stackone_client 0.23.0 → 0.25.0

data/lib/stack_one/lms.rb

@@ -308,19 +308,25 @@ module StackOne
     end
 
 
-    sig { params(lms_batch_upsert_course_request_dto: Models::Shared::LmsBatchUpsertCourseRequestDto, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsBatchUpsertCourseResponse) }
-    def batch_upsert_course(lms_batch_upsert_course_request_dto, x_account_id, retries = nil, timeout_ms = nil)
-      # batch_upsert_course - Batch Upsert Course
-      request = Models::Operations::LmsBatchUpsertCourseRequest.new(
+    sig { params(lms_create_assignment_request_dto: Models::Shared::LmsCreateAssignmentRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsCreateUserAssignmentResponse) }
+    def create_user_assignment(lms_create_assignment_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
+      # create_user_assignment - Create User Assignment
+      request = Models::Operations::LmsCreateUserAssignmentRequest.new(
         
-        lms_batch_upsert_course_request_dto: lms_batch_upsert_course_request_dto,
+        lms_create_assignment_request_dto: lms_create_assignment_request_dto,
+        id: id,
         x_account_id: x_account_id
       )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/courses/batch"
+      url = Utils.generate_url(
+        Models::Operations::LmsCreateUserAssignmentRequest,
+        base_url,
+        '/unified/lms/users/{id}/assignments',
+        request
+      )
       headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_batch_upsert_course_request_dto, :json)
+      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_assignment_request_dto, :json)
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
@@ -358,7 +364,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_batch_upsert_course',
+        operation_id: 'lms_create_user_assignment',
         security_source: @sdk_configuration.security_source
       )
 
@@ -407,7 +413,7 @@ module StackOne
       end
       
       content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
-      if Utils.match_status_code(http_response.status, ['202'])
+      if Utils.match_status_code(http_response.status, ['201'])
         if Utils.match_content_type(content_type, 'application/json')
           http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
@@ -415,12 +421,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::BatchResultApiModel)
-          response = Models::Operations::LmsBatchUpsertCourseResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CreateResult)
+          response = Models::Operations::LmsCreateUserAssignmentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            batch_result_api_model: obj
+            create_result: obj
           )
 
           return response
@@ -594,1181 +600,35 @@ module StackOne
     end
 
 
