stackone_client 0.35.0 → 0.36.1

data/lib/stack_one/models/operations/lms_get_category_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetCategoryResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetCategoryResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def headers(); end
+  def headers=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def category_result(); end
+  def category_result=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_completion_request.rb

@@ -18,15 +18,14 @@ module StackOne
         # The account identifier
         field :x_account_id, ::String, { 'header': { 'field_name': 'x-account-id', 'style': 'simple', 'explode': false } }
         # The comma separated list of fields to return in the response (if empty, all fields are returned)
-        field :fields_, T.nilable(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
+        field :fields_, Crystalline::Nilable.new(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
         # Query parameters that can be used to pass through parameters to the underlying provider request by surrounding them with 'proxy' key
-        field :proxy, T.nilable(T::Hash[Symbol, ::Object]), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
+        field :proxy, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::Object)), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
         # Indicates that the raw request result should be returned in addition to the mapped result (default value is false)
-        field :raw, T.nilable(T::Boolean), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
-
+        field :raw, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
 
         sig { params(id: ::String, x_account_id: ::String, fields_: T.nilable(::String), proxy: T.nilable(T::Hash[Symbol, ::Object]), raw: T.nilable(T::Boolean)).void }
-        def initialize(id: nil, x_account_id: nil, fields_: nil, proxy: nil, raw: nil)
+        def initialize(id:, x_account_id:, fields_: nil, proxy: nil, raw: nil)
           @id = id
           @x_account_id = x_account_id
           @fields_ = fields_
@@ -34,6 +33,7 @@ module StackOne
           @raw = raw
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @id == other.id

data/lib/stack_one/models/operations/lms_get_completion_request.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetCompletionRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetCompletionRequest
+  def id(); end
+  def id=(str_); end
+  def x_account_id(); end
+  def x_account_id=(str_); end
+  def fields_(); end
+  def fields_=(str_); end
+  def proxy(); end
+  def proxy=(str_); end
+  def raw(); end
+  def raw=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_completion_response.rb

@@ -16,30 +16,30 @@ module StackOne
         # HTTP response content type for this operation
         field :content_type, ::String
 
-        field :headers, T::Hash[Symbol, T::Array[::String]]
-        # Raw HTTP response; suitable for custom response parsing
-        field :raw_response, ::Faraday::Response
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
         # HTTP response status code for this operation
         field :status_code, ::Integer
+        # Raw HTTP response; suitable for custom response parsing
+        field :raw_response, ::Faraday::Response
         # The completion with the given identifier was retrieved.
-        field :completion_result, T.nilable(Models::Shared::CompletionResult)
-
+        field :completion_result, Crystalline::Nilable.new(Models::Shared::CompletionResult)
 
-        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], raw_response: ::Faraday::Response, status_code: ::Integer, completion_result: T.nilable(Models::Shared::CompletionResult)).void }
-        def initialize(content_type: nil, headers: nil, raw_response: nil, status_code: nil, completion_result: nil)
+        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], status_code: ::Integer, raw_response: ::Faraday::Response, completion_result: T.nilable(Models::Shared::CompletionResult)).void }
+        def initialize(content_type:, headers:, status_code:, raw_response:, completion_result: nil)
           @content_type = content_type
           @headers = headers
-          @raw_response = raw_response
           @status_code = status_code
+          @raw_response = raw_response
           @completion_result = completion_result
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @content_type == other.content_type
           return false unless @headers == other.headers
-          return false unless @raw_response == other.raw_response
           return false unless @status_code == other.status_code
+          return false unless @raw_response == other.raw_response
           return false unless @completion_result == other.completion_result
           true
         end

data/lib/stack_one/models/operations/lms_get_completion_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetCompletionResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetCompletionResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def headers(); end
+  def headers=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def completion_result(); end
+  def completion_result=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_content_request.rb

@@ -18,15 +18,14 @@ module StackOne
         # The account identifier
         field :x_account_id, ::String, { 'header': { 'field_name': 'x-account-id', 'style': 'simple', 'explode': false } }
         # The comma separated list of fields that will be returned in the response (if empty, all fields are returned)
