testttttttttttttttomgomgomg12 0.0.1.pre.alpha.0

data/lib/sink/resources/resource_refs/paginated_model_second_ref.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ResourceRefs
+      class PaginatedModelSecondRef
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/resource_refs/parent/child.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ResourceRefs
+      class Parent
+        class Child
+          def initialize(client:)
+            @client = client
+          end
+
+          # endpoint that returns a model that is referenced from a model in a parent
+          #   resource
+          #
+          # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+          #
+          # @return [Sink::Models::ChildModel]
+          def returns_child_model(opts = {})
+            req = {}
+            req[:method] = :get
+            req[:path] = "/resource_refs/child"
+            req[:model] = Sink::Models::ChildModel
+            @client.request(req, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/resource_refs/parent.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ResourceRefs
+      class Parent
+        # @return [Sink::Resources::ResourceRefs::Parent::Child]
+        attr_reader :child
+
+        def initialize(client:)
+          @client = client
+          @child = Sink::Resources::ResourceRefs::Parent::Child.new(client: client)
+        end
+
+        # endpoint that returns a model that has a nested reference to a child model
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ParentModelWithChildRef]
+        def returns_parent_model_with_child_ref(opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/resource_refs/parent_with_child_ref"
+          req[:model] = Sink::Models::ParentModelWithChildRef
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/resource_refs.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ResourceRefs
+      # @return [Sink::Resources::ResourceRefs::PaginatedModelFirstRef]
+      attr_reader :paginated_model_first_ref
+
+      # @return [Sink::Resources::ResourceRefs::PaginatedModelSecondRef]
+      attr_reader :paginated_model_second_ref
+
+      # @return [Sink::Resources::ResourceRefs::Parent]
+      attr_reader :parent
+
+      def initialize(client:)
+        @client = client
+        @paginated_model_first_ref = Sink::Resources::ResourceRefs::PaginatedModelFirstRef.new(client: client)
+        @paginated_model_second_ref = Sink::Resources::ResourceRefs::PaginatedModelSecondRef.new(client: client)
+        @parent = Sink::Resources::ResourceRefs::Parent.new(client: client)
+      end
+    end
+  end
+end

data/lib/sink/resources/resources.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Resources
+      def initialize(client:)
+        @client = client
+      end
+
+      # Endpoint returning no response
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def foo(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/no_response"
+        req[:model] = NilClass
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/responses/union_types.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Responses
+      class UnionTypes
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a top level union response of different types.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Boolean, Sink::Models::SimpleObject, Sink::Models::UnionTypeMixedTypesResponse::UnnamedTypeWithunionParent4]
+        def mixed_types(opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/responses/unions/mixed_types"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a top level union response of floats and integers.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::SimpleObject, Sink::Models::UnionTypeNullableUnionResponse::UnnamedTypeWithunionParent5]
+        def nullable_union(opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/responses/unions/nullable"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a top level union response of floats and integers.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Float]
+        def numbers(opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/responses/unions/numbers"
+          req[:model] = Float
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a top level union response of just object variants.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::SimpleObject, Sink::Models::UnionTypeObjectsResponse::UnnamedTypeWithunionParent6]
+        def objects(opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/responses/unions/objects"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a top level union response of different types.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Boolean, Object, Sink::Models::SimpleObject, Sink::Models::UnionTypeSuperMixedTypesResponse::UnnamedTypeWithunionParent7, String]
+        def super_mixed_types(opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/responses/unions/super_mixed_types"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a top level union response with a variant that is `type: unknown`
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Object, Sink::Models::SimpleObject]
+        def unknown_variant(opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/responses/unions/unknown_variant"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/responses.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Responses
+      # @return [Sink::Resources::Responses::UnionTypes]
+      attr_reader :union_types
+
+      def initialize(client:)
+        @client = client
+        @union_types = Sink::Resources::Responses::UnionTypes.new(client: client)
+      end
+
+      # Endpoint with a top level additionalProperties response.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Hash]
+      def additional_properties(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/additional_properties"
+        req[:model] = Hash
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a top level additionalProperties response where the items type
+      #   points to an object defined as a model in the config.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Hash]
+      def additional_properties_nested_model_reference(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/additional_properties_nested_model_reference"
+        req[:model] = Hash
+        @client.request(req, opts)
+      end
+
+      # Method with a response object defined using allOf and inline schema definitions.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseAllofSimpleResponse]
+      def allof_simple(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/allof/simple"
+        req[:model] = Sink::Models::ResponseAllofSimpleResponse
+        @client.request(req, opts)
+      end
+
+      # Method with a response object that uses anyOf to indicate nullability.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ObjectWithAnyOfNullProperty]
+      def anyof_null(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/anyof_null"
+        req[:model] = Sink::Models::ObjectWithAnyOfNullProperty
+        @client.request(req, opts)
+      end
+
+      # Endpoint that returns an array of objects with union properties.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Array<Sink::Models::ObjectWithUnionProperties>]
+      def array_object_with_union_properties(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/array/object_with_union_properties"
+        req[:model] = Sink::ArrayOf.new(Sink::Models::ObjectWithUnionProperties)
+        @client.request(req, opts)
+      end
+
+      # Endpoint that returns a top-level array.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Array<Sink::Models::SimpleObject>]
+      def array_response(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/array"
+        req[:model] = Sink::ArrayOf.new(Sink::Models::SimpleObject)
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a top level boolean response.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Boolean]
+      def boolean_response(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/boolean"
+        req[:model] = Sink::BooleanModel
+        @client.request(req, opts)
+      end
+
+      # Endpoint with an empty response.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def empty_response(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/empty"
+        req[:model] = NilClass
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a top level integer response.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Integer]
+      def integer_response(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/integer"
+        req[:model] = Integer
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response schema that doesn't set the `required` property.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseMissingRequiredResponse]
+      def missing_required(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/missing_required"
+        req[:model] = Sink::Models::ResponseMissingRequiredResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint that returns a nested array.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseNestedArrayResponse]
+      def nested_array(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/array/nested"
+        req[:model] = Sink::Models::ResponseNestedArrayResponse
+        @client.request(req, opts)
+      end
+
+      # Method with a response object with a different property for each supported type.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseObjectAllPropertiesResponse]
+      def object_all_properties(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/object/everything"
+        req[:model] = Sink::Models::ResponseObjectAllPropertiesResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint with an empty response.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseObjectNoPropertiesResponse]
+      def object_no_properties(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/object_no_properties"
+        req[:model] = Sink::Models::ResponseObjectNoPropertiesResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint with an object response that contains an `additionalProperties`
+      #   property with a nested schema.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseObjectWithAdditionalPropertiesPropResponse]
+      def object_with_additional_properties_prop(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/object_with_additional_properties_prop"
+        req[:model] = Sink::Models::ResponseObjectWithAdditionalPropertiesPropResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint with an object response that contains a union property with multiple
+      #   nested schemas.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseObjectWithHeavilyNestedUnionResponse]
+      def object_with_heavily_nested_union(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/object_with_heavily_nested_union"
+        req[:model] = Sink::Models::ResponseObjectWithHeavilyNestedUnionResponse
+        @client.request(req, opts)
+      end
+
+      # Method with a response object that uses oneOf to indicate nullability.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ObjectWithOneOfNullProperty]
+      def oneof_null(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/oneof_null"
+        req[:model] = Sink::Models::ObjectWithOneOfNullProperty
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response that only has `readOnly` properties
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ResponseOnlyReadOnlyPropertiesResponse]
+      def only_read_only_properties(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/only_read_only_properties"
+        req[:model] = Sink::Models::ResponseOnlyReadOnlyPropertiesResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint that returns a $ref to SimpleObject. This is used to test shared
+      #   response models.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::SimpleObject]
+      def shared_simple_object(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/shared_simple_object"
+        req[:model] = Sink::Models::SimpleObject
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a top level string response.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [String]
+      def string_response(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/string"
+        req[:model] = String
+        @client.request(req, opts)
+      end
+
+      # Should not generate a named return type for object without defined properties;
+      #   instead, it should simply use an `unknown` type or equivalent. In Java and Go,
+      #   where we have fancier accessors for raw json stuff, we should generate a named
+      #   type, but it should basically just have untyped additional properties. See
+      #   https://linear.app/stainless/issue/STA-563/no-type-should-be-generated-for-endpoints-returning-type-object-schema.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Object]
+      def unknown_object(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/responses/unknown_object"
+        req[:model] = Sink::Unknown
+        @client.request(req, opts)
+      end
+
+      # Should return a ModelWithNestedModel object with a `properties` field that we
+      #   can rename in the Stainless config to a prettier name.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ModelWithNestedModel]
+      def with_model_in_nested_path(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/responses/with_model_in_nested_path"
+        req[:model] = Sink::Models::ModelWithNestedModel
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/shared_query_params.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class SharedQueryParams
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String, nil] :get1
+      # @option params [String, nil] :shared1
+      # @option params [String, nil] :shared2
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [String]
+      def retrieve(params = {}, opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/shared-query-params"
+        req[:query] = params
+        req[:model] = String
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String, nil] :get1
+      # @option params [String, nil] :shared1
+      # @option params [String, nil] :shared2
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [String]
+      def del(params = {}, opts = {})
+        req = {}
+        req[:method] = :delete
+        req[:path] = "/shared-query-params"
+        req[:query] = params
+        req[:model] = String
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/streaming.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Streaming
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String] :model
+      # @option params [String] :prompt
+      # @option params [Boolean] :stream
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::StreamingBasicResponse]
+      def basic(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/streaming/basic"
+        req[:body] = params
+        req[:model] = Sink::Models::StreamingBasicResponse
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String] :model
+      # @option params [String] :prompt
+      # @option params [ParentObject, nil] :parent_object
+      # @option params [Boolean] :stream
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::StreamingNestedParamsResponse]
+      def nested_params(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/streaming/nested_params"
+        req[:body] = params
+        req[:model] = Sink::Models::StreamingNestedParamsResponse
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String] :model
+      # @option params [String] :prompt
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::StreamingNoDiscriminatorResponse]
+      def no_discriminator(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/streaming/no_discriminator"
+        req[:body] = params
+        req[:model] = Sink::Models::StreamingNoDiscriminatorResponse
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String] :prompt
+      # @option params [Boolean] :should_stream
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::StreamingQueryParamDiscriminatorResponse]
+      def query_param_discriminator(params = {}, opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/streaming/query_param_discriminator"
+        req[:query] = params
+        req[:model] = Sink::Models::StreamingQueryParamDiscriminatorResponse
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String] :model
+      # @option params [Symbol, ParamWithDefaultValue] :param_with_default_value
+      # @option params [String] :prompt
+      # @option params [Boolean] :stream
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::StreamingWithUnrelatedDefaultParamResponse]
+      def with_unrelated_default_param(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/streaming/with_unrelated_default_param"
+        req[:body] = params
+        req[:model] = Sink::Models::StreamingWithUnrelatedDefaultParamResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/testing.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Testing
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::RootResponse]
+      def root(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/"
+        req[:model] = Sink::Models::RootResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end