-    sig { params(lms_create_collection_request_dto: Models::Shared::LmsCreateCollectionRequestDto, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsCreateCollectionResponse) }
-    def create_collection(lms_create_collection_request_dto, x_account_id, retries = nil, timeout_ms = nil)
-      # create_collection - Create Collection
-      request = Models::Operations::LmsCreateCollectionRequest.new(
+    sig { params(lms_create_completion_request_dto: Models::Shared::LmsCreateCompletionRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsCreateUserCompletionResponse) }
+    def create_user_completion(lms_create_completion_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
+      # create_user_completion - Create User Completion
+      request = Models::Operations::LmsCreateUserCompletionRequest.new(
         
-        lms_create_collection_request_dto: lms_create_collection_request_dto,
+        lms_create_completion_request_dto: lms_create_completion_request_dto,
+        id: id,
         x_account_id: x_account_id
       )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/collections"
-      headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_collection_request_dto, :json)
-      headers['content-type'] = req_content_type
-      raise StandardError, 'request body is required' if data.nil? && form.nil?
-
-      if form
-        body = Utils.encode_form(form)
-      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
-        body = URI.encode_www_form(data)
-      else
-        body = data
-      end
-      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.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
-
-      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(
-        base_url: base_url,
-        oauth2_scopes: [],
-        operation_id: 'lms_create_collection',
-        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 = connection.post(url) do |req|
-          req.body = body
-          req.headers.merge!(headers)
-          req.options.timeout = timeout unless timeout.nil?
-          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, ['201'])
-        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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CreateResult)
-          response = Models::Operations::LmsCreateCollectionResponse.new(
-            status_code: http_response.status,
-            content_type: content_type,
-            raw_response: http_response,
-            create_result: 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadRequestResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnauthorizedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ForbiddenResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotFoundResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::RequestTimedOutResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ConflictResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::PreconditionFailedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnprocessableEntityResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::TooManyRequestsResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::InternalServerErrorResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotImplementedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadGatewayResponse)
-          throw 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(lms_create_assignment_request_dto: Models::Shared::LmsCreateAssignmentRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsCreateUserAssignmentResponse) }
-    def create_user_assignment(lms_create_assignment_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
-      # create_user_assignment - Create User Assignment
-      request = Models::Operations::LmsCreateUserAssignmentRequest.new(
-        
-        lms_create_assignment_request_dto: lms_create_assignment_request_dto,
-        id: id,
-        x_account_id: x_account_id
-      )
-      url, params = @sdk_configuration.get_server_details
-      base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::LmsCreateUserAssignmentRequest,
-        base_url,
-        '/unified/lms/users/{id}/assignments',
-        request
-      )
-      headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_assignment_request_dto, :json)
-      headers['content-type'] = req_content_type
-      raise StandardError, 'request body is required' if data.nil? && form.nil?
-
-      if form
-        body = Utils.encode_form(form)
-      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
-        body = URI.encode_www_form(data)
-      else
-        body = data
-      end
-      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.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
-
-      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(
-        base_url: base_url,
-        oauth2_scopes: [],
-        operation_id: 'lms_create_user_assignment',
-        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 = connection.post(url) do |req|
-          req.body = body
-          req.headers.merge!(headers)
-          req.options.timeout = timeout unless timeout.nil?
-          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, ['201'])
-        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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CreateResult)
-          response = Models::Operations::LmsCreateUserAssignmentResponse.new(
-            status_code: http_response.status,
-            content_type: content_type,
-            raw_response: http_response,
-            create_result: 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadRequestResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnauthorizedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ForbiddenResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotFoundResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::RequestTimedOutResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ConflictResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::PreconditionFailedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnprocessableEntityResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::TooManyRequestsResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::InternalServerErrorResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotImplementedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadGatewayResponse)
-          throw 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(lms_create_completion_request_dto: Models::Shared::LmsCreateCompletionRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsCreateUserCompletionResponse) }
-    def create_user_completion(lms_create_completion_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
-      # create_user_completion - Create User Completion
-      request = Models::Operations::LmsCreateUserCompletionRequest.new(
-        
-        lms_create_completion_request_dto: lms_create_completion_request_dto,
-        id: id,
-        x_account_id: x_account_id
-      )
-      url, params = @sdk_configuration.get_server_details
-      base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::LmsCreateUserCompletionRequest,
-        base_url,
-        '/unified/lms/users/{id}/completions',
-        request
-      )
-      headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_completion_request_dto, :json)
-      headers['content-type'] = req_content_type
-      raise StandardError, 'request body is required' if data.nil? && form.nil?
-
-      if form
-        body = Utils.encode_form(form)
-      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
-        body = URI.encode_www_form(data)
-      else
-        body = data
-      end
-      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.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
-
-      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(
-        base_url: base_url,
-        oauth2_scopes: [],
-        operation_id: 'lms_create_user_completion',
-        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 = connection.post(url) do |req|
-          req.body = body
-          req.headers.merge!(headers)
-          req.options.timeout = timeout unless timeout.nil?
-          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, ['201'])
-        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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CreateResult)
-          response = Models::Operations::LmsCreateUserCompletionResponse.new(
-            status_code: http_response.status,
-            content_type: content_type,
-            raw_response: http_response,
-            create_result: 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadRequestResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnauthorizedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ForbiddenResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotFoundResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::RequestTimedOutResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ConflictResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::PreconditionFailedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnprocessableEntityResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::TooManyRequestsResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::InternalServerErrorResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotImplementedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadGatewayResponse)
-          throw 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(id: ::String, sub_resource_id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsDeleteUserCompletionResponse) }
-    def delete_user_completion(id, sub_resource_id, x_account_id, retries = nil, timeout_ms = nil)
-      # delete_user_completion - Delete User Completion
-      request = Models::Operations::LmsDeleteUserCompletionRequest.new(
-        
-        id: id,
-        sub_resource_id: sub_resource_id,
-        x_account_id: x_account_id
-      )
-      url, params = @sdk_configuration.get_server_details
-      base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::LmsDeleteUserCompletionRequest,
-        base_url,
-        '/unified/lms/users/{id}/completions/{subResourceId}',
-        request
-      )
-      headers = Utils.get_headers(request)
-      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.nil? && !@sdk_configuration.security_source.nil? ? @sdk_configuration.security_source.call : nil
-
-      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(
-        base_url: base_url,
-        oauth2_scopes: [],
-        operation_id: 'lms_delete_user_completion',
-        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 = connection.delete(url) do |req|
-          req.headers.merge!(headers)
-          req.options.timeout = timeout unless timeout.nil?
-          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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::DeleteResult)
-          response = Models::Operations::LmsDeleteUserCompletionResponse.new(
-            status_code: http_response.status,
-            content_type: content_type,
-            raw_response: http_response,
-            delete_result: 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, ['204'])
-        http_response = @sdk_configuration.hooks.after_success(
-          hook_ctx: SDKHooks::AfterSuccessHookContext.new(
-            hook_ctx: hook_ctx
-          ),
-          response: http_response
-        )
-        return Models::Operations::LmsDeleteUserCompletionResponse.new(
-          status_code: http_response.status,
-          content_type: content_type,
-          raw_response: http_response
-        )
-      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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadRequestResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnauthorizedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ForbiddenResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotFoundResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::RequestTimedOutResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::ConflictResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::PreconditionFailedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::UnprocessableEntityResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::TooManyRequestsResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::InternalServerErrorResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::NotImplementedResponse)
-          throw 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
-          )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::BadGatewayResponse)
-          throw 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: T.nilable(Models::Operations::LmsGetAssignmentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetAssignmentResponse) }
-    def get_assignment(request, retries = nil, timeout_ms = nil)
-      # get_assignment - Get Assignment
-      url, params = @sdk_configuration.get_server_details
-      base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetAssignmentRequest,
+        Models::Operations::LmsCreateUserCompletionRequest,
         base_url,
