nextbillionai 0.1.0.pre.alpha.4

data/lib/nextbillionai/models/snap_to_road_snap_params.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::SnapToRoads#snap
+    class SnapToRoadSnapParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      # @!attribute key
+      #   A key is a unique identifier that is required to authenticate a request to the
+      #   API.
+      #
+      #   @return [String]
+      required :key, String
+
+      # @!attribute path
+      #   Pipe-separated list of coordinate points along a path which would be snapped to
+      #   a road.
+      #
+      #   @return [String]
+      required :path, String
+
+      # @!attribute approaches
+      #   A semicolon-separated list indicating the side of the road from which to
+      #   approach the locations on the snapped route. When set to "unrestricted" a route
+      #   can arrive at the snapped location from either side of the road and when set to
+      #   "curb" the route will arrive at the snapped location on the driving side of the
+      #   region. Please note the number of values provided must be equal to the number of
+      #   coordinate points provided in the "path" parameter. However, you can skip a
+      #   coordinate and show its position in the list with the ";" separator.
+      #
+      #   @return [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Approaches, nil]
+      optional :approaches, enum: -> { Nextbillionai::SnapToRoadSnapParams::Approaches }
+
+      # @!attribute avoid
+      #   Setting this will ensure the route avoids ferries, tolls, highways or nothing.
+      #   Multiple values should be separated by a pipe (|). If "none" is provided along
+      #   with other values, an error is returned as a valid route is not feasible. Please
+      #   note that when this parameter is not provided in the input, ferries are set to
+      #   be avoided by default. When this parameter is provided, only the mentioned
+      #   objects are avoided.
+      #
+      #   @return [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Avoid, nil]
+      optional :avoid, enum: -> { Nextbillionai::SnapToRoadSnapParams::Avoid }
+
+      # @!attribute geometry
+      #   Sets the output format of the route geometry in the response. Only the
+      #   "polyline" or "polyline6" encoded "geometry" of the snapped path is returned in
+      #   the response depending on the value provided in the input. When "geojson" is
+      #   selected as the input value, "polyline6" encoded geometry of the snapped path is
+      #   returned along with a "geojson" object.
+      #
+      #   @return [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Geometry, nil]
+      optional :geometry, enum: -> { Nextbillionai::SnapToRoadSnapParams::Geometry }
+
+      # @!attribute mode
+      #   Set which driving mode the service should use to determine a route. For example,
+      #   if you use "car", the API will return a route that a car can take. Using "truck"
+      #   will return a route a truck can use, taking into account appropriate truck
+      #   routing restrictions.
+      #
+      #   Note: Only the "car" profile is enabled by default. Please note that customized
+      #   profiles (including "truck") might not be available for all regions. Please
+      #   contact your [NextBillion.ai](http://NextBillion.ai) account manager, sales
+      #   representative or reach out at
+      #   [support@nextbillion.ai](mailto:support@nextbillion.ai) in case you need
+      #   additional profiles.
+      #
+      #   @return [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Mode, nil]
+      optional :mode, enum: -> { Nextbillionai::SnapToRoadSnapParams::Mode }
+
+      # @!attribute option
+      #   Include this parameter in the request to return segment-wise speed information
+      #   of the route returned in the response.
+      #
+      #   Please note that returning speed information is a function of "road_info"
+      #   parameter, which is effective only when "option=flexible". However, the
+      #   resultant route might not contain all the locations provided in "path" input.
+      #
+      #   @return [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Option, nil]
+      optional :option, enum: -> { Nextbillionai::SnapToRoadSnapParams::Option }
+
+      # @!attribute radiuses
+      #   Pipe separated radiuses, in meters (m), up to which a coordinate point can be
+      #   snapped. Please note, if no valid road is available within the specified radius,
+      #   the API would snap the points to nearest, most viable road. When using this
+      #   parameter, it is recommended to specify as many radius values as the number of
+      #   points in "path" parameter. If the same number of "radiuses" are not provided,
+      #   the API will use the default radius value of 25 meters for all locations.
+      #
+      #   @return [String, nil]
+      optional :radiuses, String
+
+      # @!attribute road_info
+      #   Use this parameter to receive segment-wise maximum speed information of the
+      #   route in the response. "max_speed" is the only allowed value.
+      #
+      #   @return [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::RoadInfo, nil]
+      optional :road_info, enum: -> { Nextbillionai::SnapToRoadSnapParams::RoadInfo }
+
+      # @!attribute timestamps
+      #   Pipe-separated UNIX epoch timestamp in seconds for each location. If used, the
+      #   number of timestamps must be equal to the number of coordinate points in the
+      #   "path" parameter. The "timestamps" must increase monotonically starting from the
+      #   first timestamp. This means that each subsequent timestamp should either be more
+      #   than or equal to the preceding one.
+      #
+      #   @return [String, nil]
+      optional :timestamps, String
+
+      # @!attribute tolerate_outlier
+      #   Enable it to ignore locations outside the service boundary. When "true", the
+      #   service would ignore "path" coordinates points falling outside the accessible
+      #   area, which otherwise would cause an error when this parameter is "false".
+      #
+      #   @return [Boolean, nil]
+      optional :tolerate_outlier, Nextbillionai::Internal::Type::Boolean
+
+      # @!method initialize(key:, path:, approaches: nil, avoid: nil, geometry: nil, mode: nil, option: nil, radiuses: nil, road_info: nil, timestamps: nil, tolerate_outlier: nil, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::SnapToRoadSnapParams} for more details.
+      #
+      #   @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      #   @param path [String] Pipe-separated list of coordinate points along a path which would be snapped to
+      #
+      #   @param approaches [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Approaches] A semicolon-separated list indicating the side of the road from which to approac
+      #
+      #   @param avoid [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Avoid] Setting this will ensure the route avoids ferries, tolls, highways or nothing. M
+      #
+      #   @param geometry [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Geometry] Sets the output format of the route geometry in the response. Only the "polyline
+      #
+      #   @param mode [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Mode] Set which driving mode the service should use to determine a route. For example,
+      #
+      #   @param option [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::Option] Include this parameter in the request to return segment-wise speed information o
+      #
+      #   @param radiuses [String] Pipe separated radiuses, in meters (m), up to which a coordinate point can be sn
+      #
+      #   @param road_info [Symbol, Nextbillionai::Models::SnapToRoadSnapParams::RoadInfo] Use this parameter to receive segment-wise maximum speed information of the rout
+      #
+      #   @param timestamps [String] Pipe-separated UNIX epoch timestamp in seconds for each location. If used, the n
+      #
+      #   @param tolerate_outlier [Boolean] Enable it to ignore locations outside the service boundary. When "true", the ser
+      #
+      #   @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}]
+
+      # A semicolon-separated list indicating the side of the road from which to
+      # approach the locations on the snapped route. When set to "unrestricted" a route
+      # can arrive at the snapped location from either side of the road and when set to
+      # "curb" the route will arrive at the snapped location on the driving side of the
+      # region. Please note the number of values provided must be equal to the number of
+      # coordinate points provided in the "path" parameter. However, you can skip a
+      # coordinate and show its position in the list with the ";" separator.
+      module Approaches
+        extend Nextbillionai::Internal::Type::Enum
+
+        UNRESTRICTED = :unrestricted
+        CURB = :curb
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Setting this will ensure the route avoids ferries, tolls, highways or nothing.
+      # Multiple values should be separated by a pipe (|). If "none" is provided along
+      # with other values, an error is returned as a valid route is not feasible. Please
+      # note that when this parameter is not provided in the input, ferries are set to
+      # be avoided by default. When this parameter is provided, only the mentioned
+      # objects are avoided.
+      module Avoid
+        extend Nextbillionai::Internal::Type::Enum
+
+        TOLL = :toll
+        FERRY = :ferry
+        HIGHWAY = :highway
+        NONE = :none
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Sets the output format of the route geometry in the response. Only the
+      # "polyline" or "polyline6" encoded "geometry" of the snapped path is returned in
+      # the response depending on the value provided in the input. When "geojson" is
+      # selected as the input value, "polyline6" encoded geometry of the snapped path is
+      # returned along with a "geojson" object.
+      module Geometry
+        extend Nextbillionai::Internal::Type::Enum
+
+        POLYLINE = :polyline
+        POLYLINE6 = :polyline6
+        GEOJSON = :geojson
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Set which driving mode the service should use to determine a route. For example,
+      # if you use "car", the API will return a route that a car can take. Using "truck"
+      # will return a route a truck can use, taking into account appropriate truck
+      # routing restrictions.
+      #
+      # Note: Only the "car" profile is enabled by default. Please note that customized
+      # profiles (including "truck") might not be available for all regions. Please
+      # contact your [NextBillion.ai](http://NextBillion.ai) account manager, sales
+      # representative or reach out at
+      # [support@nextbillion.ai](mailto:support@nextbillion.ai) in case you need
+      # additional profiles.
+      module Mode
+        extend Nextbillionai::Internal::Type::Enum
+
+        CAR = :car
+        TRUCK = :truck
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Include this parameter in the request to return segment-wise speed information
+      # of the route returned in the response.
+      #
+      # Please note that returning speed information is a function of "road_info"
+      # parameter, which is effective only when "option=flexible". However, the
+      # resultant route might not contain all the locations provided in "path" input.
+      module Option
+        extend Nextbillionai::Internal::Type::Enum
+
+        FLEXIBLE = :flexible
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+
+      # Use this parameter to receive segment-wise maximum speed information of the
+      # route in the response. "max_speed" is the only allowed value.
+      module RoadInfo
+        extend Nextbillionai::Internal::Type::Enum
+
+        MAX_SPEED = :max_speed
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/nextbillionai/models/snap_to_road_snap_response.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Models
+    # @see Nextbillionai::Resources::SnapToRoads#snap
+    class SnapToRoadSnapResponse < Nextbillionai::Internal::Type::BaseModel
+      # @!attribute distance
+      #   The total distance of the snapped path in meters.
+      #
+      #   @return [Integer, nil]
+      optional :distance, Integer
+
+      # @!attribute geojson
+      #   A GeoJSON object with details of the snapped path. This object is returned when
+      #   the geometry field is set to geojson in the input request, otherwise it is not
+      #   present in the response. The contents of this object follow the
+      #   [geoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946).
+      #
+      #   @return [Nextbillionai::Models::SnapToRoadSnapResponse::Geojson, nil]
+      optional :geojson, -> { Nextbillionai::Models::SnapToRoadSnapResponse::Geojson }
+
+      # @!attribute geometry
+      #   An array of strings containing the encoded geometries of snapped paths in
+      #   polyline or polyline6 format.
+      #
+      #   @return [Array<String>, nil]
+      optional :geometry, Nextbillionai::Internal::Type::ArrayOf[String]
+
+      # @!attribute msg
+      #   Displays the error message in case of a failed request or operation. Please note
+      #   that this parameter is not returned in the response in case of a successful
+      #   request.
+      #
+      #   @return [String, nil]
+      optional :msg, String
+
+      # @!attribute road_info
+      #   An object containing the maximum speed information for each road segment present
+      #   in the route.
+      #
+      #   @return [Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo, nil]
+      optional :road_info, -> { Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo }
+
+      # @!attribute snapped_points
+      #   An array of objects. Each object provides the details of a path coordinate point
+      #   snapped to the nearest road.
+      #
+      #   @return [Array<Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint>, nil]
+      optional :snapped_points,
+               -> { Nextbillionai::Internal::Type::ArrayOf[Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint] },
+               api_name: :snappedPoints
+
+      # @!attribute status
+      #   A string indicating the state of the response. On normal responses, the value
+      #   will be Ok. Indicative HTTP error codes are returned for different errors. See
+      #   the [API Errors Codes](#api-error-codes) section below for more information.
+      #
+      #   @return [String, nil]
+      optional :status, String
+
+      # @!method initialize(distance: nil, geojson: nil, geometry: nil, msg: nil, road_info: nil, snapped_points: nil, status: nil)
+      #   Some parameter documentations has been truncated, see
+      #   {Nextbillionai::Models::SnapToRoadSnapResponse} for more details.
+      #
+      #   Response Body
+      #
+      #   @param distance [Integer] The total distance of the snapped path in meters.
+      #
+      #   @param geojson [Nextbillionai::Models::SnapToRoadSnapResponse::Geojson] A GeoJSON object with details of the snapped path. This object is returned when
+      #
+      #   @param geometry [Array<String>] An array of strings containing the encoded geometries of snapped paths in polyli
+      #
+      #   @param msg [String] Displays the error message in case of a failed request or operation. Please note
+      #
+      #   @param road_info [Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo] An object containing the maximum speed information for each road segment present
+      #
+      #   @param snapped_points [Array<Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint>] An array of objects. Each object provides the details of a path coordinate point
+      #
+      #   @param status [String] A string indicating the state of the response. On normal responses, the value wi
+
+      # @see Nextbillionai::Models::SnapToRoadSnapResponse#geojson
+      class Geojson < Nextbillionai::Internal::Type::BaseModel
+        # @!attribute geometry
+        #   An object with details of the geoJSON geometry of the snapped path.
+        #
+        #   @return [Nextbillionai::Models::SnapToRoadSnapResponse::Geojson::Geometry, nil]
+        optional :geometry, -> { Nextbillionai::Models::SnapToRoadSnapResponse::Geojson::Geometry }
+
+        # @!attribute properties
+        #   Properties associated with the geoJSON shape of the snapped path.
+        #
+        #   @return [String, nil]
+        optional :properties, String
+
+        # @!attribute type
+        #   Type of the GeoJSON object.
+        #
+        #   @return [String, nil]
+        optional :type, String
+
+        # @!method initialize(geometry: nil, properties: nil, type: nil)
+        #   A GeoJSON object with details of the snapped path. This object is returned when
+        #   the geometry field is set to geojson in the input request, otherwise it is not
+        #   present in the response. The contents of this object follow the
+        #   [geoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946).
+        #
+        #   @param geometry [Nextbillionai::Models::SnapToRoadSnapResponse::Geojson::Geometry] An object with details of the geoJSON geometry of the snapped path.
+        #
+        #   @param properties [String] Properties associated with the geoJSON shape of the snapped path.
+        #
+        #   @param type [String] Type of the GeoJSON object.
+
+        # @see Nextbillionai::Models::SnapToRoadSnapResponse::Geojson#geometry
+        class Geometry < Nextbillionai::Internal::Type::BaseModel
+          # @!attribute coordinates
+          #   An array of coordinates in the [longitude, latitude] format, representing the
+          #   snapped path geometry.
+          #
+          #   @return [Array<Float>, nil]
+          optional :coordinates, Nextbillionai::Internal::Type::ArrayOf[Float]
+
+          # @!attribute type
+          #   Type of the geoJSON geometry
+          #
+          #   @return [String, nil]
+          optional :type, String
+
+          # @!method initialize(coordinates: nil, type: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {Nextbillionai::Models::SnapToRoadSnapResponse::Geojson::Geometry} for more
+          #   details.
+          #
+          #   An object with details of the geoJSON geometry of the snapped path.
+          #
+          #   @param coordinates [Array<Float>] An array of coordinates in the [longitude, latitude] format, representing the sn
+          #
+          #   @param type [String] Type of the geoJSON geometry
+        end
+      end
+
+      # @see Nextbillionai::Models::SnapToRoadSnapResponse#road_info
+      class RoadInfo < Nextbillionai::Internal::Type::BaseModel
+        # @!attribute max_speed
+        #   An array of objects containing maximum speed, in kilometers per hour, for each
+        #   segment of the route. Each object represents one road segment.
+        #
+        #   @return [Array<Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo::MaxSpeed>, nil]
+        optional :max_speed,
+                 -> { Nextbillionai::Internal::Type::ArrayOf[Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo::MaxSpeed] }
+
+        # @!method initialize(max_speed: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo} for more details.
+        #
+        #   An object containing the maximum speed information for each road segment present
+        #   in the route.
+        #
+        #   @param max_speed [Array<Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo::MaxSpeed>] An array of objects containing maximum speed, in kilometers per hour, for each s
+
+        class MaxSpeed < Nextbillionai::Internal::Type::BaseModel
+          # @!attribute length
+          #   length refers to a sequence of 'n' consecutive vertices in the route geometry
+          #   starting from the offset, forming a continuous section of route where the
+          #   maximum speed is the same and is indicated in value.
+          #
+          #   @return [Integer, nil]
+          optional :length, Integer
+
+          # @!attribute offset
+          #   offset is the index value of the vertex of route geometry, which is the starting
+          #   point of the segment.
+          #
+          #   @return [Integer, nil]
+          optional :offset, Integer
+
+          # @!attribute value
+          #   value denotes the maximum speed of this segment, in kilometers per hour.
+          #
+          #   - A value of "-1" indicates that the speed is unlimited for this road segment.
+          #   - A value of "0" indicates that there is no information about the maximum speed
+          #     for this road segment.
+          #
+          #   @return [Float, nil]
+          optional :value, Float
+
+          # @!method initialize(length: nil, offset: nil, value: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {Nextbillionai::Models::SnapToRoadSnapResponse::RoadInfo::MaxSpeed} for more
+          #   details.
+          #
+          #   @param length [Integer] length refers to a sequence of 'n' consecutive vertices in the route geometry st
+          #
+          #   @param offset [Integer] offset is the index value of the vertex of route geometry, which is the starting
+          #
+          #   @param value [Float] value denotes the maximum speed of this segment, in kilometers per hour.
+        end
+      end
+
+      class SnappedPoint < Nextbillionai::Internal::Type::BaseModel
+        # @!attribute bearing
+        #   The bearing, calculated as the angle from true north in clockwise direction, of
+        #   the route leading to the next snapped point from the current snapped_point, in
+        #   radians. In case of the last snapped_point of the route, the bearing indicates
+        #   the direction of the route to the previous snapped_location.
+        #
+        #   @return [Float]
+        required :bearing, Float
+
+        # @!attribute distance
+        #   The distance of the snapped point from the original input coordinate in meters.
+        #
+        #   @return [Float]
+        required :distance, Float
+
+        # @!attribute location
+        #   The latitude and longitude coordinates of the snapped point.
+        #
+        #   @return [Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint::Location]
+        required :location, -> { Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint::Location }
+
+        # @!attribute name
+        #   The name of the street or road that the input coordinate snapped to.
+        #
+        #   @return [String]
+        required :name, String
+
+        # @!attribute original_index
+        #   The index of the input path coordinate point to which this snapped point
+        #   corresponds to.
+        #
+        #   @return [Integer]
+        required :original_index, Integer, api_name: :originalIndex
+
+        # @!method initialize(bearing:, distance:, location:, name:, original_index:)
+        #   Some parameter documentations has been truncated, see
+        #   {Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint} for more details.
+        #
+        #   @param bearing [Float] The bearing, calculated as the angle from true north in clockwise direction, of
+        #
+        #   @param distance [Float] The distance of the snapped point from the original input coordinate in meters.
+        #
+        #   @param location [Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint::Location] The latitude and longitude coordinates of the snapped point.
+        #
+        #   @param name [String] The name of the street or road that the input coordinate snapped to.
+        #
+        #   @param original_index [Integer] The index of the input path coordinate point to which this snapped point corresp
+
+        # @see Nextbillionai::Models::SnapToRoadSnapResponse::SnappedPoint#location
+        class Location < Nextbillionai::Internal::Type::BaseModel
+          # @!attribute latitude
+          #   Latitude of the snapped point.
+          #
+          #   @return [Float]
+          required :latitude, Float
+
+          # @!attribute longitude
+          #   Longitude of the snapped point.
+          #
+          #   @return [Float]
+          required :longitude, Float
+
+          # @!method initialize(latitude:, longitude:)
+          #   The latitude and longitude coordinates of the snapped point.
+          #
+          #   @param latitude [Float] Latitude of the snapped point.
+          #
+          #   @param longitude [Float] Longitude of the snapped point.
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/models.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  [
+    Nextbillionai::Internal::Type::BaseModel,
+    *Nextbillionai::Internal::Type::BaseModel.subclasses
+  ].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, Nextbillionai::Internal::AnyHash) } }
+  end
+
+  Nextbillionai::Internal::Util.walk_namespaces(Nextbillionai::Models).each do |mod|
+    case mod
+    in Nextbillionai::Internal::Type::Enum | Nextbillionai::Internal::Type::Union
+      mod.constants.each do |name|
+        case mod.const_get(name)
+        in true | false
+          mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T::Boolean } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { Integer } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { Float } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { Symbol } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
+      end
+    else
+    end
+  end
+
+  Nextbillionai::Internal::Util.walk_namespaces(Nextbillionai::Models)
+                               .lazy
+                               .grep(Nextbillionai::Internal::Type::Union)
+                               .each do |mod|
+    const = :Variants
+    next if mod.sorbet_constant_defined?(const)
+
+    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+  end
+
+  Access = Nextbillionai::Models::Access
+
+  Address = Nextbillionai::Models::Address
+
+  AreaListParams = Nextbillionai::Models::AreaListParams
+
+  AutocompleteSuggestParams = Nextbillionai::Models::AutocompleteSuggestParams
+
+  AutosuggestSuggestParams = Nextbillionai::Models::AutosuggestSuggestParams
+
+  BatchCreateParams = Nextbillionai::Models::BatchCreateParams
+
+  BatchRetrieveParams = Nextbillionai::Models::BatchRetrieveParams
+
+  BrowseSearchParams = Nextbillionai::Models::BrowseSearchParams
+
+  Categories = Nextbillionai::Models::Categories
+
+  ContactObject = Nextbillionai::Models::ContactObject
+
+  Contacts = Nextbillionai::Models::Contacts
+
+  DirectionComputeRouteParams = Nextbillionai::Models::DirectionComputeRouteParams
+
+  DiscoverRetrieveParams = Nextbillionai::Models::DiscoverRetrieveParams
+
+  DistanceMatrix = Nextbillionai::Models::DistanceMatrix
+
+  Fleetify = Nextbillionai::Models::Fleetify
+
+  GeocodeBatchCreateParams = Nextbillionai::Models::GeocodeBatchCreateParams
+
+  GeocodeRetrieveParams = Nextbillionai::Models::GeocodeRetrieveParams
+
+  GeocodeStructuredRetrieveParams = Nextbillionai::Models::GeocodeStructuredRetrieveParams
+
+  Geofence = Nextbillionai::Models::Geofence
+
+  GeofenceAPI = Nextbillionai::Models::GeofenceAPI
+
+  GeofenceContainsParams = Nextbillionai::Models::GeofenceContainsParams
+
+  GeofenceCreateParams = Nextbillionai::Models::GeofenceCreateParams
+
+  GeofenceDeleteParams = Nextbillionai::Models::GeofenceDeleteParams
+
+  GeofenceEntityCreate = Nextbillionai::Models::GeofenceEntityCreate
+
+  GeofenceListParams = Nextbillionai::Models::GeofenceListParams
+
+  GeofenceRetrieveParams = Nextbillionai::Models::GeofenceRetrieveParams
+
+  GeofenceUpdateParams = Nextbillionai::Models::GeofenceUpdateParams
+
+  IsochroneComputeParams = Nextbillionai::Models::IsochroneComputeParams
+
+  LookupByIDParams = Nextbillionai::Models::LookupByIDParams
+
+  MapCreateSegmentParams = Nextbillionai::Models::MapCreateSegmentParams
+
+  MapView = Nextbillionai::Models::MapView
+
+  MdmCreateDistanceMatrixParams = Nextbillionai::Models::MdmCreateDistanceMatrixParams
+
+  MdmGetDistanceMatrixStatusParams = Nextbillionai::Models::MdmGetDistanceMatrixStatusParams
+
+  Multigeocode = Nextbillionai::Models::Multigeocode
+
+  MultigeocodeSearchParams = Nextbillionai::Models::MultigeocodeSearchParams
+
+  NavigationRetrieveRouteParams = Nextbillionai::Models::NavigationRetrieveRouteParams
+
+  Optimization = Nextbillionai::Models::Optimization
+
+  OptimizationComputeParams = Nextbillionai::Models::OptimizationComputeParams
+
+  OptimizationReOptimizeParams = Nextbillionai::Models::OptimizationReOptimizeParams
+
+  Position = Nextbillionai::Models::Position
+
+  PostalcodeRetrieveCoordinatesParams = Nextbillionai::Models::PostalcodeRetrieveCoordinatesParams
+
+  PostResponse = Nextbillionai::Models::PostResponse
+
+  RestrictionCreateParams = Nextbillionai::Models::RestrictionCreateParams
+
+  RestrictionDeleteParams = Nextbillionai::Models::RestrictionDeleteParams
+
+  RestrictionListByBboxParams = Nextbillionai::Models::RestrictionListByBboxParams
+
+  RestrictionListParams = Nextbillionai::Models::RestrictionListParams
+
+  RestrictionRetrieveParams = Nextbillionai::Models::RestrictionRetrieveParams
+
+  RestrictionSetStateParams = Nextbillionai::Models::RestrictionSetStateParams
+
+  RestrictionsItemListParams = Nextbillionai::Models::RestrictionsItemListParams
+
+  RestrictionUpdateParams = Nextbillionai::Models::RestrictionUpdateParams
+
+  RevgeocodeRetrieveParams = Nextbillionai::Models::RevgeocodeRetrieveParams
+
+  RichGroupRequest = Nextbillionai::Models::RichGroupRequest
+
+  RichGroupResponse = Nextbillionai::Models::RichGroupResponse
+
+  RouteReportCreateParams = Nextbillionai::Models::RouteReportCreateParams
+
+  Skynet = Nextbillionai::Models::Skynet
+
+  SkynetSubscribeParams = Nextbillionai::Models::SkynetSubscribeParams
+
+  SnapToRoadSnapParams = Nextbillionai::Models::SnapToRoadSnapParams
+end