test-test-ignore-123123 0.0.1.pre.alpha.0

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

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

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

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

data/lib/sink/resources/invalid_schemas.rb

@@ -0,0 +1,19 @@
+# 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
+
+      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,24 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MakeAmbiguousSchemasExplicit
+      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 = {}
+        req[:method] = :get
+        req[:path] = "/make-ambiguous-schemas-explicit"
+        req[:model] = Sink::Models::MakeAmbiguousSchemasExplicitMakeAmbiguousSchemasExplicitResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/make_ambiguous_schemas_looser.rb

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

data/lib/sink/resources/method_config.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MethodConfig
+      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] 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 = {}
+        req[:method] = :post
+        req[:path] = "/cards/#{card_token}/reissue"
+        req[:body] = params
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[: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 = {}
+        req[:method] = :get
+        req[:path] = "/method_config/skipped_tests/#{id}"
+        req[:model] = Sink::Models::MethodConfigSkippedTestsRubyResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MixedParams
+      class Duplicates
+        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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/mixed_params/duplicates/body_and_path/#{params.fetch(:path_id)}"
+          req[:body] = params
+          req[: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] 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 = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/mixed_params/duplicates/query_and_body"
+          query_params = [:query_id]
+          req[:query] = params.slice(*query_params)
+          req[:body] = params.except(*query_params)
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/mixed_params/duplicates/query_and_path/#{params.fetch(:path_id)}"
+          req[:query] = params
+          req[:model] = Sink::Models::BasicSharedModelObject
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/mixed_params.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class MixedParams
+      # @return [Sink::Resources::MixedParams::Duplicates]
+      attr_reader :duplicates
+
+      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] 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 = {}
+        req[:method] = :post
+        req[:path] = "/mixed_params/body_with_top_level_one_of_and_path/#{path_param}"
+        req[:body] = params
+        req[:model] = NilClass
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a `requestBody` that defines both query and body params
+      #
+      # @param params [Hash] 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 = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/mixed_params/query_and_body"
+        query_params = [:query_param]
+        req[:query] = params.slice(*query_params)
+        req[:body] = params.except(*query_params)
+        req[: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] 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 = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/mixed_params/query_body_and_path/#{path_param}"
+        query_params = [:query_param]
+        req[:query] = params.slice(*query_params)
+        req[:body] = params.except(*query_params)
+        req[: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,24 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ModelReferencedInParentAndChild
+      class Child
+        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 = {}
+          req[:method] = :get
+          req[:path] = "/model_referenced_in_parent_and_child/child"
+          req[: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,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class ModelReferencedInParentAndChild
+      # @return [Sink::Resources::ModelReferencedInParentAndChild::Child]
+      attr_reader :child
+
+      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 = {}
+        req[:method] = :get
+        req[:path] = "/model_referenced_in_parent_and_child"
+        req[: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,15 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class CanCauseClashes
+        class EmploymentData
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class CanCauseClashes
+        # The `Response` class name can cause clashes with imports.
+        class Response
+          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 = {}
+            req[:method] = :get
+            req[:path] = "/binaries/return_binary"
+            req[:headers] = {"Accept" => "audio/mpeg"}
+            req[: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,22 @@
+# 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
+
+        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,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class Documents
+        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 = {}
+          req[:method] = :post
+          req[:path] = "/names/model_import_clash_with_resource"
+          req[:model] = Sink::Models::Documents
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class Params
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a `requestBody` that has a property named `options`
+        #
+        # @param params [Hash] 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 = {}
+          req[:method] = :post
+          req[:path] = "/names/body_params/options"
+          req[:body] = params
+          req[:model] = NilClass
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a `requestBody` that has a property named `timeout`
+        #
+        # @param params [Hash] 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 = {}
+          req[:method] = :post
+          req[:path] = "/names/body_params/timeout"
+          req[:body] = params
+          req[:model] = NilClass
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

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