-        '/unified/lms/assignments/{id}',
+        '/unified/lms/users/{id}/completions',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetAssignmentRequest, request)
+      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_completion_request_dto, :json)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+
+      if form
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+        body = URI.encode_www_form(data)
+      else
+        body = data
+      end
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -1796,7 +656,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_assignment',
+        operation_id: 'lms_create_user_completion',
         security_source: @sdk_configuration.security_source
       )
 
@@ -1805,10 +665,10 @@ module StackOne
       
       
       begin
-        http_response = connection.get(url) do |req|
+        http_response = connection.post(url) do |req|
+          req.body = body
           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(
@@ -1845,7 +705,7 @@ module StackOne
       end
       
       content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
-      if Utils.match_status_code(http_response.status, ['200'])
+      if Utils.match_status_code(http_response.status, ['201'])
         if Utils.match_content_type(content_type, 'application/json')
           http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
@@ -1853,12 +713,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentResult)
-          response = Models::Operations::LmsGetAssignmentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CreateResult)
+          response = Models::Operations::LmsCreateUserCompletionResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            assignment_result: obj
+            create_result: obj
           )
 
           return response
@@ -2032,19 +892,24 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetCategoryRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetCategoryResponse) }
-    def get_category(request, retries = nil, timeout_ms = nil)
-      # get_category - Get Category
+    sig { params(id: ::String, sub_resource_id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsDeleteUserCompletionResponse) }
+    def delete_user_completion(id, sub_resource_id, x_account_id, retries = nil, timeout_ms = nil)
+      # delete_user_completion - Delete User Completion
+      request = Models::Operations::LmsDeleteUserCompletionRequest.new(
+        
+        id: id,
+        sub_resource_id: sub_resource_id,
+        x_account_id: x_account_id
+      )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetCategoryRequest,
+        Models::Operations::LmsDeleteUserCompletionRequest,
         base_url,
-        '/unified/lms/categories/{id}',
+        '/unified/lms/users/{id}/completions/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetCategoryRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -2072,7 +937,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_category',
+        operation_id: 'lms_delete_user_completion',
         security_source: @sdk_configuration.security_source
       )
 
@@ -2081,10 +946,9 @@ module StackOne
       
       
       begin
-        http_response = connection.get(url) do |req|
+        http_response = connection.delete(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(
@@ -2129,18 +993,30 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CategoryResult)
-          response = Models::Operations::LmsGetCategoryResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::DeleteResult)
+          response = Models::Operations::LmsDeleteUserCompletionResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            category_result: obj
+            delete_result: 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, ['204'])
+        http_response = @sdk_configuration.hooks.after_success(
+          hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+            hook_ctx: hook_ctx
+          ),
+          response: http_response
+        )
+        return Models::Operations::LmsDeleteUserCompletionResponse.new(
+          status_code: http_response.status,
+          content_type: content_type,
+          raw_response: http_response
+        )
       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(
@@ -2308,19 +1184,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetCompletionRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetCompletionResponse) }
-    def get_completion(request, retries = nil, timeout_ms = nil)
-      # get_completion - Get Completion
+    sig { params(request: T.nilable(Models::Operations::LmsGetAssignmentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetAssignmentResponse) }
+    def get_assignment(request, retries = nil, timeout_ms = nil)
+      # get_assignment - Get Assignment
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetCompletionRequest,
+        Models::Operations::LmsGetAssignmentRequest,
         base_url,
-        '/unified/lms/completions/{id}',
+        '/unified/lms/assignments/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetCompletionRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetAssignmentRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -2348,7 +1224,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_completion',
+        operation_id: 'lms_get_assignment',
         security_source: @sdk_configuration.security_source
       )
 