-        field :fields_, T.nilable(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
+        field :fields_, Crystalline::Nilable.new(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
         # Query parameters that can be used to pass through parameters to the underlying provider request by surrounding them with 'proxy' key
-        field :proxy, T.nilable(T::Hash[Symbol, ::Object]), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
+        field :proxy, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::Object)), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
         # Indicates that the raw request result should be returned in addition to the mapped result (default value is false)
-        field :raw, T.nilable(T::Boolean), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
-
+        field :raw, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
 
         sig { params(id: ::String, x_account_id: ::String, fields_: T.nilable(::String), proxy: T.nilable(T::Hash[Symbol, ::Object]), raw: T.nilable(T::Boolean)).void }
-        def initialize(id: nil, x_account_id: nil, fields_: nil, proxy: nil, raw: nil)
+        def initialize(id:, x_account_id:, fields_: nil, proxy: nil, raw: nil)
           @id = id
           @x_account_id = x_account_id
           @fields_ = fields_
@@ -34,6 +33,7 @@ module StackOne
           @raw = raw
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @id == other.id

data/lib/stack_one/models/operations/lms_get_content_request.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetContentRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetContentRequest
+  def id(); end
+  def id=(str_); end
+  def x_account_id(); end
+  def x_account_id=(str_); end
+  def fields_(); end
+  def fields_=(str_); end
+  def proxy(); end
+  def proxy=(str_); end
+  def raw(); end
+  def raw=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_content_response.rb

@@ -16,30 +16,30 @@ module StackOne
         # HTTP response content type for this operation
         field :content_type, ::String
 
-        field :headers, T::Hash[Symbol, T::Array[::String]]
-        # Raw HTTP response; suitable for custom response parsing
-        field :raw_response, ::Faraday::Response
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
         # HTTP response status code for this operation
         field :status_code, ::Integer
+        # Raw HTTP response; suitable for custom response parsing
+        field :raw_response, ::Faraday::Response
         # The content with the given identifier was retrieved.
-        field :content_result, T.nilable(Models::Shared::ContentResult)
-
+        field :content_result, Crystalline::Nilable.new(Models::Shared::ContentResult)
 
-        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], raw_response: ::Faraday::Response, status_code: ::Integer, content_result: T.nilable(Models::Shared::ContentResult)).void }
-        def initialize(content_type: nil, headers: nil, raw_response: nil, status_code: nil, content_result: nil)
+        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], status_code: ::Integer, raw_response: ::Faraday::Response, content_result: T.nilable(Models::Shared::ContentResult)).void }
+        def initialize(content_type:, headers:, status_code:, raw_response:, content_result: nil)
           @content_type = content_type
           @headers = headers
-          @raw_response = raw_response
           @status_code = status_code
+          @raw_response = raw_response
           @content_result = content_result
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @content_type == other.content_type
           return false unless @headers == other.headers
-          return false unless @raw_response == other.raw_response
           return false unless @status_code == other.status_code
+          return false unless @raw_response == other.raw_response
           return false unless @content_result == other.content_result
           true
         end

data/lib/stack_one/models/operations/lms_get_content_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetContentResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetContentResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def headers(); end
+  def headers=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def content_result(); end
+  def content_result=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_course_request.rb

@@ -18,15 +18,14 @@ module StackOne
         # The account identifier
         field :x_account_id, ::String, { 'header': { 'field_name': 'x-account-id', 'style': 'simple', 'explode': false } }
         # The comma separated list of fields that will be returned in the response (if empty, all fields are returned)
-        field :fields_, T.nilable(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
+        field :fields_, Crystalline::Nilable.new(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
         # Query parameters that can be used to pass through parameters to the underlying provider request by surrounding them with 'proxy' key
-        field :proxy, T.nilable(T::Hash[Symbol, ::Object]), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
+        field :proxy, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::Object)), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
         # Indicates that the raw request result should be returned in addition to the mapped result (default value is false)
-        field :raw, T.nilable(T::Boolean), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
-
+        field :raw, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
 
         sig { params(id: ::String, x_account_id: ::String, fields_: T.nilable(::String), proxy: T.nilable(T::Hash[Symbol, ::Object]), raw: T.nilable(T::Boolean)).void }
