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

data/lib/sink/resources/mixed_params.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MixedParams
+      # @return [Sink::Resources::MixedParams::Duplicates]
+      attr_reader :duplicates
+
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+        @duplicates = Sink::Resources::MixedParams::Duplicates.new(client: client)
+      end
+
+      # Endpoint with a `requestBody` making use of oneOf, and a path param.
+      #
+      #   See
+      #   https://linear.app/stainless/issue/STA-4902/orb-java-unresolved-reference-customerid-externalcustomerid
+      #
+      # @param path_param [String]
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Symbol, Kind] :kind
+      #   @option params [String] :bar
+      #   @option params [String] :foo
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def body_with_top_level_one_of_and_path(path_param, params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/mixed_params/body_with_top_level_one_of_and_path/#{path_param}",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: NilClass
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a `requestBody` that defines both query and body params
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :query_param Query param: Query param description
+      #   @option params [String, nil] :body_param Body param: Body param description
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def query_and_body(params = {}, opts = {})
+        query_params = [:query_param]
+        req = {
+          method: :post,
+          path: "/mixed_params/query_and_body",
+          query: params.slice(*query_params),
+          body: params.except(*query_params),
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a `requestBody` that defines query, body and path params
+      #
+      # @param path_param [String] Path param: Path param description
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :query_param Query param: Query param description
+      #   @option params [String, nil] :body_param Body param: Body param description
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def query_body_and_path(path_param = nil, params = {}, opts = {})
+        query_params = [:query_param]
+        req = {
+          method: :post,
+          path: "/mixed_params/query_body_and_path/#{path_param}",
+          query: params.slice(*query_params),
+          body: params.except(*query_params),
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/model_referenced_in_parent_and_child/child.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ModelReferencedInParentAndChild
+      class Child
+        # @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::ModelReferencedInParentAndChild]
+        def retrieve(opts = {})
+          req = {
+            method: :get,
+            path: "/model_referenced_in_parent_and_child/child",
+            model: Sink::Models::ModelReferencedInParentAndChild
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/model_referenced_in_parent_and_child.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ModelReferencedInParentAndChild
+      # @return [Sink::Resources::ModelReferencedInParentAndChild::Child]
+      attr_reader :child
+
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+        @child = Sink::Resources::ModelReferencedInParentAndChild::Child.new(client: client)
+      end
+
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ModelReferencedInParentAndChild]
+      def retrieve(opts = {})
+        req = {
+          method: :get,
+          path: "/model_referenced_in_parent_and_child",
+          model: Sink::Models::ModelReferencedInParentAndChild
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/names/can_cause_clashes/employment_data.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class CanCauseClashes
+        class EmploymentData
+          # @param client [Sink::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/can_cause_clashes/response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class CanCauseClashes
+        # The `Response` class name can cause clashes with imports.
+        class Response
+          # @param client [Sink::Client]
+          def initialize(client:)
+            @client = client
+          end
+
+          # Return a binary response.
+          #
+          # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+          #
+          # @return [Object]
+          def binary_return(opts = {})
+            req = {
+              method: :get,
+              path: "/binaries/return_binary",
+              headers: {"Accept" => "audio/mpeg"},
+              model: Sink::Unknown
+            }
+            @client.request(req, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/can_cause_clashes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class CanCauseClashes
+        # @return [Sink::Resources::Names::CanCauseClashes::EmploymentData]
+        attr_reader :employment_data
+
+        # The `Response` class name can cause clashes with imports.
+        # @return [Sink::Resources::Names::CanCauseClashes::Response]
+        attr_reader :response
+
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+          @employment_data = Sink::Resources::Names::CanCauseClashes::EmploymentData.new(client: client)
+          @response = Sink::Resources::Names::CanCauseClashes::Response.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/documents.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class Documents
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a response model that can clash with the resource class in Python.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::Documents]
+        def retrieve(opts = {})
+          req = {
+            method: :post,
+            path: "/names/model_import_clash_with_resource",
+            model: Sink::Models::Documents
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/openapi_specials.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class OpenAPISpecials
+        # @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::OpenAPISpecialUsedUsedAsPropertyNameResponse]
+        def used_used_as_property_name(opts = {})
+          req = {
+            method: :get,
+            path: "/names/openapi_specials/used_used_as_property_name",
+            model: Sink::Models::OpenAPISpecialUsedUsedAsPropertyNameResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/params.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class Params
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a `requestBody` that has a property named `options`
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String, nil] :options my options request parameter
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def options_param(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/names/body_params/options",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a `requestBody` that has a property named `timeout`
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Float, nil] :timeout my timeout request parameter
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def timeout_param(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/names/body_params/timeout",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names/import.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Import
+          # @param client [Sink::Client]
+          def initialize(client:)
+            @client = client
+          end
+
+          # Endpoint that is named `import` in the config which can cause issues in certain
+          #   languages.
+          #
+          # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+          #
+          # @return [Sink::Models::Import]
+          def import(opts = {})
+            req = {
+              method: :get,
+              path: "/names/reserved_names/import",
+              model: Sink::Models::Import
+            }
+            @client.request(req, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names/methods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Methods
+          # @param client [Sink::Client]
+          def initialize(client:)
+            @client = client
+          end
+
+          # Test reserved word in method name
+          #
+          # @param class_ [String] Path param: test reserved word in path parameters
+          #
+          # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+          #   @option params [String, nil] :let Query param: test reserved word in query parameter
+          #   @option params [String, nil] :const Body param: test reserved word in body property
+          #
+          # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+          #
+          # @return [Sink::Models::Export]
+          def export(class_, params = {}, opts = {})
+            query_params = [:let]
+            req = {
+              method: :post,
+              path: "/names/reserved_names/methods/export/#{class_}",
+              query: params.slice(*query_params),
+              body: params.except(*query_params),
+              headers: {"Content-Type" => "application/json"},
+              model: Sink::Models::Export
+            }
+            @client.request(req, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names/public/class_.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          class Class
+            # @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::Class]
+            def class_(opts = {})
+              req = {
+                method: :get,
+                path: "/names/reserved_names/public/class",
+                model: Sink::Models::Class
+              }
+              @client.request(req, opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names/public/interface.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          class Interface
+            # @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::Interface]
+            def interface(opts = {})
+              req = {
+                method: :get,
+                path: "/names/reserved_names/public/interface",
+                model: Sink::Models::Interface
+              }
+              @client.request(req, opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names/public/private.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          class Private
+            # @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::Private]
+            def private(opts = {})
+              req = {
+                method: :get,
+                path: "/names/reserved_names/public/private",
+                model: Sink::Models::Private
+              }
+              @client.request(req, opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names/public.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          # @return [Sink::Resources::Names::ReservedNames::Public::Private]
+          attr_reader :private
+
+          # @return [Sink::Resources::Names::ReservedNames::Public::Interface]
+          attr_reader :interface
+
+          # @return [Sink::Resources::Names::ReservedNames::Public::Class]
+          attr_reader :class_
+
+          # @param client [Sink::Client]
+          def initialize(client:)
+            @client = client
+            @private = Sink::Resources::Names::ReservedNames::Public::Private.new(client: client)
+            @interface = Sink::Resources::Names::ReservedNames::Public::Interface.new(client: client)
+            @class_ = Sink::Resources::Names::ReservedNames::Public::Class.new(client: client)
+          end
+
+          # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+          #
+          # @return [Sink::Models::Public]
+          def public(opts = {})
+            req = {
+              method: :get,
+              path: "/names/reserved_names/public",
+              model: Sink::Models::Public
+            }
+            @client.request(req, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names/reserved_names.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        # @return [Sink::Resources::Names::ReservedNames::Public]
+        attr_reader :public
+
+        # @return [Sink::Resources::Names::ReservedNames::Import]
+        attr_reader :import
+
+        # @return [Sink::Resources::Names::ReservedNames::Methods]
+        attr_reader :methods
+
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+          @public = Sink::Resources::Names::ReservedNames::Public.new(client: client)
+          @import = Sink::Resources::Names::ReservedNames::Import.new(client: client)
+          @methods = Sink::Resources::Names::ReservedNames::Methods.new(client: client)
+        end
+
+        # Endpoint with a `requestBody` that has a property name that can conflict with
+        #   language keywords.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String] :from
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def common_reserved_params(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/names/reserved_names/common_reserved_params",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end