test-test-sink-test-test 0.0.2.pre.alpha.0

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Responses
+      class UnionTypes
+        # @param client [Sink::Client]
+        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 = {
+            method: :post,
+            path: "/responses/unions/mixed_types",
+            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 = {
+            method: :post,
+            path: "/responses/unions/nullable",
+            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 = {
+            method: :post,
+            path: "/responses/unions/numbers",
+            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 = {
+            method: :post,
+            path: "/responses/unions/objects",
+            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 = {
+            method: :post,
+            path: "/responses/unions/super_mixed_types",
+            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 = {
+            method: :post,
+            path: "/responses/unions/unknown_variant",
+            model: Sink::Unknown
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/responses.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Responses
+      # @return [Sink::Resources::Responses::UnionTypes]
+      attr_reader :union_types
+
+      # @param client [Sink::Client]
+      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 = {
+          method: :post,
+          path: "/responses/additional_properties",
+          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 = {
+          method: :post,
+          path: "/responses/additional_properties_nested_model_reference",
+          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 = {
+          method: :get,
+          path: "/responses/allof/simple",
+          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 = {
+          method: :get,
+          path: "/responses/anyof_null",
+          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 = {
+          method: :get,
+          path: "/responses/array/object_with_union_properties",
+          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 = {
+          method: :get,
+          path: "/responses/array",
+          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 = {
+          method: :post,
+          path: "/responses/boolean",
+          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 = {
+          method: :post,
+          path: "/responses/empty",
+          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 = {
+          method: :post,
+          path: "/responses/integer",
+          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 = {
+          method: :get,
+          path: "/responses/missing_required",
+          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 = {
+          method: :get,
+          path: "/responses/array/nested",
+          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 = {
+          method: :get,
+          path: "/responses/object/everything",
+          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 = {
+          method: :post,
+          path: "/responses/object_no_properties",
+          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 = {
+          method: :post,
+          path: "/responses/object_with_additional_properties_prop",
+          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 = {
+          method: :post,
+          path: "/responses/object_with_heavily_nested_union",
+          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 = {
+          method: :get,
+          path: "/responses/oneof_null",
+          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 = {
+          method: :get,
+          path: "/responses/only_read_only_properties",
+          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 = {
+          method: :get,
+          path: "/responses/shared_simple_object",
+          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 = {
+          method: :post,
+          path: "/responses/string",
+          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 = {
+          method: :post,
+          path: "/responses/unknown_object",
+          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 = {
+          method: :get,
+          path: "/responses/with_model_in_nested_path",
+          model: Sink::Models::ModelWithNestedModel
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/shared_query_params.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class SharedQueryParams
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :get,
+          path: "/shared-query-params",
+          query: params,
+          model: String
+        }
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :delete,
+          path: "/shared-query-params",
+          query: params,
+          model: String
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/streaming.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Streaming
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :post,
+          path: "/streaming/basic",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::StreamingBasicResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :post,
+          path: "/streaming/nested_params",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::StreamingNestedParamsResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :post,
+          path: "/streaming/no_discriminator",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::StreamingNoDiscriminatorResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :get,
+          path: "/streaming/query_param_discriminator",
+          query: params,
+          model: Sink::Models::StreamingQueryParamDiscriminatorResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # @param params [Hash{Symbol => Object}] 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 = {
+          method: :post,
+          path: "/streaming/with_unrelated_default_param",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::StreamingWithUnrelatedDefaultParamResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/testing.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Testing
+      # @param client [Sink::Client]
+      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 = {
+          method: :get,
+          path: "/",
+          model: Sink::Models::RootResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/tests.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Tests
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Testing codegen change with new Github action
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def run_codegen(opts = {})
+        req = {
+          method: :get,
+          path: "/tests/run_codegen",
+          model: NilClass
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/tools.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Tools
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :skipped_go
+      #   @option params [String, nil] :skipped_java
+      #   @option params [String, nil] :skipped_node
+      #   @option params [String, nil] :skipped_python
+      #   @option params [String, nil] :skipped_python_and_node
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ObjectSkippedProps]
+      def skipped_params(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/tools/skipped_params",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::ObjectSkippedProps
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/types/allofs.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Allofs
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end