-        def initialize(id: nil, x_account_id: nil, fields_: nil, proxy: nil, raw: nil)
+        def initialize(id:, x_account_id:, fields_: nil, proxy: nil, raw: nil)
           @id = id
           @x_account_id = x_account_id
           @fields_ = fields_
@@ -34,6 +33,7 @@ module StackOne
           @raw = raw
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @id == other.id

data/lib/stack_one/models/operations/lms_get_course_request.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetCourseRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetCourseRequest
+  def id(); end
+  def id=(str_); end
+  def x_account_id(); end
+  def x_account_id=(str_); end
+  def fields_(); end
+  def fields_=(str_); end
+  def proxy(); end
+  def proxy=(str_); end
+  def raw(); end
+  def raw=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_course_response.rb

@@ -16,30 +16,30 @@ module StackOne
         # HTTP response content type for this operation
         field :content_type, ::String
 
-        field :headers, T::Hash[Symbol, T::Array[::String]]
-        # Raw HTTP response; suitable for custom response parsing
-        field :raw_response, ::Faraday::Response
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
         # HTTP response status code for this operation
         field :status_code, ::Integer
+        # Raw HTTP response; suitable for custom response parsing
+        field :raw_response, ::Faraday::Response
         # The course with the given identifier was retrieved.
-        field :course_result, T.nilable(Models::Shared::CourseResult)
-
+        field :course_result, Crystalline::Nilable.new(Models::Shared::CourseResult)
 
-        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], raw_response: ::Faraday::Response, status_code: ::Integer, course_result: T.nilable(Models::Shared::CourseResult)).void }
-        def initialize(content_type: nil, headers: nil, raw_response: nil, status_code: nil, course_result: nil)
+        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], status_code: ::Integer, raw_response: ::Faraday::Response, course_result: T.nilable(Models::Shared::CourseResult)).void }
+        def initialize(content_type:, headers:, status_code:, raw_response:, course_result: nil)
           @content_type = content_type
           @headers = headers
-          @raw_response = raw_response
           @status_code = status_code
+          @raw_response = raw_response
           @course_result = course_result
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @content_type == other.content_type
           return false unless @headers == other.headers
-          return false unless @raw_response == other.raw_response
           return false unless @status_code == other.status_code
+          return false unless @raw_response == other.raw_response
           return false unless @course_result == other.course_result
           true
         end

data/lib/stack_one/models/operations/lms_get_course_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetCourseResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetCourseResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def headers(); end
+  def headers=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def course_result(); end
+  def course_result=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_skill_request.rb

@@ -18,15 +18,14 @@ module StackOne
         # The account identifier
         field :x_account_id, ::String, { 'header': { 'field_name': 'x-account-id', 'style': 'simple', 'explode': false } }
         # The comma separated list of fields that will be returned in the response (if empty, all fields are returned)
-        field :fields_, T.nilable(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
+        field :fields_, Crystalline::Nilable.new(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
         # Query parameters that can be used to pass through parameters to the underlying provider request by surrounding them with 'proxy' key
-        field :proxy, T.nilable(T::Hash[Symbol, ::Object]), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
+        field :proxy, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::Object)), { 'query_param': { 'field_name': 'proxy', 'style': 'form', 'explode': true } }
         # Indicates that the raw request result should be returned in addition to the mapped result (default value is false)
-        field :raw, T.nilable(T::Boolean), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
-
+        field :raw, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
 
         sig { params(id: ::String, x_account_id: ::String, fields_: T.nilable(::String), proxy: T.nilable(T::Hash[Symbol, ::Object]), raw: T.nilable(T::Boolean)).void }
-        def initialize(id: nil, x_account_id: nil, fields_: nil, proxy: nil, raw: nil)
+        def initialize(id:, x_account_id:, fields_: nil, proxy: nil, raw: nil)
           @id = id
           @x_account_id = x_account_id
           @fields_ = fields_
@@ -34,6 +33,7 @@ module StackOne
           @raw = raw
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @id == other.id

data/lib/stack_one/models/operations/lms_get_skill_request.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetSkillRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetSkillRequest
+  def id(); end
+  def id=(str_); end
+  def x_account_id(); end
+  def x_account_id=(str_); end
+  def fields_(); end
+  def fields_=(str_); end
+  def proxy(); end
+  def proxy=(str_); end
+  def raw(); end
+  def raw=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_skill_response.rb

