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

data/lib/sink/resources/empty_body.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class EmptyBody
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Endpoint with x-stainless-empty-object should still have types for params
+      #
+      # @param path_param [String] Path param: Path param description
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Body] :body Body param:
+      #   @option params [String, nil] :query_param Query param: Query param description
+      #   @option params [String, nil] :second_query_param Query param: Query param description
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def stainless_empty_object(path_param = nil, params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/mixed_params/with_empty_body/#{path_param}/x_stainless_empty_object",
+          body: params[:body],
+          query: params.except(:body),
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with an empty `requestBody` should still have types for params
+      #
+      # @param path_param [String] Path param: Path param description
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Object] :body Body param:
+      #   @option params [String, nil] :query_param Query param: Query param description
+      #   @option params [String, nil] :second_query_param Query param: Query param description
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def typed_params(path_param = nil, params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/mixed_params/with_empty_body/#{path_param}",
+          body: params[:body],
+          query: params.except(:body),
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/envelopes.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Envelopes
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Endpoint with a response wrapped within a `data` property.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::Address]
+      def explicit(opts = {})
+        req = {
+          method: :get,
+          path: "/envelopes/data",
+          unwrap: :data,
+          model: Sink::Models::Address
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response wrapped within a `items` property.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::Address]
+      def implicit(opts = {})
+        req = {
+          method: :get,
+          path: "/envelopes/items",
+          unwrap: :items,
+          model: Sink::Models::Address
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response wrapped within a `items` property that doesn't use a
+      #   $ref.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::EnvelopeInlineResponseResponse]
+      def inline_response(opts = {})
+        req = {
+          method: :get,
+          path: "/envelopes/items/inline_response",
+          unwrap: :items,
+          model: Sink::Models::EnvelopeInlineResponseResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response wrapped within a `items` property that is an array
+      #   type.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Array<Sink::Models::ObjectWithChildRef>]
+      def wrapped_array(opts = {})
+        req = {
+          method: :get,
+          path: "/envelopes/items/wrapped_array",
+          unwrap: :items,
+          model: Sink::ArrayOf.new(Sink::Models::ObjectWithChildRef)
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/files.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Files
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Endpoint for testing file uploads
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String] :file
+      #   @option params [String] :purpose
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::FileCreateMultipartResponse]
+      def create_multipart(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/files/multipart",
+          body: params,
+          headers: {"Content-Type" => "multipart/form-data"},
+          model: Sink::Models::FileCreateMultipartResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint for testing file uploads with all kinds of properties
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Boolean] :b
+      #   @option params [Symbol, E] :e
+      #   @option params [Float] :f
+      #   @option params [String] :file
+      #   @option params [Integer] :i
+      #   @option params [String] :purpose
+      #   @option params [String] :s
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::FileEverythingMultipartResponse]
+      def everything_multipart(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/files/multipart_everything",
+          body: params,
+          headers: {"Content-Type" => "multipart/form-data"},
+          model: Sink::Models::FileEverythingMultipartResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint for multipart requests without a file parameter.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String] :purpose
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::FileNoFileMultipartResponse]
+      def no_file_multipart(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/files/no_file_multipart",
+          body: params,
+          headers: {"Content-Type" => "multipart/form-data"},
+          model: Sink::Models::FileNoFileMultipartResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Multipart request with a required and an optional file request param.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String] :image The image to edit. Must be a valid PNG file, less than 4MB, and square. If mask
+      #     is not provided, image must have transparency, which will be used as the mask.
+      #   @option params [String] :prompt A text description of the desired image(s). The maximum length is 1000
+      #     characters.
+      #   @option params [String, nil] :mask An additional image whose fully transparent areas (e.g. where alpha is zero)
+      #     indicate where `image` should be edited. Must be a valid PNG file, less than
+      #     4MB, and have the same dimensions as `image`.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::FileWithOptionalParamResponse]
+      def with_optional_param(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/files/with_optional_param",
+          body: params,
+          headers: {"Content-Type" => "multipart/form-data"},
+          model: Sink::Models::FileWithOptionalParamResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/header_params.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class HeaderParams
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Endpoint with a `type: null` header param, which we should turn into a string
+      #   type.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Array<Integer>] :x_required_int_array Header param:
+      #   @option params [Array<String>] :x_required_string_array Header param:
+      #   @option params [String, nil] :body_argument Body param:
+      #   @option params [Array<Integer>, nil] :x_optional_int_array Header param:
+      #   @option params [Array<String>, nil] :x_optional_string_array Header param:
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def arrays(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/header_params/arrays",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: NilClass
+        }
+        @client.request(req, opts)
+      end
+
+      # The `X-Client-Secret` header shouldn't be included in params definitions as it
+      #   is already sent as a client argument.
+      #
+      #   Whereas the `X-Custom-Endpoint-Header` should be included as it is only used
+      #   here.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :foo Body param:
+      #   @option params [String, nil] :x_custom_endpoint_header Header param:
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def client_argument(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/header_params/client_argument",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: NilClass
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a `type: null` header param, which we should turn into a string
+      #   type.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :body_argument Body param:
+      #   @option params [String, nil] :x_null Header param:
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def nullable_type(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/header_params/nullable_type",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: NilClass
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/invalid_schemas/arrays.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class InvalidSchemas
+      class Arrays
+        # @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::ArrayMissingItemsResponse]
+        def missing_items(opts = {})
+          req = {
+            method: :get,
+            path: "/invalid_schemas/arrays/missing_items",
+            model: Sink::Models::ArrayMissingItemsResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/invalid_schemas/objects.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class InvalidSchemas
+      class Objects
+        # @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::ObjectMissingItemsResponse]
+        def missing_items(opts = {})
+          req = {
+            method: :get,
+            path: "/invalid_schemas/objects/property_missing_def",
+            model: Sink::Models::ObjectMissingItemsResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/invalid_schemas.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class InvalidSchemas
+      # @return [Sink::Resources::InvalidSchemas::Arrays]
+      attr_reader :arrays
+
+      # @return [Sink::Resources::InvalidSchemas::Objects]
+      attr_reader :objects
+
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+        @arrays = Sink::Resources::InvalidSchemas::Arrays.new(client: client)
+        @objects = Sink::Resources::InvalidSchemas::Objects.new(client: client)
+      end
+    end
+  end
+end

data/lib/sink/resources/make_ambiguous_schemas_explicit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MakeAmbiguousSchemasExplicit
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Test case for makeAmbiguousSchemasExplicit
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MakeAmbiguousSchemasExplicitMakeAmbiguousSchemasExplicitResponse]
+      def make_ambiguous_schemas_explicit(opts = {})
+        req = {
+          method: :get,
+          path: "/make-ambiguous-schemas-explicit",
+          model: Sink::Models::MakeAmbiguousSchemasExplicitMakeAmbiguousSchemasExplicitResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/make_ambiguous_schemas_looser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MakeAmbiguousSchemasLooser
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Test case for makeAmbiguousSchemasLooser
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MakeAmbiguousSchemasLooserMakeAmbiguousSchemasLooserResponse]
+      def make_ambiguous_schemas_looser(opts = {})
+        req = {
+          method: :get,
+          path: "/make-ambiguous-schemas-looser",
+          model: Sink::Models::MakeAmbiguousSchemasLooserMakeAmbiguousSchemasLooserResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/method_config.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MethodConfig
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Initiate print and shipment of a duplicate card.
+      #
+      #   Only applies to cards of type `PHYSICAL` [beta].
+      #
+      # @param card_token [String]
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :product_id Specifies the configuration (e.g. physical card art) that the card should be
+      #     manufactured with, and only applies to cards of type `PHYSICAL` [beta]. This
+      #     must be configured with Lithic before use.
+      #   @option params [Symbol, ShippingMethod, nil] :shipping_method Shipping method for the card. Use of options besides `STANDARD` require
+      #     additional permissions.
+      #
+      #     - `STANDARD` - USPS regular mail or similar international option, with no
+      #       tracking
+      #     - `STANDARD_WITH_TRACKING` - USPS regular mail or similar international option,
+      #       with tracking
+      #     - `EXPEDITED` - FedEx Standard Overnight or similar international option, with
+      #       tracking
+      #   @option params [Sink::Models::ShippingAddress, nil] :shipping_address If omitted, the previous shipping address will be used.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::Card]
+      def should_not_show_up_in_api_docs(card_token, params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/cards/#{card_token}/reissue",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::Card
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsAllResponse]
+      def skipped_tests_all(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsAllResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsGoResponse]
+      def skipped_tests_go(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsGoResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsJavaResponse]
+      def skipped_tests_java(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsJavaResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsKotlinResponse]
+      def skipped_tests_kotlin(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsKotlinResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsNodeResponse]
+      def skipped_tests_node(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsNodeResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsNodeAndPythonResponse]
+      def skipped_tests_node_and_python(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsNodeAndPythonResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsPythonResponse]
+      def skipped_tests_python(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsPythonResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Used to test skipping generated unit tests.
+      #
+      # @param id [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::MethodConfigSkippedTestsRubyResponse]
+      def skipped_tests_ruby(id, opts = {})
+        req = {
+          method: :get,
+          path: "/method_config/skipped_tests/#{id}",
+          model: Sink::Models::MethodConfigSkippedTestsRubyResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/mixed_params/duplicates.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MixedParams
+      class Duplicates
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a `requestBody` that defines a param with the same name in path
+        #   and body params
+        #
+        # @param path_id [String] Path param description
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String] :body_id Body param description
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::BasicSharedModelObject]
+        def body_and_path(_path_id = nil, params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/mixed_params/duplicates/body_and_path/#{params.fetch(:path_id)}",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: Sink::Models::BasicSharedModelObject
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a `requestBody` that defines a param with the same name in query
+        #   and body params
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String] :body_id 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_id]
+          req = {
+            method: :post,
+            path: "/mixed_params/duplicates/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 a param with the same name in path
+        #   and query params
+        #
+        # @param path_id [String] Path param description
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String] :query_id Query param description
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::BasicSharedModelObject]
+        def query_and_path(_path_id = nil, params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/mixed_params/duplicates/query_and_path/#{params.fetch(:path_id)}",
+            query: params,
+            model: Sink::Models::BasicSharedModelObject
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end