@@ -2405,12 +1281,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionResult)
-          response = Models::Operations::LmsGetCompletionResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentResult)
+          response = Models::Operations::LmsGetAssignmentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            completion_result: obj
+            assignment_result: obj
           )
 
           return response
@@ -2584,19 +1460,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetContentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetContentResponse) }
-    def get_content(request, retries = nil, timeout_ms = nil)
-      # get_content - Get Content
+    sig { params(request: T.nilable(Models::Operations::LmsGetCategoryRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetCategoryResponse) }
+    def get_category(request, retries = nil, timeout_ms = nil)
+      # get_category - Get Category
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetContentRequest,
+        Models::Operations::LmsGetCategoryRequest,
         base_url,
-        '/unified/lms/content/{id}',
+        '/unified/lms/categories/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetContentRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetCategoryRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -2624,7 +1500,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_content',
+        operation_id: 'lms_get_category',
         security_source: @sdk_configuration.security_source
       )
 
@@ -2681,12 +1557,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::ContentResult)
-          response = Models::Operations::LmsGetContentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CategoryResult)
+          response = Models::Operations::LmsGetCategoryResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            content_result: obj
+            category_result: obj
           )
 
           return response
@@ -2860,19 +1736,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetCourseRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetCourseResponse) }
-    def get_course(request, retries = nil, timeout_ms = nil)
-      # get_course - Get Course
+    sig { params(request: T.nilable(Models::Operations::LmsGetCompletionRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetCompletionResponse) }
+    def get_completion(request, retries = nil, timeout_ms = nil)
+      # get_completion - Get Completion
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetCourseRequest,
+        Models::Operations::LmsGetCompletionRequest,
         base_url,
-        '/unified/lms/courses/{id}',
+        '/unified/lms/completions/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetCourseRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetCompletionRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -2900,7 +1776,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_course',
+        operation_id: 'lms_get_completion',
         security_source: @sdk_configuration.security_source
       )
 
@@ -2957,12 +1833,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CourseResult)
-          response = Models::Operations::LmsGetCourseResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionResult)
+          response = Models::Operations::LmsGetCompletionResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            course_result: obj
+            completion_result: obj
           )
 
           return response
@@ -3136,19 +2012,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetSkillRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetSkillResponse) }
-    def get_skill(request, retries = nil, timeout_ms = nil)
-      # get_skill - Get Skill
+    sig { params(request: T.nilable(Models::Operations::LmsGetContentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetContentResponse) }
+    def get_content(request, retries = nil, timeout_ms = nil)
+      # get_content - Get Content
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetSkillRequest,
+        Models::Operations::LmsGetContentRequest,
         base_url,
-        '/unified/lms/skills/{id}',
+        '/unified/lms/content/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetSkillRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetContentRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3176,7 +2052,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_skill',
+        operation_id: 'lms_get_content',
         security_source: @sdk_configuration.security_source
       )
 
@@ -3233,12 +2109,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::SkillResult)
-          response = Models::Operations::LmsGetSkillResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::ContentResult)
+          response = Models::Operations::LmsGetContentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            skill_result: obj
+            content_result: obj
           )
 
           return response
@@ -3412,19 +2288,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetUserRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetUserResponse) }
-    def get_user(request, retries = nil, timeout_ms = nil)
-      # get_user - Get User
+    sig { params(request: T.nilable(Models::Operations::LmsGetCourseRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetCourseResponse) }
+    def get_course(request, retries = nil, timeout_ms = nil)
+      # get_course - Get Course
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetUserRequest,
+        Models::Operations::LmsGetCourseRequest,
         base_url,
-        '/unified/lms/users/{id}',
+        '/unified/lms/courses/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetUserRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetCourseRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3452,7 +2328,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_user',
+        operation_id: 'lms_get_course',
         security_source: @sdk_configuration.security_source
       )
 
@@ -3509,12 +2385,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UserResult)
-          response = Models::Operations::LmsGetUserResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CourseResult)
+          response = Models::Operations::LmsGetCourseResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            user_result: obj
+            course_result: obj
           )
 
           return response