@@ -16,30 +16,30 @@ module StackOne
         # HTTP response content type for this operation
         field :content_type, ::String
 
-        field :headers, T::Hash[Symbol, T::Array[::String]]
-        # Raw HTTP response; suitable for custom response parsing
-        field :raw_response, ::Faraday::Response
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
         # HTTP response status code for this operation
         field :status_code, ::Integer
+        # Raw HTTP response; suitable for custom response parsing
+        field :raw_response, ::Faraday::Response
         # The skill with the given identifier was retrieved.
-        field :skill_result, T.nilable(Models::Shared::SkillResult)
-
+        field :skill_result, Crystalline::Nilable.new(Models::Shared::SkillResult)
 
-        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], raw_response: ::Faraday::Response, status_code: ::Integer, skill_result: T.nilable(Models::Shared::SkillResult)).void }
-        def initialize(content_type: nil, headers: nil, raw_response: nil, status_code: nil, skill_result: nil)
+        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], status_code: ::Integer, raw_response: ::Faraday::Response, skill_result: T.nilable(Models::Shared::SkillResult)).void }
+        def initialize(content_type:, headers:, status_code:, raw_response:, skill_result: nil)
           @content_type = content_type
           @headers = headers
-          @raw_response = raw_response
           @status_code = status_code
+          @raw_response = raw_response
           @skill_result = skill_result
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @content_type == other.content_type
           return false unless @headers == other.headers
-          return false unless @raw_response == other.raw_response
           return false unless @status_code == other.status_code
+          return false unless @raw_response == other.raw_response
           return false unless @skill_result == other.skill_result
           true
         end

data/lib/stack_one/models/operations/lms_get_skill_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetSkillResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetSkillResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def headers(); end
+  def headers=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def skill_result(); end
+  def skill_result=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_user_assignment_request.rb

@@ -20,15 +20,14 @@ module StackOne
         # The account identifier
         field :x_account_id, ::String, { 'header': { 'field_name': 'x-account-id', 'style': 'simple', 'explode': false } }
         # The comma separated list of fields to return in the response (if empty, all fields are returned)
-        field :fields_, T.nilable(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
+        field :fields_, Crystalline::Nilable.new(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
         # Query parameters that can be used to pass through parameters to the underlying provider request by surrounding them with 'proxy' key
-        field :proxy, T.nilable(T::Hash[Symbol, ::Object]), { 'query_param': { 'field_name': 'proxy', 'style': 'deepObject', 'explode': true } }
+        field :proxy, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::Object)), { 'query_param': { 'field_name': 'proxy', 'style': 'deepObject', 'explode': true } }
         # Indicates that the raw request result should be returned in addition to the mapped result (default value is false)
-        field :raw, T.nilable(T::Boolean), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
-
+        field :raw, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
 
         sig { params(id: ::String, sub_resource_id: ::String, x_account_id: ::String, fields_: T.nilable(::String), proxy: T.nilable(T::Hash[Symbol, ::Object]), raw: T.nilable(T::Boolean)).void }
-        def initialize(id: nil, sub_resource_id: nil, x_account_id: nil, fields_: nil, proxy: nil, raw: nil)
+        def initialize(id:, sub_resource_id:, x_account_id:, fields_: nil, proxy: nil, raw: nil)
           @id = id
           @sub_resource_id = sub_resource_id
           @x_account_id = x_account_id
@@ -37,6 +36,7 @@ module StackOne
           @raw = raw
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @id == other.id

data/lib/stack_one/models/operations/lms_get_user_assignment_request.rbi

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetUserAssignmentRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetUserAssignmentRequest
+  def id(); end
+  def id=(str_); end
+  def sub_resource_id(); end
+  def sub_resource_id=(str_); end
+  def x_account_id(); end
+  def x_account_id=(str_); end
+  def fields_(); end
+  def fields_=(str_); end
+  def proxy(); end
+  def proxy=(str_); end
+  def raw(); end
+  def raw=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_user_assignment_response.rb

@@ -16,30 +16,30 @@ module StackOne
         # HTTP response content type for this operation
         field :content_type, ::String
 
