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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class Refs
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for pagination using an in-line nested object reference
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String, nil] :cursor
+        #   @option params [Integer, nil] :limit
+        #   @option params [ObjectParam, nil] :object_param
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::PageCursorNestedObjectRef<Sink::Models::MyModel>]
+        def nested_object_ref(params = {}, opts = {})
+          req = {
+            method: :get,
+            path: "/paginated/nested_object_ref",
+            query: params,
+            page: Sink::PageCursorNestedObjectRef,
+            model: Sink::Models::MyModel
+          }
+          @client.request(req, opts)
+        end
+
+        # Test case for pagination using a shared model reference
+        #
+        # @param params [Hash{Symbol => Object}] 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::PageCursorSharedRef<Sink::Models::MyModel>]
+        def with_shared_model_ref(params = {}, opts = {})
+          req = {
+            method: :get,
+            path: "/paginated/with_shared_model_ref",
+            query: params,
+            page: Sink::PageCursorSharedRef,
+            model: Sink::Models::MyModel
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class ResponseHeaders
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for response headers with cursor pagination
+        #
+        # @param params [Hash{Symbol => Object}] 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::PageCursorFromHeaders<Sink::Models::MyModel>]
+        def basic_cursor(params = {}, opts = {})
+          req = {
+            method: :get,
+            path: "/paginated/response_headers/basic_cursor",
+            query: params,
+            page: Sink::PageCursorFromHeaders,
+            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,54 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class SchemaTypes
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for a cursor endpoint that defines properties using allOf
+        #
+        # @param params [Hash{Symbol => Object}] 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 = {
+            method: :get,
+            path: "/paginated/schema_types/allofs",
+            query: params,
+            page: Sink::PageCursor,
+            model: Sink::Models::MyModel
+          }
+          @client.request(req, opts)
+        end
+
+        # Test case for a cursor endpoint that returns an anyOf
+        #
+        # @param params [Hash{Symbol => Object}] 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 = {
+            method: :get,
+            path: "/paginated/schema_types/unions",
+            query: params,
+            page: Sink::PageCursor,
+            model: Sink::Models::MyModel
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PaginationTests
+      class TopLevelArrays
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Test case for top level arrays with cursor pagination
+        #
+        # @param params [Hash{Symbol => Object}] 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::PageCursorTopLevelArray<Sink::Models::MyModel>]
+        def basic_cursor(params = {}, opts = {})
+          req = {
+            method: :get,
+            path: "/paginated/top_level_arrays/basic_cursor",
+            query: params,
+            page: Sink::PageCursorTopLevelArray,
+            model: Sink::Models::MyModel
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/pagination_tests.rb

@@ -0,0 +1,64 @@
+# 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::PageNumber]
+      attr_reader :page_number
+
+      # @return [Sink::Resources::PaginationTests::PageNumberWithoutCurrentPageResponse]
+      attr_reader :page_number_without_current_page_response
+
+      # @return [Sink::Resources::PaginationTests::Refs]
+      attr_reader :refs
+
+      # @return [Sink::Resources::PaginationTests::ResponseHeaders]
+      attr_reader :response_headers
+
+      # @return [Sink::Resources::PaginationTests::TopLevelArrays]
+      attr_reader :top_level_arrays
+
+      # @return [Sink::Resources::PaginationTests::Cursor]
+      attr_reader :cursor
+
+      # @return [Sink::Resources::PaginationTests::CursorID]
+      attr_reader :cursor_id
+
+      # @return [Sink::Resources::PaginationTests::CursorURL]
+      attr_reader :cursor_url
+
+      # @return [Sink::Resources::PaginationTests::Offset]
+      attr_reader :offset
+
+      # @return [Sink::Resources::PaginationTests::FakePages]
+      attr_reader :fake_pages
+
+      # @return [Sink::Resources::PaginationTests::NestedItems]
+      attr_reader :nested_items
+
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+        @schema_types = Sink::Resources::PaginationTests::SchemaTypes.new(client: client)
+        @items_types = Sink::Resources::PaginationTests::ItemsTypes.new(client: client)
+        @page_number = Sink::Resources::PaginationTests::PageNumber.new(client: client)
+        @page_number_without_current_page_response = Sink::Resources::PaginationTests::PageNumberWithoutCurrentPageResponse.new(client: client)
+        @refs = Sink::Resources::PaginationTests::Refs.new(client: client)
+        @response_headers = Sink::Resources::PaginationTests::ResponseHeaders.new(client: client)
+        @top_level_arrays = Sink::Resources::PaginationTests::TopLevelArrays.new(client: client)
+        @cursor = Sink::Resources::PaginationTests::Cursor.new(client: client)
+        @cursor_id = Sink::Resources::PaginationTests::CursorID.new(client: client)
+        @cursor_url = Sink::Resources::PaginationTests::CursorURL.new(client: client)
+        @offset = Sink::Resources::PaginationTests::Offset.new(client: client)
+        @fake_pages = Sink::Resources::PaginationTests::FakePages.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,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Parent
+      # Some children can be very large
+      # For example, the children of Godzilla
+      class Child
+        # @param client [Sink::Client]
+        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 = {
+            method: :get,
+            path: "/inlined_response",
+            model: Sink::Models::ChildInlinedResponseResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/parent.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Parent
+      # Some children can be very large
+      # For example, the children of Godzilla
+      # @return [Sink::Resources::Parent::Child]
+      attr_reader :child
+
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+        @child = Sink::Resources::Parent::Child.new(client: client)
+      end
+    end
+  end
+end

data/lib/sink/resources/path_params.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class PathParams
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Endpoint with a path param followed by a verb.
+      #
+      # @param with_verb [Integer]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::PathParamColonSuffixResponse]
+      def colon_suffix(with_verb, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{with_verb}:initiate",
+          model: Sink::Models::PathParamColonSuffixResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a singular path parameter that uses a `dash` separator.
+      #
+      # @param dashed_param [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def dashed_param(dashed_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{dashed_param}",
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a singular path parameter that is a date type.
+      #
+      # @param date_param [Date]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def date_param(date_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/dates/#{date_param}",
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a singular path parameter that is a date-time type.
+      #
+      # @param datetime_param [Time] An ISO 8601 timestamp for when the card was created. UTC time zone.
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def datetime_param(datetime_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/date_times/#{datetime_param}",
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a singular path parameter that is an enum type.
+      #
+      # @param enum_param [Symbol, EnumParam]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def enum_param(enum_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/enums/#{enum_param}",
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a path param followed by a file extension.
+      #
+      # @param with_file_extension [Integer]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::PathParamFileExtensionResponse]
+      def file_extension(with_file_extension, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{with_file_extension}.json",
+          model: Sink::Models::PathParamFileExtensionResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a singular path parameter that is of an integer type.
+      #
+      # @param integer_param [Integer]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def integer_param(integer_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{integer_param}",
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with multiple path parameters.
+      #
+      # @param first [String]
+      # @param second [String]
+      # @param last [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::PathParamMultipleResponse]
+      def multiple(first, second, last, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{first}/#{second}/#{last}",
+          model: Sink::Models::PathParamMultipleResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with nullable path parameters.
+      #
+      #   In a spec file nullable path params are ambiguous and likely to be a mistake.
+      #   They are transformed to non-nullable as part of the spec normalization and a
+      #   diagnostic is emitted.
+      #
+      # @param nullable_param_1 [String]
+      #
+      # @param nullable_param_2 [String]
+      #
+      # @param nullable_param_3 [Symbol, NullableParam3]
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [String, nil] :foo
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def nullable_params(nullable_param_1, nullable_param_2, nullable_param_3, params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/nullable/#{nullable_param_1}/#{nullable_param_2}/#{nullable_param_3}",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with multiple path parameters that are of different types, e.g. one
+      #   integer type and the other string type.
+      #
+      # @param integer_param [Integer]
+      # @param string_param [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::BasicSharedModelObject]
+      def params_mixed_types(integer_param, string_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/mixed/#{integer_param}/#{string_param}",
+          model: Sink::Models::BasicSharedModelObject
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a path param followed by a query param in the path itself.
+      #
+      # @param with_query_param [Integer]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::PathParamQueryParamResponse]
+      def query_param(with_query_param, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{with_query_param}?beta=true",
+          model: Sink::Models::PathParamQueryParamResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint with a singular path parameter.
+      #
+      # @param singular [String]
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::PathParamSingularResponse]
+      def singular(singular, opts = {})
+        req = {
+          method: :post,
+          path: "/path_params/#{singular}",
+          model: Sink::Models::PathParamSingularResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end