@@ -3688,19 +2564,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetUserAssignmentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetUserAssignmentResponse) }
-    def get_user_assignment(request, retries = nil, timeout_ms = nil)
-      # get_user_assignment - Get User Assignment
+    sig { params(request: T.nilable(Models::Operations::LmsGetSkillRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetSkillResponse) }
+    def get_skill(request, retries = nil, timeout_ms = nil)
+      # get_skill - Get Skill
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsGetUserAssignmentRequest,
+        Models::Operations::LmsGetSkillRequest,
         base_url,
-        '/unified/lms/users/{id}/assignments/{subResourceId}',
+        '/unified/lms/skills/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetUserAssignmentRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetSkillRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3728,7 +2604,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_user_assignment',
+        operation_id: 'lms_get_skill',
         security_source: @sdk_configuration.security_source
       )
 
@@ -3785,12 +2661,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentResult)
-          response = Models::Operations::LmsGetUserAssignmentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::SkillResult)
+          response = Models::Operations::LmsGetSkillResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            assignment_result: obj
+            skill_result: obj
           )
 
           return response
@@ -3964,19 +2840,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsGetUserCompletionRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetUserCompletionResponse) }
-    def get_user_completion(request, retries = nil, timeout_ms = nil)
-      # get_user_completion - Get User Completion
+    sig { params(request: T.nilable(Models::Operations::LmsGetUserRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetUserResponse) }
+    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::LmsGetUserCompletionRequest,
+        Models::Operations::LmsGetUserRequest,
         base_url,
-        '/unified/lms/users/{id}/completions/{subResourceId}',
+        '/unified/lms/users/{id}',
         request
       )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsGetUserCompletionRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetUserRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4004,7 +2880,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_get_user_completion',
+        operation_id: 'lms_get_user',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4061,12 +2937,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionResult)
-          response = Models::Operations::LmsGetUserCompletionResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UserResult)
+          response = Models::Operations::LmsGetUserResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            completion_result: obj
+            user_result: obj
           )
 
           return response
@@ -4240,14 +3116,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListAssignmentsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListAssignmentsResponse) }
-    def list_assignments(request, retries = nil, timeout_ms = nil)
-      # list_assignments - List Assignments
+    sig { params(request: T.nilable(Models::Operations::LmsGetUserAssignmentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetUserAssignmentResponse) }
+    def get_user_assignment(request, retries = nil, timeout_ms = nil)
+      # get_user_assignment - Get User Assignment
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/assignments"
+      url = Utils.generate_url(
+        Models::Operations::LmsGetUserAssignmentRequest,
+        base_url,
+        '/unified/lms/users/{id}/assignments/{subResourceId}',
+        request
+      )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListAssignmentsRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetUserAssignmentRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4275,7 +3156,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_assignments',
+        operation_id: 'lms_get_user_assignment',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4332,12 +3213,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentsPaginated)
-          response = Models::Operations::LmsListAssignmentsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentResult)
+          response = Models::Operations::LmsGetUserAssignmentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            assignments_paginated: obj
+            assignment_result: obj
           )
 
           return response
@@ -4511,14 +3392,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListCategoriesRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListCategoriesResponse) }
-    def list_categories(request, retries = nil, timeout_ms = nil)
-      # list_categories - List Categories
+    sig { params(request: T.nilable(Models::Operations::LmsGetUserCompletionRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsGetUserCompletionResponse) }
+    def get_user_completion(request, retries = nil, timeout_ms = nil)
+      # get_user_completion - Get User Completion
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/categories"
+      url = Utils.generate_url(
+        Models::Operations::LmsGetUserCompletionRequest,
+        base_url,
+        '/unified/lms/users/{id}/completions/{subResourceId}',
+        request
+      )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListCategoriesRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsGetUserCompletionRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4546,7 +3432,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_categories',
+        operation_id: 'lms_get_user_completion',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4603,12 +3489,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CategoriesPaginated)
-          response = Models::Operations::LmsListCategoriesResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionResult)
+          response = Models::Operations::LmsGetUserCompletionResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            categories_paginated: obj
+            completion_result: obj
           )
 
           return response
@@ -4781,15 +3667,15 @@ module StackOne
       end
     end
 
-
-    sig { params(request: T.nilable(Models::Operations::LmsListCompletionsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListCompletionsResponse) }
-    def list_completions(request, retries = nil, timeout_ms = nil)
-      # list_completions - List Completions
+
+    sig { params(request: T.nilable(Models::Operations::LmsListAssignmentsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListAssignmentsResponse) }
+    def list_assignments(request, retries = nil, timeout_ms = nil)
+      # list_assignments - List Assignments
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/completions"
+      url = "#{base_url}/unified/lms/assignments"
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListCompletionsRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListAssignmentsRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4817,7 +3703,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_completions',
+        operation_id: 'lms_list_assignments',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4874,12 +3760,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionsPaginated)
-          response = Models::Operations::LmsListCompletionsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentsPaginated)
+          response = Models::Operations::LmsListAssignmentsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            completions_paginated: obj
+            assignments_paginated: obj
           )
 
           return response