-        field :headers, T::Hash[Symbol, T::Array[::String]]
-        # Raw HTTP response; suitable for custom response parsing
-        field :raw_response, ::Faraday::Response
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
         # HTTP response status code for this operation
         field :status_code, ::Integer
+        # Raw HTTP response; suitable for custom response parsing
+        field :raw_response, ::Faraday::Response
         # The assignment with the given identifier was retrieved.
-        field :assignment_result, T.nilable(Models::Shared::AssignmentResult)
-
+        field :assignment_result, Crystalline::Nilable.new(Models::Shared::AssignmentResult)
 
-        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], raw_response: ::Faraday::Response, status_code: ::Integer, assignment_result: T.nilable(Models::Shared::AssignmentResult)).void }
-        def initialize(content_type: nil, headers: nil, raw_response: nil, status_code: nil, assignment_result: nil)
+        sig { params(content_type: ::String, headers: T::Hash[Symbol, T::Array[::String]], status_code: ::Integer, raw_response: ::Faraday::Response, assignment_result: T.nilable(Models::Shared::AssignmentResult)).void }
+        def initialize(content_type:, headers:, status_code:, raw_response:, assignment_result: nil)
           @content_type = content_type
           @headers = headers
-          @raw_response = raw_response
           @status_code = status_code
+          @raw_response = raw_response
           @assignment_result = assignment_result
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @content_type == other.content_type
           return false unless @headers == other.headers
-          return false unless @raw_response == other.raw_response
           return false unless @status_code == other.status_code
+          return false unless @raw_response == other.raw_response
           return false unless @assignment_result == other.assignment_result
           true
         end

data/lib/stack_one/models/operations/lms_get_user_assignment_response.rbi

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class StackOne::Models::Operations::LmsGetUserAssignmentResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class StackOne::Models::Operations::LmsGetUserAssignmentResponse
+  def content_type(); end
+  def content_type=(str_); end
+  def headers(); end
+  def headers=(str_); end
+  def status_code(); end
+  def status_code=(str_); end
+  def raw_response(); end
+  def raw_response=(str_); end
+  def assignment_result(); end
+  def assignment_result=(str_); end
+end

data/lib/stack_one/models/operations/lms_get_user_completion_request.rb

@@ -20,15 +20,14 @@ module StackOne
         # The account identifier
         field :x_account_id, ::String, { 'header': { 'field_name': 'x-account-id', 'style': 'simple', 'explode': false } }
         # The comma separated list of fields to return in the response (if empty, all fields are returned)
-        field :fields_, T.nilable(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
+        field :fields_, Crystalline::Nilable.new(::String), { 'query_param': { 'field_name': 'fields', 'style': 'form', 'explode': true } }
         # Query parameters that can be used to pass through parameters to the underlying provider request by surrounding them with 'proxy' key
-        field :proxy, T.nilable(T::Hash[Symbol, ::Object]), { 'query_param': { 'field_name': 'proxy', 'style': 'deepObject', 'explode': true } }
+        field :proxy, Crystalline::Nilable.new(Crystalline::Hash.new(Symbol, ::Object)), { 'query_param': { 'field_name': 'proxy', 'style': 'deepObject', 'explode': true } }
         # Indicates that the raw request result should be returned in addition to the mapped result (default value is false)
-        field :raw, T.nilable(T::Boolean), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
-
+        field :raw, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'query_param': { 'field_name': 'raw', 'style': 'form', 'explode': true } }
 
         sig { params(id: ::String, sub_resource_id: ::String, x_account_id: ::String, fields_: T.nilable(::String), proxy: T.nilable(T::Hash[Symbol, ::Object]), raw: T.nilable(T::Boolean)).void }
-        def initialize(id: nil, sub_resource_id: nil, x_account_id: nil, fields_: nil, proxy: nil, raw: nil)
+        def initialize(id:, sub_resource_id:, x_account_id:, fields_: nil, proxy: nil, raw: nil)
           @id = id
           @sub_resource_id = sub_resource_id
           @x_account_id = x_account_id
@@ -37,6 +36,7 @@ module StackOne
           @raw = raw
         end
 
+        sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
           return false unless @id == other.id