runtype 0.5.0 → 0.11.1

data/generated/lib/runtype/question_sets/client.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    class Client
+      # @param client [Runtype::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # List the organization's question sets with cursor pagination, newest first.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :cursor
+      # @option params [Runtype::QuestionSets::Types::GetV1QuestionSetsRequestDirection, nil] :direction
+      # @option params [String, nil] :include_count
+      #
+      # @example
+      #   client.question_sets.list_question_sets
+      #
+      # @return [Runtype::QuestionSets::Types::GetV1QuestionSetsResponse]
+      def list_question_sets(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        query_params["direction"] = params[:direction] if params.key?(:direction)
+        query_params["includeCount"] = params[:include_count] if params.key?(:include_count)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/question-sets",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::GetV1QuestionSetsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a question set with its first version as a draft. Publish the version before a tool, step or grader can
+      # reference it.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::QuestionSets::Types::PostV1QuestionSetsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @example
+      #   client.question_sets.create_a_question_set(
+      #     name: "name",
+      #     questions: {
+      #       key: "value"
+      #     },
+      #     slug: "slug"
+      #   )
+      #
+      # @return [Runtype::QuestionSets::Types::PostV1QuestionSetsResponse]
+      def create_a_question_set(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/question-sets",
+          body: Runtype::QuestionSets::Types::PostV1QuestionSetsRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::PostV1QuestionSetsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # A question set with its versions, newest first.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.question_sets.get_a_question_set(id: "id")
+      #
+      # @return [Runtype::QuestionSets::Types::GetV1QuestionSetsIDResponse]
+      def get_a_question_set(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::GetV1QuestionSetsIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update the name or description, and append a new draft version when `questions`, `inputMapping` or `model` is
+      # present. Fields left out of a new version carry over from the latest version. No existing version is changed,
+      # and the slug is fixed.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::QuestionSets::Types::PutV1QuestionSetsIDRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.question_sets.update_a_question_set(id: "id")
+      #
+      # @return [Runtype::QuestionSets::Types::PutV1QuestionSetsIDResponse]
+      def update_a_question_set(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::QuestionSets::Types::PutV1QuestionSetsIDRequest.new(params).to_h
+        non_body_param_names = %w[id]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PUT",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::PutV1QuestionSetsIDResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # The question set exactly as an execution receives it: the current published version (or the published `version`
+      # named), with its current calibration. A draft-only set answers 404 QUESTION_SET_UNRESOLVED.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Integer, nil] :version
+      #
+      # @example
+      #   client.question_sets.resolve_a_question_set(id: "id")
+      #
+      # @return [Runtype::Types::ResolvedQuestionSet]
+      def resolve_a_question_set(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["version"] = params[:version] if params.key?(:version)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}/resolved",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::Types::ResolvedQuestionSet.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Every version, newest first.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
+      # @example
+      #   client.question_sets.list_a_question_sets_versions(id: "id")
+      #
+      # @return [Runtype::QuestionSets::Types::GetV1QuestionSetsIDVersionsResponse]
+      def list_a_question_sets_versions(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}/versions",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::GetV1QuestionSetsIDVersionsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # The calibration history of one version, newest first, with cursor pagination.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Integer] :version_number
+      # @option params [String, nil] :limit
+      # @option params [String, nil] :cursor
+      #
+      # @example
+      #   client.question_sets.list_a_question_set_versions_calibrations(
+      #     id: "id",
+      #     version_number: 1
+      #   )
+      #
+      # @return [Runtype::QuestionSets::Types::GetV1QuestionSetsIDVersionsVersionNumberCalibrationsResponse]
+      def list_a_question_set_versions_calibrations(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}/versions/#{URI.encode_uri_component(params[:version_number].to_s)}/calibrations",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::GetV1QuestionSetsIDVersionsVersionNumberCalibrationsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Append a calibration measurement to a published version and make it the current one. Calibrations are never
+      # edited or deleted, so every past decision keeps the calibration it was taken under.
+      #
+      # @param request_options [Hash]
+      # @param params [Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Integer] :version_number
+      #
+      # @example
+      #   client.question_sets.record_a_calibration_for_a_question_set_version(
+      #     id: "id",
+      #     version_number: 1,
+      #     record: {
+      #       labeled_set_ref: "labeledSetRef",
+      #       measured_model: "measuredModel",
+      #       per_question: {
+      #         key: {
+      #           ece: 1.1,
+      #           handled_rate: 1.1,
+      #           held_out_accuracy: 1.1,
+      #           target_accuracy: 1.1,
+      #           threshold: 1.1
+      #         }
+      #       }
+      #     }
+      #   )
+      #
+      # @return [Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberCalibrationsResponse]
+      def record_a_calibration_for_a_question_set_version(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request_data = Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequest.new(params).to_h
+        non_body_param_names = %w[id versionNumber]
+        body = request_data.except(*non_body_param_names)
+
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}/versions/#{URI.encode_uri_component(params[:version_number].to_s)}/calibrations",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberCalibrationsResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Freeze the version and make it the one executions resolve when they name no version. Publishing an
+      # already-published version moves the current pointer back to it.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      # @option params [Integer] :version_number
+      #
+      # @example
+      #   client.question_sets.publish_a_question_set_version(
+      #     id: "id",
+      #     version_number: 1
+      #   )
+      #
+      # @return [Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberPublishResponse]
+      def publish_a_question_set_version(request_options: {}, **params)
+        params = Runtype::Internal::Types::Utils.normalize_keys(params)
+        request = Runtype::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "v1/question-sets/#{URI.encode_uri_component(params[:id].to_s)}/versions/#{URI.encode_uri_component(params[:version_number].to_s)}/publish",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Runtype::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberPublishResponse.load(response.body)
+        else
+          error_class = Runtype::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_resolved_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDResolvedRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :version, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDResponse < Internal::Types::Model
+        field :question_set, -> { Runtype::Types::QuestionSet }, optional: false, nullable: false, api_name: "questionSet"
+
+        field :versions, -> { Internal::Types::Array[Runtype::Types::QuestionSetVersion] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_versions_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDVersionsRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_versions_response.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDVersionsResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Runtype::Types::QuestionSetVersion] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_versions_version_number_calibrations_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDVersionsVersionNumberCalibrationsRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :version_number, -> { Integer }, optional: false, nullable: false, api_name: "versionNumber"
+
+        field :limit, -> { String }, optional: true, nullable: false
+
+        field :cursor, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_id_versions_version_number_calibrations_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsIDVersionsVersionNumberCalibrationsResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Runtype::Types::JudgmentCalibrationRecord] }, optional: false, nullable: false
+
+        field :pagination, -> { Runtype::Types::Pagination }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsRequest < Internal::Types::Model
+        field :limit, -> { String }, optional: true, nullable: false
+
+        field :cursor, -> { String }, optional: true, nullable: false
+
+        field :direction, -> { Runtype::QuestionSets::Types::GetV1QuestionSetsRequestDirection }, optional: true, nullable: false
+
+        field :include_count, -> { String }, optional: true, nullable: false, api_name: "includeCount"
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_request_direction.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      module GetV1QuestionSetsRequestDirection
+        extend Runtype::Internal::Types::Enum
+
+        NEXT = "next"
+        PREV = "prev"
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/get_v1question_sets_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class GetV1QuestionSetsResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Runtype::Types::QuestionSetListItem] }, optional: false, nullable: false
+
+        field :pagination, -> { Runtype::Types::Pagination }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/post_v1question_sets_id_versions_version_number_calibrations_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :version_number, -> { Integer }, optional: false, nullable: false, api_name: "versionNumber"
+
+        field :eval_run_id, -> { String }, optional: true, nullable: false, api_name: "evalRunId"
+
+        field :record, -> { Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequestRecord }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/post_v1question_sets_id_versions_version_number_calibrations_request_record.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequestRecord < Internal::Types::Model
+        field :labeled_set_ref, -> { String }, optional: false, nullable: false, api_name: "labeledSetRef"
+
+        field :measured_model, -> { String }, optional: false, nullable: false, api_name: "measuredModel"
+
+        field :per_question, -> { Internal::Types::Hash[String, Runtype::QuestionSets::Types::PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequestRecordPerQuestionValue] }, optional: false, nullable: false, api_name: "perQuestion"
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/post_v1question_sets_id_versions_version_number_calibrations_request_record_per_question_value.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class PostV1QuestionSetsIDVersionsVersionNumberCalibrationsRequestRecordPerQuestionValue < Internal::Types::Model
+        field :ece, -> { Integer }, optional: false, nullable: false
+
+        field :handled_rate, -> { Integer }, optional: false, nullable: false, api_name: "handledRate"
+
+        field :held_out_accuracy, -> { Integer }, optional: false, nullable: false, api_name: "heldOutAccuracy"
+
+        field :target_accuracy, -> { Integer }, optional: false, nullable: false, api_name: "targetAccuracy"
+
+        field :threshold, -> { Integer }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/post_v1question_sets_id_versions_version_number_calibrations_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class PostV1QuestionSetsIDVersionsVersionNumberCalibrationsResponse < Internal::Types::Model
+        field :calibration, -> { Runtype::Types::JudgmentCalibrationRecord }, optional: false, nullable: false
+
+        field :version, -> { Runtype::Types::QuestionSetVersion }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/post_v1question_sets_id_versions_version_number_publish_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class PostV1QuestionSetsIDVersionsVersionNumberPublishRequest < Internal::Types::Model
+        field :id, -> { String }, optional: false, nullable: false
+
+        field :version_number, -> { Integer }, optional: false, nullable: false, api_name: "versionNumber"
+      end
+    end
+  end
+end

data/generated/lib/runtype/question_sets/types/post_v1question_sets_id_versions_version_number_publish_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Runtype
+  module QuestionSets
+    module Types
+      class PostV1QuestionSetsIDVersionsVersionNumberPublishResponse < Internal::Types::Model
+        field :question_set, -> { Runtype::Types::QuestionSet }, optional: false, nullable: false, api_name: "questionSet"
+
+        field :version, -> { Runtype::Types::QuestionSetVersion }, optional: false, nullable: false
+      end
+    end
+  end
+end