@@ -5053,14 +3939,14 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListContentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListContentResponse) }
-    def list_content(request, retries = nil, timeout_ms = nil)
-      # list_content - List Content
+    sig { params(request: T.nilable(Models::Operations::LmsListCategoriesRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListCategoriesResponse) }
+    def list_categories(request, retries = nil, timeout_ms = nil)
+      # list_categories - List Categories
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/content"
+      url = "#{base_url}/unified/lms/categories"
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListContentRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListCategoriesRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5088,7 +3974,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_content',
+        operation_id: 'lms_list_categories',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5145,12 +4031,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::ContentPaginated)
-          response = Models::Operations::LmsListContentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CategoriesPaginated)
+          response = Models::Operations::LmsListCategoriesResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            content_paginated: obj
+            categories_paginated: obj
           )
 
           return response
@@ -5324,14 +4210,14 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListCoursesRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListCoursesResponse) }
-    def list_courses(request, retries = nil, timeout_ms = nil)
-      # list_courses - List Courses
+    sig { params(request: T.nilable(Models::Operations::LmsListCompletionsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListCompletionsResponse) }
+    def list_completions(request, retries = nil, timeout_ms = nil)
+      # list_completions - List Completions
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/courses"
+      url = "#{base_url}/unified/lms/completions"
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListCoursesRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListCompletionsRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5359,7 +4245,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_courses',
+        operation_id: 'lms_list_completions',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5416,12 +4302,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CoursePaginated)
-          response = Models::Operations::LmsListCoursesResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionsPaginated)
+          response = Models::Operations::LmsListCompletionsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            course_paginated: obj
+            completions_paginated: obj
           )
 
           return response
@@ -5595,14 +4481,14 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListSkillsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListSkillsResponse) }
-    def list_skills(request, retries = nil, timeout_ms = nil)
-      # list_skills - List Skills
+    sig { params(request: T.nilable(Models::Operations::LmsListContentRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListContentResponse) }
+    def list_content(request, retries = nil, timeout_ms = nil)
+      # list_content - List Content
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/skills"
+      url = "#{base_url}/unified/lms/content"
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListSkillsRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListContentRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5630,7 +4516,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_skills',
+        operation_id: 'lms_list_content',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5687,12 +4573,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::SkillsPaginated)
-          response = Models::Operations::LmsListSkillsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::ContentPaginated)
+          response = Models::Operations::LmsListContentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            skills_paginated: obj
+            content_paginated: obj
           )
 
           return response
@@ -5866,19 +4752,14 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListUserAssignmentsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListUserAssignmentsResponse) }
-    def list_user_assignments(request, retries = nil, timeout_ms = nil)
-      # list_user_assignments - List User Assignments
+    sig { params(request: T.nilable(Models::Operations::LmsListCoursesRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListCoursesResponse) }
+    def list_courses(request, retries = nil, timeout_ms = nil)
+      # list_courses - List Courses
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::LmsListUserAssignmentsRequest,
-        base_url,
-        '/unified/lms/users/{id}/assignments',
-        request
-      )
+      url = "#{base_url}/unified/lms/courses"
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListUserAssignmentsRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListCoursesRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5906,7 +4787,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_user_assignments',
+        operation_id: 'lms_list_courses',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5963,12 +4844,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentsPaginated)
-          response = Models::Operations::LmsListUserAssignmentsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CoursePaginated)
+          response = Models::Operations::LmsListCoursesResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            assignments_paginated: obj
+            course_paginated: obj
           )
 
           return response
@@ -6142,19 +5023,14 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListUserCompletionsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListUserCompletionsResponse) }
-    def list_user_completions(request, retries = nil, timeout_ms = nil)
-      # list_user_completions - List User Completions
+    sig { params(request: T.nilable(Models::Operations::LmsListSkillsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListSkillsResponse) }
+    def list_skills(request, retries = nil, timeout_ms = nil)
+      # list_skills - List Skills
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::LmsListUserCompletionsRequest,
-        base_url,
-        '/unified/lms/users/{id}/completions',
-        request
-      )
+      url = "#{base_url}/unified/lms/skills"
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListUserCompletionsRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListSkillsRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6182,7 +5058,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_user_completions',
+        operation_id: 'lms_list_skills',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6239,12 +5115,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionsPaginated)
-          response = Models::Operations::LmsListUserCompletionsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::SkillsPaginated)
+          response = Models::Operations::LmsListSkillsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            completions_paginated: obj
+            skills_paginated: obj
           )
 
           return response
