nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/models/isochrone_compute_params.rbi

@@ -0,0 +1,248 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class IsochroneComputeParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Nextbillionai::IsochroneComputeParams,
+            Nextbillionai::Internal::AnyHash
+          )
+        end
+
+      # The distances, in meters, to use for each isochrone contour. You can specify up
+      # to four contours. Distances must be in increasing order. The maximum distance
+      # that can be specified is 60000 meters (60 km).
+      sig { returns(Integer) }
+      attr_accessor :contours_meters
+
+      # The times, in minutes, to use for each isochrone contour. You can specify up to
+      # four contours. Times must be in increasing order. The maximum time that can be
+      # specified is 40 minutes.
+      sig { returns(Integer) }
+      attr_accessor :contours_minutes
+
+      # The coordinates of the location which acts as the starting point for which the
+      # isochrone lines need to be determined.
+      sig { returns(String) }
+      attr_accessor :coordinates
+
+      # A key is a unique identifier that is required to authenticate a request to the
+      # API.
+      sig { returns(String) }
+      attr_accessor :key
+
+      # The hex code of the color to fill isochrone contour. When requesting multiple
+      # contours, it is recommended to provide color codes for each of the requested
+      # contours, separated by a ",". If no colors are specified, the Isochrone API will
+      # assign a random color scheme to the output.
+      sig { returns(T.nilable(String)) }
+      attr_reader :contours_colors
+
+      sig { params(contours_colors: String).void }
+      attr_writer :contours_colors
+
+      # A floating point value from 0.0 to 1.0 can be used to remove smaller contours.
+      # The default is 1.0. A value of 1.0 will only return the largest contour for a
+      # given value. A value of 0.5 drops any contours that are less than half the area
+      # of the largest contour in the set of contours for that same value.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :denoise
+
+      sig { params(denoise: Float).void }
+      attr_writer :denoise
+
+      # Use this parameter to set a departure time, expressed as UNIX epoch timestamp in
+      # seconds, for calculating the isochrone contour. The response will consider the
+      # typical traffic conditions at the given time and return a contour which can be
+      # reached under those traffic conditions. Please note that if no input is provided
+      # for this parameter then the traffic conditions at the time of making the request
+      # are considered.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :departure_time
+
+      sig { params(departure_time: Integer).void }
+      attr_writer :departure_time
+
+      # A positive floating point value, in meters, used as the tolerance for
+      # Douglas-Peucker generalization. There is no upper bound. If no value is
+      # specified in the request, the Isochrone API will choose the most optimized
+      # generalization to use for the request. Note that the generalization of contours
+      # can lead to self-intersections, as well as intersections of adjacent contours.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :generalize
+
+      sig { params(generalize: Float).void }
+      attr_writer :generalize
+
+      # Set which driving mode the service should use to determine the contour. For
+      # example, if you use "car", the API will return an isochrone contour that a car
+      # can reach within the specified time or after driving the specified distance.
+      # Using "truck" will return a contour that a truck can reach after 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.
+      sig do
+        returns(
+          T.nilable(Nextbillionai::IsochroneComputeParams::Mode::OrSymbol)
+        )
+      end
+      attr_reader :mode
+
+      sig do
+        params(mode: Nextbillionai::IsochroneComputeParams::Mode::OrSymbol).void
+      end
+      attr_writer :mode
+
+      # Specify whether to return the contours as GeoJSON polygons (true) or linestrings
+      # (false, default). When polygons=true, any contour that forms a ring is returned
+      # as a polygon.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :polygons
+
+      sig { params(polygons: T::Boolean).void }
+      attr_writer :polygons
+
+      sig do
+        params(
+          contours_meters: Integer,
+          contours_minutes: Integer,
+          coordinates: String,
+          key: String,
+          contours_colors: String,
+          denoise: Float,
+          departure_time: Integer,
+          generalize: Float,
+          mode: Nextbillionai::IsochroneComputeParams::Mode::OrSymbol,
+          polygons: T::Boolean,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The distances, in meters, to use for each isochrone contour. You can specify up
+        # to four contours. Distances must be in increasing order. The maximum distance
+        # that can be specified is 60000 meters (60 km).
+        contours_meters:,
+        # The times, in minutes, to use for each isochrone contour. You can specify up to
+        # four contours. Times must be in increasing order. The maximum time that can be
+        # specified is 40 minutes.
+        contours_minutes:,
+        # The coordinates of the location which acts as the starting point for which the
+        # isochrone lines need to be determined.
+        coordinates:,
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # The hex code of the color to fill isochrone contour. When requesting multiple
+        # contours, it is recommended to provide color codes for each of the requested
+        # contours, separated by a ",". If no colors are specified, the Isochrone API will
+        # assign a random color scheme to the output.
+        contours_colors: nil,
+        # A floating point value from 0.0 to 1.0 can be used to remove smaller contours.
+        # The default is 1.0. A value of 1.0 will only return the largest contour for a
+        # given value. A value of 0.5 drops any contours that are less than half the area
+        # of the largest contour in the set of contours for that same value.
+        denoise: nil,
+        # Use this parameter to set a departure time, expressed as UNIX epoch timestamp in
+        # seconds, for calculating the isochrone contour. The response will consider the
+        # typical traffic conditions at the given time and return a contour which can be
+        # reached under those traffic conditions. Please note that if no input is provided
+        # for this parameter then the traffic conditions at the time of making the request
+        # are considered.
+        departure_time: nil,
+        # A positive floating point value, in meters, used as the tolerance for
+        # Douglas-Peucker generalization. There is no upper bound. If no value is
+        # specified in the request, the Isochrone API will choose the most optimized
+        # generalization to use for the request. Note that the generalization of contours
+        # can lead to self-intersections, as well as intersections of adjacent contours.
+        generalize: nil,
+        # Set which driving mode the service should use to determine the contour. For
+        # example, if you use "car", the API will return an isochrone contour that a car
+        # can reach within the specified time or after driving the specified distance.
+        # Using "truck" will return a contour that a truck can reach after 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.
+        mode: nil,
+        # Specify whether to return the contours as GeoJSON polygons (true) or linestrings
+        # (false, default). When polygons=true, any contour that forms a ring is returned
+        # as a polygon.
+        polygons: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            contours_meters: Integer,
+            contours_minutes: Integer,
+            coordinates: String,
+            key: String,
+            contours_colors: String,
+            denoise: Float,
+            departure_time: Integer,
+            generalize: Float,
+            mode: Nextbillionai::IsochroneComputeParams::Mode::OrSymbol,
+            polygons: T::Boolean,
+            request_options: Nextbillionai::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Set which driving mode the service should use to determine the contour. For
+      # example, if you use "car", the API will return an isochrone contour that a car
+      # can reach within the specified time or after driving the specified distance.
+      # Using "truck" will return a contour that a truck can reach after 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
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Nextbillionai::IsochroneComputeParams::Mode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CAR =
+          T.let(:car, Nextbillionai::IsochroneComputeParams::Mode::TaggedSymbol)
+        TRUCK =
+          T.let(
+            :truck,
+            Nextbillionai::IsochroneComputeParams::Mode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Nextbillionai::IsochroneComputeParams::Mode::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/isochrone_compute_response.rbi

@@ -0,0 +1,369 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class IsochroneComputeResponse < Nextbillionai::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Nextbillionai::Models::IsochroneComputeResponse,
+            Nextbillionai::Internal::AnyHash
+          )
+        end
+
+      # A
+      # [GeoJSON FeatureCollection](https://datatracker.ietf.org/doc/html/rfc7946#section-3.3)
+      # object with details of the isochrone contours. Each feature object in this
+      # collection represents an isochrone.
+      sig do
+        returns(
+          T.nilable(
+            T::Array[Nextbillionai::Models::IsochroneComputeResponse::Feature]
+          )
+        )
+      end
+      attr_reader :features
+
+      sig do
+        params(
+          features:
+            T::Array[
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::OrHash
+            ]
+        ).void
+      end
+      attr_writer :features
+
+      # 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.
+      sig { returns(T.nilable(String)) }
+      attr_reader :msg
+
+      sig { params(msg: String).void }
+      attr_writer :msg
+
+      # 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.
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      # Type of the GeoJSON object. As prescribed in
+      # [GeoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946#section-1.4),
+      # its value is FeatureCollection as the feature property contains a list of
+      # geoJSON feature objects.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      sig do
+        params(
+          features:
+            T::Array[
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::OrHash
+            ],
+          msg: String,
+          status: String,
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A
+        # [GeoJSON FeatureCollection](https://datatracker.ietf.org/doc/html/rfc7946#section-3.3)
+        # object with details of the isochrone contours. Each feature object in this
+        # collection represents an isochrone.
+        features: nil,
+        # 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.
+        msg: nil,
+        # 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.
+        status: nil,
+        # Type of the GeoJSON object. As prescribed in
+        # [GeoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946#section-1.4),
+        # its value is FeatureCollection as the feature property contains a list of
+        # geoJSON feature objects.
+        type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            features:
+              T::Array[
+                Nextbillionai::Models::IsochroneComputeResponse::Feature
+              ],
+            msg: String,
+            status: String,
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Feature < Nextbillionai::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::Models::IsochroneComputeResponse::Feature,
+              Nextbillionai::Internal::AnyHash
+            )
+          end
+
+        # A [GeoJSON geometry](https://datatracker.ietf.org/doc/html/rfc7946#page-7)
+        # object with details of the contour line.
+        sig do
+          returns(
+            T.nilable(
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::Geometry
+            )
+          )
+        end
+        attr_reader :geometry
+
+        sig do
+          params(
+            geometry:
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::Geometry::OrHash
+          ).void
+        end
+        attr_writer :geometry
+
+        # An object with details of how the isochrone contour can be drawn on a map.
+        sig do
+          returns(
+            T.nilable(
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::Properties
+            )
+          )
+        end
+        attr_reader :properties
+
+        sig do
+          params(
+            properties:
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::Properties::OrHash
+          ).void
+        end
+        attr_writer :properties
+
+        # Type of the GeoJSON object. Its value is Feature as per the
+        # [GeoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946#section-1.4)
+        # object.
+        sig { returns(T.nilable(String)) }
+        attr_reader :type
+
+        sig { params(type: String).void }
+        attr_writer :type
+
+        sig do
+          params(
+            geometry:
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::Geometry::OrHash,
+            properties:
+              Nextbillionai::Models::IsochroneComputeResponse::Feature::Properties::OrHash,
+            type: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A [GeoJSON geometry](https://datatracker.ietf.org/doc/html/rfc7946#page-7)
+          # object with details of the contour line.
+          geometry: nil,
+          # An object with details of how the isochrone contour can be drawn on a map.
+          properties: nil,
+          # Type of the GeoJSON object. Its value is Feature as per the
+          # [GeoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946#section-1.4)
+          # object.
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              geometry:
+                Nextbillionai::Models::IsochroneComputeResponse::Feature::Geometry,
+              properties:
+                Nextbillionai::Models::IsochroneComputeResponse::Feature::Properties,
+              type: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Geometry < Nextbillionai::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Nextbillionai::Models::IsochroneComputeResponse::Feature::Geometry,
+                Nextbillionai::Internal::AnyHash
+              )
+            end
+
+          # An array of coordinate points, in [longitude,latitude] format representing the
+          # isochrone contour line.
+          sig { returns(T.nilable(T::Array[Float])) }
+          attr_reader :coordinates
+
+          sig { params(coordinates: T::Array[Float]).void }
+          attr_writer :coordinates
+
+          # Type of the geoJSON geometry.
+          sig { returns(T.nilable(String)) }
+          attr_reader :type
+
+          sig { params(type: String).void }
+          attr_writer :type
+
+          # A [GeoJSON geometry](https://datatracker.ietf.org/doc/html/rfc7946#page-7)
+          # object with details of the contour line.
+          sig do
+            params(coordinates: T::Array[Float], type: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # An array of coordinate points, in [longitude,latitude] format representing the
+            # isochrone contour line.
+            coordinates: nil,
+            # Type of the geoJSON geometry.
+            type: nil
+          )
+          end
+
+          sig do
+            override.returns({ coordinates: T::Array[Float], type: String })
+          end
+          def to_hash
+          end
+        end
+
+        class Properties < Nextbillionai::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Nextbillionai::Models::IsochroneComputeResponse::Feature::Properties,
+                Nextbillionai::Internal::AnyHash
+              )
+            end
+
+          # The hex code of the color of the isochrone contour line
+          sig { returns(T.nilable(String)) }
+          attr_reader :color
+
+          sig { params(color: String).void }
+          attr_writer :color
+
+          # The value of the metric used in this contour. See the metric property to
+          # determine whether this is a time or distance contour. When the metric is time
+          # this value denotes the travel time in minutes and when the metric is distance
+          # this value denotes the travel distance in kilometers.
+          sig { returns(T.nilable(Float)) }
+          attr_reader :contour
+
+          sig { params(contour: Float).void }
+          attr_writer :contour
+
+          # The hex code for the fill color of the isochrone contour line.
+          sig { returns(T.nilable(String)) }
+          attr_reader :fill
+
+          sig { params(fill: String).void }
+          attr_writer :fill
+
+          # The hex code for the fill color of the isochrone contour line
+          sig { returns(T.nilable(String)) }
+          attr_reader :fill_color
+
+          sig { params(fill_color: String).void }
+          attr_writer :fill_color
+
+          # The fill opacity for the isochrone contour line. It is a float value starting
+          # from 0.0 with a max value of 1.0. Higher number indicates a higher fill opacity.
+          sig { returns(T.nilable(Float)) }
+          attr_reader :fill_opacity
+
+          sig { params(fill_opacity: Float).void }
+          attr_writer :fill_opacity
+
+          # The metric that the contour represents - either distance or time
+          sig { returns(T.nilable(String)) }
+          attr_reader :metric
+
+          sig { params(metric: String).void }
+          attr_writer :metric
+
+          # The opacity of the isochrone contour line. It is a float value starting from 0.0
+          # with a max value of 1.0. Higher number indicates a higher line opacity
+          sig { returns(T.nilable(Float)) }
+          attr_reader :opacity
+
+          sig { params(opacity: Float).void }
+          attr_writer :opacity
+
+          # An object with details of how the isochrone contour can be drawn on a map.
+          sig do
+            params(
+              color: String,
+              contour: Float,
+              fill: String,
+              fill_color: String,
+              fill_opacity: Float,
+              metric: String,
+              opacity: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The hex code of the color of the isochrone contour line
+            color: nil,
+            # The value of the metric used in this contour. See the metric property to
+            # determine whether this is a time or distance contour. When the metric is time
+            # this value denotes the travel time in minutes and when the metric is distance
+            # this value denotes the travel distance in kilometers.
+            contour: nil,
+            # The hex code for the fill color of the isochrone contour line.
+            fill: nil,
+            # The hex code for the fill color of the isochrone contour line
+            fill_color: nil,
+            # The fill opacity for the isochrone contour line. It is a float value starting
+            # from 0.0 with a max value of 1.0. Higher number indicates a higher fill opacity.
+            fill_opacity: nil,
+            # The metric that the contour represents - either distance or time
+            metric: nil,
+            # The opacity of the isochrone contour line. It is a float value starting from 0.0
+            # with a max value of 1.0. Higher number indicates a higher line opacity
+            opacity: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                color: String,
+                contour: Float,
+                fill: String,
+                fill_color: String,
+                fill_opacity: Float,
+                metric: String,
+                opacity: Float
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/lookup_by_id_params.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class LookupByIDParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Nextbillionai::LookupByIDParams,
+            Nextbillionai::Internal::AnyHash
+          )
+        end
+
+      # Specify the unique identifier of a specific POI, Street, Geography, Point
+      # Address or other entities to retrieve its details.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # A key is a unique identifier that is required to authenticate a request to the
+      # API.
+      sig { returns(String) }
+      attr_accessor :key
+
+      sig do
+        params(
+          id: String,
+          key: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Specify the unique identifier of a specific POI, Street, Geography, Point
+        # Address or other entities to retrieve its details.
+        id:,
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end