nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/models/geofence.rbi

@@ -0,0 +1,326 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class GeofenceAPI < Nextbillionai::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Nextbillionai::GeofenceAPI, Nextbillionai::Internal::AnyHash)
+        end
+
+      # ID of the geofence provided/generated at the time of creating the geofence.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      sig { returns(T.nilable(Nextbillionai::GeofenceAPI::CircleCenter)) }
+      attr_reader :circle_center
+
+      sig do
+        params(
+          circle_center: Nextbillionai::GeofenceAPI::CircleCenter::OrHash
+        ).void
+      end
+      attr_writer :circle_center
+
+      # When the type of the geofence is circle, this property returns the radius of the
+      # geofence in meters (m).
+      sig { returns(T.nilable(Float)) }
+      attr_reader :circle_radius
+
+      sig { params(circle_radius: Float).void }
+      attr_writer :circle_radius
+
+      # Time at which the geofence was created, expressed as a UNIX timestamp in
+      # seconds.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Integer).void }
+      attr_writer :created_at
+
+      # An object with geoJSON details of the geofence. The contents of this object
+      # follow the [geoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946).
+      sig { returns(T.nilable(Nextbillionai::Geofence::PolygonGeojson)) }
+      attr_reader :geojson
+
+      sig do
+        params(geojson: Nextbillionai::Geofence::PolygonGeojson::OrHash).void
+      end
+      attr_writer :geojson
+
+      # For a geofence based on isochrone contour determined using a specific driving
+      # distance, this property returns the duration value, in meters.
+      #
+      # The value would be the same as that provided for the contours_meter parameter at
+      # the time of creating or updating the geofence.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :ic_contours_meter
+
+      sig { params(ic_contours_meter: Integer).void }
+      attr_writer :ic_contours_meter
+
+      # For a geofence based on isochrone contour determined using a specific driving
+      # duration, this property returns the duration value, in minutes. The value would
+      # be the same as the value provided for the contours_minute parameter at the time
+      # of creating or updating the geofence.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :ic_contours_minute
+
+      sig { params(ic_contours_minute: Integer).void }
+      attr_writer :ic_contours_minute
+
+      # For a geofence based on isochrone contour, this property returns the coordinates
+      # of the location, in [latitude,longitude] format, which was used as the starting
+      # point to identify the geofence boundary.
+      #
+      # The value would be the same as that provided for the coordinates parameter at
+      # the time of creating or updating the geofence.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ic_coordinates
+
+      sig { params(ic_coordinates: String).void }
+      attr_writer :ic_coordinates
+
+      # For a geofence based on isochrone contour, this property returns the denoise
+      # value which would be the same as that provided for the denoise parameter at the
+      # time of creating or updating the geofence.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :ic_denoise
+
+      sig { params(ic_denoise: Float).void }
+      attr_writer :ic_denoise
+
+      # For a geofence based on isochrone contour, this property returns the departure
+      # time, as a UNIX epoch timestamp in seconds, which was used to determine the
+      # geofence boundary after taking into account the traffic conditions at the time.
+      #
+      # The value would be the same as that provided for the departure_time parameter at
+      # the time of creating or updating the geofence.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :ic_departure_time
+
+      sig { params(ic_departure_time: Integer).void }
+      attr_writer :ic_departure_time
+
+      # For a geofence based on isochrone contour, this property returns the driving
+      # mode used to determine the geofence boundary.
+      #
+      # The value would be the same as that provided for the mode parameter at the time
+      # of creating or updating the geofence.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :ic_mode
+
+      sig { params(ic_mode: Float).void }
+      attr_writer :ic_mode
+
+      # Metadata of the geofence added at the time of creating or updating it.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :meta_data
+
+      sig { params(meta_data: T.anything).void }
+      attr_writer :meta_data
+
+      # Name of the geofence added at the time of creating or updating it.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # An array of strings representing the tags associated with the geofence added at
+      # the time of creating or updating it.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :tags
+
+      sig { params(tags: T::Array[String]).void }
+      attr_writer :tags
+
+      # Type of the geofence.
+      sig { returns(T.nilable(Nextbillionai::GeofenceAPI::Type::TaggedSymbol)) }
+      attr_reader :type
+
+      sig { params(type: Nextbillionai::GeofenceAPI::Type::OrSymbol).void }
+      attr_writer :type
+
+      # Time at which the geofence was last updated, expressed as a UNIX timestamp in
+      # seconds.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: Integer).void }
+      attr_writer :updated_at
+
+      # An object with details of the geofence.
+      sig do
+        params(
+          id: String,
+          circle_center: Nextbillionai::GeofenceAPI::CircleCenter::OrHash,
+          circle_radius: Float,
+          created_at: Integer,
+          geojson: Nextbillionai::Geofence::PolygonGeojson::OrHash,
+          ic_contours_meter: Integer,
+          ic_contours_minute: Integer,
+          ic_coordinates: String,
+          ic_denoise: Float,
+          ic_departure_time: Integer,
+          ic_mode: Float,
+          meta_data: T.anything,
+          name: String,
+          tags: T::Array[String],
+          type: Nextbillionai::GeofenceAPI::Type::OrSymbol,
+          updated_at: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # ID of the geofence provided/generated at the time of creating the geofence.
+        id: nil,
+        circle_center: nil,
+        # When the type of the geofence is circle, this property returns the radius of the
+        # geofence in meters (m).
+        circle_radius: nil,
+        # Time at which the geofence was created, expressed as a UNIX timestamp in
+        # seconds.
+        created_at: nil,
+        # An object with geoJSON details of the geofence. The contents of this object
+        # follow the [geoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946).
+        geojson: nil,
+        # For a geofence based on isochrone contour determined using a specific driving
+        # distance, this property returns the duration value, in meters.
+        #
+        # The value would be the same as that provided for the contours_meter parameter at
+        # the time of creating or updating the geofence.
+        ic_contours_meter: nil,
+        # For a geofence based on isochrone contour determined using a specific driving
+        # duration, this property returns the duration value, in minutes. The value would
+        # be the same as the value provided for the contours_minute parameter at the time
+        # of creating or updating the geofence.
+        ic_contours_minute: nil,
+        # For a geofence based on isochrone contour, this property returns the coordinates
+        # of the location, in [latitude,longitude] format, which was used as the starting
+        # point to identify the geofence boundary.
+        #
+        # The value would be the same as that provided for the coordinates parameter at
+        # the time of creating or updating the geofence.
+        ic_coordinates: nil,
+        # For a geofence based on isochrone contour, this property returns the denoise
+        # value which would be the same as that provided for the denoise parameter at the
+        # time of creating or updating the geofence.
+        ic_denoise: nil,
+        # For a geofence based on isochrone contour, this property returns the departure
+        # time, as a UNIX epoch timestamp in seconds, which was used to determine the
+        # geofence boundary after taking into account the traffic conditions at the time.
+        #
+        # The value would be the same as that provided for the departure_time parameter at
+        # the time of creating or updating the geofence.
+        ic_departure_time: nil,
+        # For a geofence based on isochrone contour, this property returns the driving
+        # mode used to determine the geofence boundary.
+        #
+        # The value would be the same as that provided for the mode parameter at the time
+        # of creating or updating the geofence.
+        ic_mode: nil,
+        # Metadata of the geofence added at the time of creating or updating it.
+        meta_data: nil,
+        # Name of the geofence added at the time of creating or updating it.
+        name: nil,
+        # An array of strings representing the tags associated with the geofence added at
+        # the time of creating or updating it.
+        tags: nil,
+        # Type of the geofence.
+        type: nil,
+        # Time at which the geofence was last updated, expressed as a UNIX timestamp in
+        # seconds.
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            circle_center: Nextbillionai::GeofenceAPI::CircleCenter,
+            circle_radius: Float,
+            created_at: Integer,
+            geojson: Nextbillionai::Geofence::PolygonGeojson,
+            ic_contours_meter: Integer,
+            ic_contours_minute: Integer,
+            ic_coordinates: String,
+            ic_denoise: Float,
+            ic_departure_time: Integer,
+            ic_mode: Float,
+            meta_data: T.anything,
+            name: String,
+            tags: T::Array[String],
+            type: Nextbillionai::GeofenceAPI::Type::TaggedSymbol,
+            updated_at: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class CircleCenter < Nextbillionai::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::GeofenceAPI::CircleCenter,
+              Nextbillionai::Internal::AnyHash
+            )
+          end
+
+        # Latitude of the location.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :lat
+
+        sig { params(lat: Float).void }
+        attr_writer :lat
+
+        # Longitude of the location.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :lon
+
+        sig { params(lon: Float).void }
+        attr_writer :lon
+
+        sig { params(lat: Float, lon: Float).returns(T.attached_class) }
+        def self.new(
+          # Latitude of the location.
+          lat: nil,
+          # Longitude of the location.
+          lon: nil
+        )
+        end
+
+        sig { override.returns({ lat: Float, lon: Float }) }
+        def to_hash
+        end
+      end
+
+      # Type of the geofence.
+      module Type
+        extend Nextbillionai::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Nextbillionai::GeofenceAPI::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CIRCLE = T.let(:circle, Nextbillionai::GeofenceAPI::Type::TaggedSymbol)
+        POLYGON =
+          T.let(:polygon, Nextbillionai::GeofenceAPI::Type::TaggedSymbol)
+        ISOCHRONE =
+          T.let(:isochrone, Nextbillionai::GeofenceAPI::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Nextbillionai::GeofenceAPI::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/geofence_contains_params.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class GeofenceContainsParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Nextbillionai::GeofenceContainsParams,
+            Nextbillionai::Internal::AnyHash
+          )
+        end
+
+      # A key is a unique identifier that is required to authenticate a request to the
+      # API.
+      sig { returns(String) }
+      attr_accessor :key
+
+      # Pipe (|) separated coordinates, in [latitude,longitude] format, of the locations
+      # to be searched against the geofences.
+      sig { returns(String) }
+      attr_accessor :locations
+
+      # A , separated list geofence IDs against which the locations will be searched. If
+      # not provided, then the 'locations' will be searched against all your existing
+      # geofences.
+      #
+      # Maximum length of the string can be 256 characters.
+      sig { returns(T.nilable(String)) }
+      attr_reader :geofences
+
+      sig { params(geofences: String).void }
+      attr_writer :geofences
+
+      # When true, an array with detailed information of geofences is returned. When
+      # false, an array containing only the IDs of the geofences is returned.
+      sig { returns(T.nilable(String)) }
+      attr_reader :verbose
+
+      sig { params(verbose: String).void }
+      attr_writer :verbose
+
+      sig do
+        params(
+          key: String,
+          locations: String,
+          geofences: String,
+          verbose: String,
+          request_options: Nextbillionai::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A key is a unique identifier that is required to authenticate a request to the
+        # API.
+        key:,
+        # Pipe (|) separated coordinates, in [latitude,longitude] format, of the locations
+        # to be searched against the geofences.
+        locations:,
+        # A , separated list geofence IDs against which the locations will be searched. If
+        # not provided, then the 'locations' will be searched against all your existing
+        # geofences.
+        #
+        # Maximum length of the string can be 256 characters.
+        geofences: nil,
+        # When true, an array with detailed information of geofences is returned. When
+        # false, an array containing only the IDs of the geofences is returned.
+        verbose: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            key: String,
+            locations: String,
+            geofences: String,
+            verbose: String,
+            request_options: Nextbillionai::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/geofence_contains_response.rbi

@@ -0,0 +1,255 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class GeofenceContainsResponse < Nextbillionai::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Nextbillionai::Models::GeofenceContainsResponse,
+            Nextbillionai::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(
+          T.nilable(Nextbillionai::Models::GeofenceContainsResponse::Data)
+        )
+      end
+      attr_reader :data
+
+      sig do
+        params(
+          data: Nextbillionai::Models::GeofenceContainsResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      # A string indicating the state of the response. On successful responses, the
+      # value will be Ok. Indicative error messages are returned for different errors.
+      # See the [API Error 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
+
+      sig do
+        params(
+          data: Nextbillionai::Models::GeofenceContainsResponse::Data::OrHash,
+          status: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data: nil,
+        # A string indicating the state of the response. On successful responses, the
+        # value will be Ok. Indicative error messages are returned for different errors.
+        # See the [API Error Codes](#api-error-codes) section below for more information.
+        status: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Nextbillionai::Models::GeofenceContainsResponse::Data,
+            status: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Nextbillionai::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::Models::GeofenceContainsResponse::Data,
+              Nextbillionai::Internal::AnyHash
+            )
+          end
+
+        # An array of objects containing each of the geofences provided in the geofences
+        # input. If geofences in not provided then the array will return all the geofences
+        # associated with the key
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList
+              ]
+            )
+          )
+        end
+        attr_reader :result_list
+
+        sig do
+          params(
+            result_list:
+              T::Array[
+                Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::OrHash
+              ]
+          ).void
+        end
+        attr_writer :result_list
+
+        sig do
+          params(
+            result_list:
+              T::Array[
+                Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::OrHash
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # An array of objects containing each of the geofences provided in the geofences
+          # input. If geofences in not provided then the array will return all the geofences
+          # associated with the key
+          result_list: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              result_list:
+                T::Array[
+                  Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList
+                ]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ResultList < Nextbillionai::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList,
+                Nextbillionai::Internal::AnyHash
+              )
+            end
+
+          # An object with details of the geofence.
+          sig { returns(T.nilable(Nextbillionai::GeofenceAPI)) }
+          attr_reader :geofence_detail
+
+          sig do
+            params(geofence_detail: Nextbillionai::GeofenceAPI::OrHash).void
+          end
+          attr_writer :geofence_detail
+
+          # ID of the geofence provided/generated at the time of creating the geofence.
+          sig { returns(T.nilable(String)) }
+          attr_reader :geofence_id
+
+          sig { params(geofence_id: String).void }
+          attr_writer :geofence_id
+
+          # An array of objects with results of the contains check for each of the
+          # coordinate points in locations against the geofence represented by geofence_id.
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::Result
+                ]
+              )
+            )
+          end
+          attr_reader :result
+
+          sig do
+            params(
+              result:
+                T::Array[
+                  Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::Result::OrHash
+                ]
+            ).void
+          end
+          attr_writer :result
+
+          sig do
+            params(
+              geofence_detail: Nextbillionai::GeofenceAPI::OrHash,
+              geofence_id: String,
+              result:
+                T::Array[
+                  Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::Result::OrHash
+                ]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # An object with details of the geofence.
+            geofence_detail: nil,
+            # ID of the geofence provided/generated at the time of creating the geofence.
+            geofence_id: nil,
+            # An array of objects with results of the contains check for each of the
+            # coordinate points in locations against the geofence represented by geofence_id.
+            result: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                geofence_detail: Nextbillionai::GeofenceAPI,
+                geofence_id: String,
+                result:
+                  T::Array[
+                    Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::Result
+                  ]
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Result < Nextbillionai::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Nextbillionai::Models::GeofenceContainsResponse::Data::ResultList::Result,
+                  Nextbillionai::Internal::AnyHash
+                )
+              end
+
+            # true when a coordinate point in locations is contained by this geofence.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :contain
+
+            sig { params(contain: T::Boolean).void }
+            attr_writer :contain
+
+            # Index of the coordinate point in the input locations.
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :location_index
+
+            sig { params(location_index: Integer).void }
+            attr_writer :location_index
+
+            sig do
+              params(contain: T::Boolean, location_index: Integer).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # true when a coordinate point in locations is contained by this geofence.
+              contain: nil,
+              # Index of the coordinate point in the input locations.
+              location_index: nil
+            )
+            end
+
+            sig do
+              override.returns({ contain: T::Boolean, location_index: Integer })
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end