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

data/lib/sink/resources/tests.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Tests
+      def initialize(client:)
+        @client = client
+      end
+
+      # Testing codegen change with new Github action
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [nil]
+      def run_codegen(opts = {})
+        req = {}
+        req[:method] = :get
+        req[:path] = "/tests/run_codegen"
+        req[:model] = NilClass
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/tools.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Tools
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [String, nil] :skipped_go
+      # @option params [String, nil] :skipped_java
+      # @option params [String, nil] :skipped_node
+      # @option params [String, nil] :skipped_python
+      # @option params [String, nil] :skipped_python_and_node
+      #
+      # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+      #
+      # @return [Sink::Models::ObjectSkippedProps]
+      def skipped_params(params = {}, opts = {})
+        req = {}
+        req[:method] = :post
+        req[:path] = "/tools/skipped_params"
+        req[:body] = params
+        req[:model] = Sink::Models::ObjectSkippedProps
+        @client.request(req, opts)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Allofs
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Arrays
+        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 = {}
+          req[:method] = :get
+          req[:path] = "/types/array/float_items"
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/array/model_nested_in_params"
+          req[:body] = params
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/array/object_items"
+          req[: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,86 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Enums
+        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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/enum_tests_array_unique_values"
+          req[:body] = params[:body]
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/enum_tests_array_unique_values_2_values"
+          req[:body] = params[:body]
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/enum_tests_array_unique_values_numbers"
+          req[:body] = params[:body]
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/enums"
+          req[:body] = params
+          req[:model] = Sink::Models::EnumBasicResponse
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Maps
+        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 = {}
+          req[:method] = :get
+          req[:path] = "/types/map/nullable_items"
+          req[:model] = Sink::Models::MapNullableItemsResponse
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Objects
+        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 = {}
+          req[:method] = :get
+          req[:path] = "/types/object/mixed_known_and_unknown"
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/object/multiple_array_properties_same_ref"
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/object/multiple_properties_same_model"
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/object/multiple_properties_same_ref"
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/object/2d_array_primitive_properties"
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/object/unknown_object"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Primitives
+        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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/primitives/strings"
+          req[:body] = params
+          req[: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,31 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class ReadOnlyParams
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with a request params schema object that contains a `readOnly`
+        #   property.
+        #
+        # @param params [Hash] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/read_only_params/simple"
+          req[:body] = params
+          req[:model] = Hash
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class Unions
+        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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/unions/array_param_discriminated_by_property_name"
+          req[:body] = params[:body]
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/unions/array_param_discriminated_with_basic_mapping"
+          req[:body] = params[:body]
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/unions/param_discriminated_by_property_name"
+          req[:body] = params
+          req[: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] 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 = {}
+          req[:method] = :post
+          req[:path] = "/types/unions/param_discriminated_with_basic_mapping"
+          req[:body] = params
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/unions/response_discriminated_by_property_name"
+          req[: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 = {}
+          req[:method] = :get
+          req[:path] = "/types/unions/response_discriminated_with_basic_mapping"
+          req[:model] = Sink::Unknown
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class Types
+      class WriteOnlyResponses
+        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 = {}
+          req[:method] = :get
+          req[:path] = "/types/write_only_responses/simple"
+          req[:model] = Sink::Models::WriteOnlyResponseSimpleResponse
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/types.rb

@@ -0,0 +1,90 @@
+# 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
+
+      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] 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 = {}
+        req[:method] = :post
+        req[:path] = "/types/dates"
+        req[:body] = params
+        req[:model] = Sink::Models::TypeDatesResponse
+        @client.request(req, opts)
+      end
+
+      # Endpoint that has date-time types.
+      #
+      # @param params [Hash] Attributes to send in this request.
+      # @option params [DateTime] :required_datetime
+      # @option params [DateTime] :required_nullable_datetime
+      # @option params [Array<DateTime>, nil] :list_datetime
+      # @option params [DateTime, Integer, nil] :oneof_datetime union type coming from the `oneof_datetime` property
+      # @option params [DateTime, 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 = {}
+        req[:method] = :post
+        req[:path] = "/types/datetimes"
+        req[:body] = params
+        req[:model] = Sink::Models::TypeDatetimesResponse
+        @client.request(req, opts)
+      end
+    end
+  end
+end

data/lib/sink/resources/undocumented_resource.rb

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