testttttttttttttttomgomgomg12 0.0.1.pre.alpha.0

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Methods
+          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] 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 = {})
+            req = {}
+            req[:method] = :post
+            req[:path] = "/names/reserved_names/methods/export/#{class_}"
+            query_params = [:let]
+            req[:query] = params.slice(*query_params)
+            req[:body] = params.except(*query_params)
+            req[: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,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          class Class
+            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 = {}
+              req[:method] = :get
+              req[:path] = "/names/reserved_names/public/class"
+              req[: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,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          class Interface
+            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 = {}
+              req[:method] = :get
+              req[:path] = "/names/reserved_names/public/interface"
+              req[: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,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      class ReservedNames
+        class Public
+          class Private
+            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 = {}
+              req[:method] = :get
+              req[:path] = "/names/reserved_names/public/private"
+              req[: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,38 @@
+# 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_
+
+          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 = {}
+            req[:method] = :get
+            req[:path] = "/names/reserved_names/public"
+            req[: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,43 @@
+# 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
+
+        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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/names/reserved_names/common_reserved_params"
+          req[:body] = params
+          req[:model] = NilClass
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/names.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Names
+      # @return [Sink::Resources::Names::Documents]
+      attr_reader :documents
+
+      # @return [Sink::Resources::Names::ReservedNames]
+      attr_reader :reserved_names
+
+      # @return [Sink::Resources::Names::Params]
+      attr_reader :params
+
+      # @return [Sink::Resources::Names::CanCauseClashes]
+      attr_reader :can_cause_clashes
+
+      # @return [Sink::Resources::Names::OpenAPISpecials]
+      attr_reader :openapi_specials
+
+      def initialize(client:)
+        @client = client
+        @documents = Sink::Resources::Names::Documents.new(client: client)
+        @reserved_names = Sink::Resources::Names::ReservedNames.new(client: client)
+        @params = Sink::Resources::Names::Params.new(client: client)
+        @can_cause_clashes = Sink::Resources::Names::CanCauseClashes.new(client: client)
+        @openapi_specials = Sink::Resources::Names::OpenAPISpecials.new(client: client)
+      end
+
+      # Endpoint with request & response properties that could cause clashes due to
+      #   imports.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::NameChildPropImportClashResponse]
+      def child_prop_import_clash(opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/names/child_prop_import_clash"
+        req[:model] = Sink::Models::NameChildPropImportClashResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint with the name `get` in the config.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def get(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/names/method_name_get"
+        req[:model] = Sink::Models::BasicSharedModelObject
+        @client.request(req, opts)
+      end
+
+      # Endpoint with request & response properties that are likely to cause name
+      #   conflicts.
+      #
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String] :_1_digit_leading_underscore In certain languages the leading underscore in combination with this property
+      #   name may cause issues
+      # @option params [String] :_leading_underscore In certain languages the leading underscore in this property name may cause
+      #   issues
+      # @option params [String] :_leading_underscore_mixed_case In certain languages the leading underscore in this property name may cause
+      #   issues alongside a case change
+      # @option params [Boolean] :bool
+      # @option params [Boolean] :bool_2 In certain languages the type declaration for this prop can shadow the `bool`
+      #   property declaration.
+      # @option params [Date] :date This shadows the stdlib `datetime.date` type in Python & causes type errors.
+      # @option params [Date] :date_2 In certain languages the type declaration for this prop can shadow the `date`
+      #   property declaration.
+      # @option params [Float] :float
+      # @option params [Float] :float_2 In certain languages the type declaration for this prop can shadow the `float`
+      #   property declaration.
+      # @option params [Integer] :int
+      # @option params [Integer] :int_2 In certain languages the type declaration for this prop can shadow the `int`
+      #   property declaration.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::NamePropertiesCommonConflictsResponse]
+      def properties_common_conflicts(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/names/properties_common_conflicts"
+        req[:body] = params
+        req[:model] = Sink::Models::NamePropertiesCommonConflictsResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint with request & response properties with names that aren't legal
+      #   javascript identifiers.
+      #
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [Float, nil] :irrelevant
+      # @option params [Float] :body
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Float, Sink::Models::NamePropertiesIllegalJavascriptIdentifiersResponse::UnnamedTypeWithunionParent3]
+      def properties_illegal_javascript_identifiers(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/names/properties_illegal_javascript_identifiers"
+        req[:body] = params
+        req[:model] = Sink::Unknown
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response model property that can cause clashes with a model
+      #   import.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::NameResponsePropertyClashesModelImportResponse]
+      def response_property_clashes_model_import(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/names/response_property_clashes_model_import"
+        req[:model] = Sink::Models::NameResponsePropertyClashesModelImportResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a response model property that would clash with pydantic.
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::NameResponseShadowsPydanticResponse]
+      def response_shadows_pydantic(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/names/response_property_shadows_pydantic"
+        req[:model] = Sink::Models::NameResponseShadowsPydanticResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/openapi_formats.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class OpenAPIFormats
+      def initialize(client:)
+        @client = client
+      end
+
+      # See https://linear.app/stainless/issue/STA-569/support-for-type-[object-null]
+      #
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [Boolean] :enable_debug_logging
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::OpenAPIFormatArrayTypeOneEntryResponse]
+      def array_type_one_entry(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/openapi_formats/array_type_one_entry"
+        req[:body] = params
+        req[:model] = Sink::Models::OpenAPIFormatArrayTypeOneEntryResponse
+        @client.request(req, opts)
+      end
+
+      # The `type` property being set to [T, null] should result in an optional response
+      #   return type in generated SDKs.
+      #
+      #   See https://linear.app/stainless/issue/STA-569/support-for-type-[object-null]
+      #
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [Boolean, nil] :enable_debug_logging
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::OpenAPIFormatArrayTypeOneEntryWithNullResponse]
+      def array_type_one_entry_with_null(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/openapi_formats/array_type_one_entry_with_null"
+        req[:body] = params
+        req[:model] = Sink::Models::OpenAPIFormatArrayTypeOneEntryWithNullResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests/cursor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class Cursor
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for cursor pagination
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [String, nil] :cursor
+        # @option params [Integer, nil] :limit
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageCursor<Sink::Models::MyModel>]
+        def list(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/cursor"
+          req[:query] = params
+          req[:page] = Sink::PageCursor
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests/items_types.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class ItemsTypes
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for paginated items of `unknown` types with page_number pagination
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [Integer, nil] :page
+        # @option params [Integer, nil] :page_size
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PagePageNumber<Object>]
+        def list_unknown(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/items_types/unknown"
+          req[:query] = params
+          req[:page] = Sink::PagePageNumber
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests/nested_items.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class NestedItems
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for response headers with cursor pagination
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [String, nil] :cursor
+        # @option params [Integer, nil] :limit
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageCursorNestedItems<Sink::Models::MyModel>]
+        def list(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/nested_items"
+          req[:query] = params
+          req[:page] = Sink::PageCursorNestedItems
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests/offset.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class Offset
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for offset pagination
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [Integer, nil] :limit
+        # @option params [Integer, nil] :offset
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageOffset<Sink::Models::MyModel>]
+        def list(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/offset"
+          req[:query] = params
+          req[:page] = Sink::PageOffset
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+
+        # Test case for offset pagination with no start response field
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [Integer, nil] :limit
+        # @option params [Integer, nil] :offset
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageOffsetNoStartField<Sink::Models::MyModel>]
+        def list_no_start_field(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/offset/no_start_field"
+          req[:query] = params
+          req[:page] = Sink::PageOffsetNoStartField
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+
+        # Test case for offset pagination with a total count response property
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [Integer, nil] :limit
+        # @option params [Integer, nil] :offset
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageOffsetTotalCount<Sink::Models::MyModel>]
+        def with_total_count(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/offset/with_total_count"
+          req[:query] = params
+          req[:page] = Sink::PageOffsetTotalCount
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests/schema_types.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class SchemaTypes
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for a cursor endpoint that defines properties using allOf
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [String, nil] :cursor
+        # @option params [Integer, nil] :limit
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageCursor<Sink::Models::MyModel>]
+        def allofs(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/schema_types/allofs"
+          req[:query] = params
+          req[:page] = Sink::PageCursor
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+
+        # Test case for a cursor endpoint that returns an anyOf
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [String, nil] :cursor
+        # @option params [Integer, nil] :limit
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageCursor<Sink::Models::MyModel>]
+        def unions(params = {}, opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/paginated/schema_types/unions"
+          req[:query] = params
+          req[:page] = Sink::PageCursor
+          req[:model] = Sink::Models::MyModel
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      # @return [Sink::Resources::PaginationTests::SchemaTypes]
+      attr_reader :schema_types
+
+      # @return [Sink::Resources::PaginationTests::ItemsTypes]
+      attr_reader :items_types
+
+      # @return [Sink::Resources::PaginationTests::Cursor]
+      attr_reader :cursor
+
+      # @return [Sink::Resources::PaginationTests::Offset]
+      attr_reader :offset
+
+      # @return [Sink::Resources::PaginationTests::NestedItems]
+      attr_reader :nested_items
+
+      def initialize(client:)
+        @client = client
+        @schema_types = Sink::Resources::PaginationTests::SchemaTypes.new(client: client)
+        @items_types = Sink::Resources::PaginationTests::ItemsTypes.new(client: client)
+        @cursor = Sink::Resources::PaginationTests::Cursor.new(client: client)
+        @offset = Sink::Resources::PaginationTests::Offset.new(client: client)
+        @nested_items = Sink::Resources::PaginationTests::NestedItems.new(client: client)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Parent
+      # Some children can be very large
+      # For example, the children of Godzilla
+      class Child
+        def initialize(client:)
+          @client = client
+        end
+
+        # Method with inlined response model.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ChildInlinedResponseResponse]
+        def inlined_response(opts = {})
+          req = {}
+          req[:method] = :get
+          req[:path] = "/inlined_response"
+          req[:model] = Sink::Models::ChildInlinedResponseResponse
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end