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

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Arrays
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a response schema that is an array of number types.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Array<Float>]
+        def float_items(opts = {})
+          req = {
+            method: :get,
+            path: "/types/array/float_items",
+            model: Sink::ArrayOf.new(Float)
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a request schema that has a property that points to an array
+        #   model.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Object, nil] :array_param
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def nested_in_params(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/array/model_nested_in_params",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema that is an array of in-line object types.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Array<Sink::Models::ArrayObjectItemsResponse::ArrayObjectItemsResponse>]
+        def object_items(opts = {})
+          req = {
+            method: :get,
+            path: "/types/array/object_items",
+            model: Sink::ArrayOf.new(Sink::Models::ArrayObjectItemsResponse::ArrayObjectItemsResponse)
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types/enums.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Enums
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint that has an array of enum that should generate a valid test with
+        #   non-repeating values in the array.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Array<Symbol, Body>] :body
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def array_unique_values(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/enum_tests_array_unique_values",
+            body: params[:body],
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint that has an array of enum that should generate a valid test with 2
+        #   non-repeating values in the array.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Array<Symbol, Body>] :body
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def array_unique_values_2_values(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/enum_tests_array_unique_values_2_values",
+            body: params[:body],
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint that has an array of enum that should generate a valid test with 2
+        #   non-repeating values in the array.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Array<Float>] :body
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def array_unique_values_numbers(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/enum_tests_array_unique_values_numbers",
+            body: params[:body],
+            headers: {"Content-Type" => "application/json"},
+            model: NilClass
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint that has a `$ref`d enum type in the request body and the response body.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Symbol, Sink::Models::Currency, nil] :input_currency This is my description for the Currency enum
+        #   @option params [Symbol, ProblematicEnum, nil] :problematic_enum
+        #   @option params [Symbol, UsesConst, nil] :uses_const
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::EnumBasicResponse]
+        def basic(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/enums",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: Sink::Models::EnumBasicResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types/maps.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Maps
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a response schema object that contains properties that use
+        #   `additionalProperties` with a nullable items type.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::MapNullableItemsResponse]
+        def nullable_items(opts = {})
+          req = {
+            method: :get,
+            path: "/types/map/nullable_items",
+            model: Sink::Models::MapNullableItemsResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Objects
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a response schema object that contains a mix of known & unknown
+        #   properties with the same value types.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ObjectMixedKnownAndUnknownResponse]
+        def mixed_known_and_unknown(opts = {})
+          req = {
+            method: :get,
+            path: "/types/object/mixed_known_and_unknown",
+            model: Sink::Models::ObjectMixedKnownAndUnknownResponse
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema object that contains multiple properties that
+        #   reference the same $ref in array items that is _not_ a model in the config.
+        #   Three child types should be generated, one for each property.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ObjectMultipleArrayPropertiesSameRefResponse]
+        def multiple_array_properties_same_ref(opts = {})
+          req = {
+            method: :get,
+            path: "/types/object/multiple_array_properties_same_ref",
+            model: Sink::Models::ObjectMultipleArrayPropertiesSameRefResponse
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema object that contains multiple properties that
+        #   reference the same model.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ObjectMultiplePropertiesSameModelResponse]
+        def multiple_properties_same_model(opts = {})
+          req = {
+            method: :get,
+            path: "/types/object/multiple_properties_same_model",
+            model: Sink::Models::ObjectMultiplePropertiesSameModelResponse
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema object that contains multiple properties that
+        #   reference the same $ref that is _not_ a model in the config. Three child types
+        #   should be generated. One for each property.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ObjectMultiplePropertiesSameRefResponse]
+        def multiple_properties_same_ref(opts = {})
+          req = {
+            method: :get,
+            path: "/types/object/multiple_properties_same_ref",
+            model: Sink::Models::ObjectMultiplePropertiesSameRefResponse
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema object that contains properties that are
+        #   primitive 2d arrays
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::ObjectTwoDimensionalArrayPrimitivePropertyResponse]
+        def two_dimensional_array_primitive_property(opts = {})
+          req = {
+            method: :get,
+            path: "/types/object/2d_array_primitive_properties",
+            model: Sink::Models::ObjectTwoDimensionalArrayPrimitivePropertyResponse
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema object that does not define any properties
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Object]
+        def unknown_object(opts = {})
+          req = {
+            method: :get,
+            path: "/types/object/unknown_object",
+            model: Sink::Unknown
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types/primitives.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Primitives
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint that has a request body property that points to a string model &
+        #   returns an object with a string model prop
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String, nil] :string_param
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::PrimitiveStringsResponse]
+        def strings(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/primitives/strings",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: Sink::Models::PrimitiveStringsResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types/read_only_params.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class ReadOnlyParams
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a request params schema object that contains a `readOnly`
+        #   property.
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String, nil] :should_show_up This should be generated in the request params type.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Hash]
+        def simple(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/read_only_params/simple",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: Hash
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types/unions.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Unions
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with an array request param schema with items discriminated union that
+        #   just defines the `propertyName` config
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Array<Sink::Models::UnionDiscriminatedVariantA, Sink::Models::UnionDiscriminatedVariantB>] :body
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [String]
+        def array_param_discriminated_by_property_name(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/unions/array_param_discriminated_by_property_name",
+            body: params[:body],
+            headers: {"Content-Type" => "application/json"},
+            model: String
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with an array request param schema with items discriminated union that
+        #   also defines the `mapping` config
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [Array<Sink::Models::UnionDiscriminatedVariantA, Sink::Models::UnionDiscriminatedVariantB>] :body
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [String]
+        def array_param_discriminated_with_basic_mapping(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/unions/array_param_discriminated_with_basic_mapping",
+            body: params[:body],
+            headers: {"Content-Type" => "application/json"},
+            model: String
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a request param schema that is a discriminated union that just
+        #   defines the `propertyName` config
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String] :value
+        #   @option params [Symbol, Type, nil] :type
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [String]
+        def param_discriminated_by_property_name(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/unions/param_discriminated_by_property_name",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: String
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a request param schema that is a discriminated union that also
+        #   defines the `mapping` config
+        #
+        # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+        #   @option params [String] :value
+        #   @option params [Symbol, Type, nil] :type
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [String]
+        def param_discriminated_with_basic_mapping(params = {}, opts = {})
+          req = {
+            method: :post,
+            path: "/types/unions/param_discriminated_with_basic_mapping",
+            body: params,
+            headers: {"Content-Type" => "application/json"},
+            model: String
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema that is a discriminated union that just defines
+        #   the `propertyName` config
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::UnionDiscriminatedVariantA, Sink::Models::UnionDiscriminatedVariantB]
+        def response_discriminated_by_property_name(opts = {})
+          req = {
+            method: :get,
+            path: "/types/unions/response_discriminated_by_property_name",
+            model: Sink::Unknown
+          }
+          @client.request(req, opts)
+        end
+
+        # Endpoint with a response schema that is a discriminated union that also defines
+        #   the `mapping` config
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::UnionDiscriminatedVariantA, Sink::Models::UnionDiscriminatedVariantB]
+        def response_discriminated_with_basic_mapping(opts = {})
+          req = {
+            method: :get,
+            path: "/types/unions/response_discriminated_with_basic_mapping",
+            model: Sink::Unknown
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types/write_only_responses.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class WriteOnlyResponses
+        # @param client [Sink::Client]
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a response schema object that contains a `writeOnly` property.
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [Sink::Models::WriteOnlyResponseSimpleResponse]
+        def simple(opts = {})
+          req = {
+            method: :get,
+            path: "/types/write_only_responses/simple",
+            model: Sink::Models::WriteOnlyResponseSimpleResponse
+          }
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      # @return [Sink::Resources::Types::Primitives]
+      attr_reader :primitives
+
+      # @return [Sink::Resources::Types::ReadOnlyParams]
+      attr_reader :read_only_params
+
+      # @return [Sink::Resources::Types::WriteOnlyResponses]
+      attr_reader :write_only_responses
+
+      # @return [Sink::Resources::Types::Maps]
+      attr_reader :maps
+
+      # @return [Sink::Resources::Types::Enums]
+      attr_reader :enums
+
+      # @return [Sink::Resources::Types::Allofs]
+      attr_reader :allofs
+
+      # @return [Sink::Resources::Types::Unions]
+      attr_reader :unions
+
+      # @return [Sink::Resources::Types::Objects]
+      attr_reader :objects
+
+      # @return [Sink::Resources::Types::Arrays]
+      attr_reader :arrays
+
+      # @param client [Sink::Client]
+      def initialize(client:)
+        @client = client
+        @primitives = Sink::Resources::Types::Primitives.new(client: client)
+        @read_only_params = Sink::Resources::Types::ReadOnlyParams.new(client: client)
+        @write_only_responses = Sink::Resources::Types::WriteOnlyResponses.new(client: client)
+        @maps = Sink::Resources::Types::Maps.new(client: client)
+        @enums = Sink::Resources::Types::Enums.new(client: client)
+        @allofs = Sink::Resources::Types::Allofs.new(client: client)
+        @unions = Sink::Resources::Types::Unions.new(client: client)
+        @objects = Sink::Resources::Types::Objects.new(client: client)
+        @arrays = Sink::Resources::Types::Arrays.new(client: client)
+      end
+
+      # Endpoint that has date types should generate params/responses with rich date
+      #   types.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Date] :required_date
+      #   @option params [Date] :required_nullable_date
+      #   @option params [Array<Date>, nil] :list_date
+      #   @option params [Date, Integer, nil] :oneof_date
+      #   @option params [Date, nil] :optional_date
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::TypeDatesResponse]
+      def dates(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/types/dates",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::TypeDatesResponse
+        }
+        @client.request(req, opts)
+      end
+
+      # Endpoint that has date-time types.
+      #
+      # @param params [Hash{Symbol => Object}] Attributes to send in this request.
+      #   @option params [Time] :required_datetime
+      #   @option params [Time] :required_nullable_datetime
+      #   @option params [Array<Time>, nil] :list_datetime
+      #   @option params [Integer, Time, nil] :oneof_datetime union type coming from the `oneof_datetime` property
+      #   @option params [Time, nil] :optional_datetime
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::TypeDatetimesResponse]
+      def datetimes(params = {}, opts = {})
+        req = {
+          method: :post,
+          path: "/types/datetimes",
+          body: params,
+          headers: {"Content-Type" => "application/json"},
+          model: Sink::Models::TypeDatetimesResponse
+        }
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/undocumented_resource.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class UndocumentedResource
+      # @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 reissue(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
+    end
+  end
+end