@@ -6418,14 +5294,19 @@ module StackOne
     end
 
 
-    sig { params(request: T.nilable(Models::Operations::LmsListUsersRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListUsersResponse) }
-    def list_users(request, retries = nil, timeout_ms = nil)
-      # list_users - List Users
+    sig { params(request: T.nilable(Models::Operations::LmsListUserAssignmentsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListUserAssignmentsResponse) }
+    def list_user_assignments(request, retries = nil, timeout_ms = nil)
+      # list_user_assignments - List User Assignments
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/users"
+      url = Utils.generate_url(
+        Models::Operations::LmsListUserAssignmentsRequest,
+        base_url,
+        '/unified/lms/users/{id}/assignments',
+        request
+      )
       headers = Utils.get_headers(request)
-      query_params = Utils.get_query_params(Models::Operations::LmsListUsersRequest, request)
+      query_params = Utils.get_query_params(Models::Operations::LmsListUserAssignmentsRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6453,7 +5334,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_list_users',
+        operation_id: 'lms_list_user_assignments',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6510,12 +5391,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UsersPaginated)
-          response = Models::Operations::LmsListUsersResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::AssignmentsPaginated)
+          response = Models::Operations::LmsListUserAssignmentsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            users_paginated: obj
+            assignments_paginated: obj
           )
 
           return response
@@ -6689,35 +5570,19 @@ module StackOne
     end
 
 
-    sig { params(lms_create_collection_request_dto: Models::Shared::LmsCreateCollectionRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsUpdateCollectionResponse) }
-    def update_collection(lms_create_collection_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
-      # update_collection - Update Collection
-      request = Models::Operations::LmsUpdateCollectionRequest.new(
-        
-        lms_create_collection_request_dto: lms_create_collection_request_dto,
-        id: id,
-        x_account_id: x_account_id
-      )
+    sig { params(request: T.nilable(Models::Operations::LmsListUserCompletionsRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListUserCompletionsResponse) }
+    def list_user_completions(request, retries = nil, timeout_ms = nil)
+      # list_user_completions - List User Completions
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::LmsUpdateCollectionRequest,
+        Models::Operations::LmsListUserCompletionsRequest,
         base_url,
-        '/unified/lms/collections/{id}',
+        '/unified/lms/users/{id}/completions',
         request
       )
       headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_collection_request_dto, :json)
-      headers['content-type'] = req_content_type
-      raise StandardError, 'request body is required' if data.nil? && form.nil?
-
-      if form
-        body = Utils.encode_form(form)
-      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
-        body = URI.encode_www_form(data)
-      else
-        body = data
-      end
+      query_params = Utils.get_query_params(Models::Operations::LmsListUserCompletionsRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6745,7 +5610,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_update_collection',
+        operation_id: 'lms_list_user_completions',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6754,10 +5619,10 @@ module StackOne
       
       
       begin
-        http_response = connection.patch(url) do |req|
-          req.body = body
+        http_response = 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(
@@ -6794,7 +5659,7 @@ module StackOne
       end
       
       content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
-      if Utils.match_status_code(http_response.status, ['201'])
+      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(
@@ -6802,12 +5667,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UpdateResult)
-          response = Models::Operations::LmsUpdateCollectionResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::CompletionsPaginated)
+          response = Models::Operations::LmsListUserCompletionsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            update_result: obj
+            completions_paginated: obj
           )
 
           return response
@@ -6981,35 +5846,14 @@ module StackOne
     end
 
 
-    sig { params(lms_create_content_request_dto: Models::Shared::LmsCreateContentRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsUpdateContentResponse) }
-    def update_content(lms_create_content_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
-      # update_content - Update Content
-      request = Models::Operations::LmsUpdateContentRequest.new(
-        
-        lms_create_content_request_dto: lms_create_content_request_dto,
-        id: id,
-        x_account_id: x_account_id
-      )
+    sig { params(request: T.nilable(Models::Operations::LmsListUsersRequest), retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsListUsersResponse) }
+    def list_users(request, retries = nil, timeout_ms = nil)
+      # list_users - List Users
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::LmsUpdateContentRequest,
-        base_url,
-        '/unified/lms/content/{id}',
-        request
-      )
+      url = "#{base_url}/unified/lms/users"
       headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_content_request_dto, :json)
-      headers['content-type'] = req_content_type
-      raise StandardError, 'request body is required' if data.nil? && form.nil?
-
-      if form
-        body = Utils.encode_form(form)
-      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
-        body = URI.encode_www_form(data)
-      else
-        body = data
-      end
+      query_params = Utils.get_query_params(Models::Operations::LmsListUsersRequest, request)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -7037,7 +5881,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_update_content',
+        operation_id: 'lms_list_users',
         security_source: @sdk_configuration.security_source
       )
 
@@ -7046,10 +5890,10 @@ module StackOne
       
       
       begin
-        http_response = connection.patch(url) do |req|
-          req.body = body
+        http_response = 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(
@@ -7086,7 +5930,7 @@ module StackOne
       end
       
       content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
-      if Utils.match_status_code(http_response.status, ['201'])
+      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(
@@ -7094,12 +5938,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UpdateResult)
-          response = Models::Operations::LmsUpdateContentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UsersPaginated)
+          response = Models::Operations::LmsListUsersResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            update_result: obj
+            users_paginated: obj
           )
 
           return response
@@ -7273,19 +6117,25 @@ module StackOne
     end
 
 
-    sig { params(lms_upsert_content_request_dto: Models::Shared::LmsUpsertContentRequestDto, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsUpsertContentResponse) }
-    def upsert_content(lms_upsert_content_request_dto, x_account_id, retries = nil, timeout_ms = nil)
-      # upsert_content - Upsert Content
-      request = Models::Operations::LmsUpsertContentRequest.new(
+    sig { params(lms_create_content_request_dto: Models::Shared::LmsCreateContentRequestDto, id: ::String, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsUpdateContentResponse) }
+    def update_content(lms_create_content_request_dto, id, x_account_id, retries = nil, timeout_ms = nil)
+      # update_content - Update Content
+      request = Models::Operations::LmsUpdateContentRequest.new(
         
-        lms_upsert_content_request_dto: lms_upsert_content_request_dto,
+        lms_create_content_request_dto: lms_create_content_request_dto,
+        id: id,
         x_account_id: x_account_id
       )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/content"
+      url = Utils.generate_url(
+        Models::Operations::LmsUpdateContentRequest,
+        base_url,
+        '/unified/lms/content/{id}',
+        request
+      )
       headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_upsert_content_request_dto, :json)
+      req_content_type, data, form = Utils.serialize_request_body(request, :lms_create_content_request_dto, :json)
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
@@ -7323,7 +6173,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_upsert_content',
+        operation_id: 'lms_update_content',
         security_source: @sdk_configuration.security_source
       )
 
@@ -7332,7 +6182,7 @@ module StackOne
       
       
       begin
-        http_response = connection.put(url) do |req|
+        http_response = connection.patch(url) do |req|
           req.body = body
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
@@ -7380,12 +6230,12 @@ module StackOne
             ),
             response: http_response
           )
-          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UpsertResult)
-          response = Models::Operations::LmsUpsertContentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UpdateResult)
+          response = Models::Operations::LmsUpdateContentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
-            upsert_result: obj
+            update_result: obj
           )
 
           return response
@@ -7559,19 +6409,19 @@ module StackOne
     end
 
 
-    sig { params(lms_upsert_course_request_dto: Models::Shared::LmsUpsertCourseRequestDto, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsUpsertCourseResponse) }
-    def upsert_course(lms_upsert_course_request_dto, x_account_id, retries = nil, timeout_ms = nil)
-      # upsert_course - Upsert Course
-      request = Models::Operations::LmsUpsertCourseRequest.new(
+    sig { params(lms_upsert_content_request_dto: Models::Shared::LmsUpsertContentRequestDto, x_account_id: ::String, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::LmsUpsertContentResponse) }
+    def upsert_content(lms_upsert_content_request_dto, x_account_id, retries = nil, timeout_ms = nil)
+      # upsert_content - Upsert Content
+      request = Models::Operations::LmsUpsertContentRequest.new(
         
-        lms_upsert_course_request_dto: lms_upsert_course_request_dto,
+        lms_upsert_content_request_dto: lms_upsert_content_request_dto,
         x_account_id: x_account_id
       )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/lms/courses"
+      url = "#{base_url}/unified/lms/content"
       headers = Utils.get_headers(request)
-      req_content_type, data, form = Utils.serialize_request_body(request, :lms_upsert_course_request_dto, :json)
+      req_content_type, data, form = Utils.serialize_request_body(request, :lms_upsert_content_request_dto, :json)
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
@@ -7609,7 +6459,7 @@ module StackOne
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'lms_upsert_course',
+        operation_id: 'lms_upsert_content',
         security_source: @sdk_configuration.security_source
       )
 
@@ -7667,7 +6517,7 @@ module StackOne
             response: http_response
           )
           obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Shared::UpsertResult)
-          response = Models::Operations::LmsUpsertCourseResponse.new(
+          response = Models::Operations::LmsUpsertContentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,