nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/resources/skynet/monitor.rbi

@@ -0,0 +1,305 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Monitor
+        # Create a Monitor
+        sig do
+          params(
+            key: String,
+            tags: T::Array[String],
+            type: Nextbillionai::Skynet::MonitorCreateParams::Type::OrSymbol,
+            cluster:
+              Nextbillionai::Skynet::MonitorCreateParams::Cluster::OrSymbol,
+            custom_id: String,
+            description: String,
+            geofence_config:
+              Nextbillionai::Skynet::MonitorCreateParams::GeofenceConfig::OrHash,
+            geofence_ids: T::Array[String],
+            idle_config:
+              Nextbillionai::Skynet::MonitorCreateParams::IdleConfig::OrHash,
+            match_filter:
+              Nextbillionai::Skynet::MonitorCreateParams::MatchFilter::OrHash,
+            meta_data: T.anything,
+            name: String,
+            speeding_config:
+              Nextbillionai::Skynet::MonitorCreateParams::SpeedingConfig::OrHash,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::MonitorCreateResponse)
+        end
+        def create(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Use this parameter to add tags to the monitor. tags can be used for
+          # filtering monitors in the _Get Monitor List_ operation. They can also be used
+          # for easy identification of monitors.
+          #
+          # Please note that valid tags are strings, consisting of alphanumeric characters
+          # (A-Z, a-z, 0-9) along with the underscore ('\_') and hyphen ('-') symbols.
+          tags:,
+          # Body param: Specify the type of activity the monitor would detect.
+          #
+          # The monitor will be able to detect the specified type of activity and create
+          # events for eligible asset. A monitor can detect following types of asset
+          # activity:
+          #
+          # - enter: The monitor will create an event when a linked asset enters into the
+          #   specified geofence.
+          #
+          # - exit: The monitor will create an event when a linked asset exits the specified
+          #   geofence.
+          #
+          # - enter_and_exit: The monitor will create an event when a linked asset either
+          #   enters or exits the specified geofence.
+          #
+          # - speeding: The monitor will create an event when a linked asset exceeds a given
+          #   speed limit.
+          #
+          # - idle: The monitor will create an event when a linked asset exhibits idle
+          #   activity.
+          #
+          # Please note that assets and geofences can be linked to a monitor using the
+          # match_filter and geofence_config attributes respectively.
+          type:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          # Body param: Set a unique ID for the new monitor. If not provided, an ID will be
+          # automatically generated in UUID format. A valid custom*id can contain letters,
+          # numbers, "-", & "*" only.
+          #
+          # Please note that the ID of an monitor can not be changed once it is created.
+          custom_id: nil,
+          # Body param: Add a description for your monitor using this parameter.
+          description: nil,
+          # Body param: Geofences are geographic boundaries surrounding an area of interest.
+          # geofence_config is used to specify the geofences for creating enter or exit type
+          # of events based on the asset's location. When an asset associated with the
+          # monitor enters the given geofence, an enter type event is created, whereas when
+          # the asset moves out of the geofence an exit type event is created.
+          #
+          # Please note that this object is mandatory when the monitor type belongs to one
+          # of enter, exit or enter_and_exit.
+          geofence_config: nil,
+          # Body param: **Deprecated. Please use the geofence_config to specify the
+          # geofence_ids for this monitor.**
+          #
+          # An array of strings to collect the geofence IDs that should be linked to the
+          # monitor. Geofences are geographic boundaries that can be used to trigger events
+          # based on an asset's location.
+          geofence_ids: nil,
+          # Body param: idle_config is used to set up constraints for creating idle events.
+          # When an asset associated with the monitor has not moved a given distance within
+          # a given time, the Live Tracking API can create events to denote such instances.
+          # Please note that this object is mandatory when the monitor type is idle.
+          #
+          # Let's look at the properties of this object.
+          idle_config: nil,
+          # Body param: This object is used to identify the asset(s) on which the monitor
+          # would be applied.
+          match_filter: nil,
+          # Body param: Any valid json object data. Can be used to save customized data. Max
+          # size is 65kb.
+          meta_data: nil,
+          # Body param: Name of the monitor. Use this field to assign a meaningful, custom
+          # name to the monitor being created.
+          name: nil,
+          # Body param: speeding_config is used to set up constraints for creating
+          # over-speed events. When an asset associated with a monitor is traveling at a
+          # speed above the given limits, the Live Tracking API can create events to denote
+          # such instances. There is also an option to set up a tolerance before creating an
+          # event. Please note that this object is mandatory when type=speeding.
+          #
+          # Let's look at the properties of this object.
+          speeding_config: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a Monitor
+        sig do
+          params(
+            id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::MonitorRetrieveResponse)
+        end
+        def retrieve(
+          # ID of the monitor to be fetched. This is the same ID that was generated at the
+          # time of creating the monitor.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # Update a Monitor
+        sig do
+          params(
+            id: String,
+            key: String,
+            description: String,
+            geofence_config:
+              Nextbillionai::Skynet::MonitorUpdateParams::GeofenceConfig::OrHash,
+            geofence_ids: T::Array[String],
+            idle_config:
+              Nextbillionai::Skynet::MonitorUpdateParams::IdleConfig::OrHash,
+            match_filter:
+              Nextbillionai::Skynet::MonitorUpdateParams::MatchFilter::OrHash,
+            meta_data: T.anything,
+            name: String,
+            speeding_config:
+              Nextbillionai::Skynet::MonitorUpdateParams::SpeedingConfig::OrHash,
+            tags: T::Array[String],
+            type: Nextbillionai::Skynet::MonitorUpdateParams::Type::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def update(
+          # Path param: ID of the monitor to be updated. This is the same ID that was
+          # generated at the time of creating the monitor.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Use this parameter to update the description of the monitor.
+          description: nil,
+          # Body param: geofence_config is used to update the set of geofences linked to the
+          # monitor for creating enter or exit type of events based on the asset's location.
+          # Please note that this object is mandatory when the monitor type belongs to one
+          # of enter, exit or enter_and_exit.
+          geofence_config: nil,
+          # Body param: Use this parameter to update the geofences linked to the monitor by
+          # providing the geofence id as , separated strings. Geofences are geographic
+          # boundaries that can be used to trigger events based on an asset's location.
+          geofence_ids: nil,
+          # Body param: idle_config is used to update the constraints for creating idle
+          # events. When an asset associated with the monitor has not moved a given distance
+          # within a given time, the Live Tracking API can create events to denote such
+          # instances.
+          #
+          # Please note that this object is mandatory when the monitor type is idle.
+          idle_config: nil,
+          # Body param: Use this object to update the attributes of the monitor. Please note
+          # that using this property will overwrite the existing attributes that the monitor
+          # might be using currently to match any asset(s).
+          match_filter: nil,
+          # Body param: Any valid json object data. Can be used to save customized data. Max
+          # size is 65kb.
+          meta_data: nil,
+          # Body param: Use this parameter to update the name of the monitor. Users can add
+          # meaningful names to the monitors like "warehouse_exit", "depot_entry" etc.
+          name: nil,
+          # Body param: speeding_config is used to update the tolerance values for creating
+          # over-speed events. When an asset associated with a monitor is traveling at a
+          # speed above the given limits, Live Tracking API creates events to indicate such
+          # instances.
+          #
+          # Please note that this object is mandatory when the monitor type is speeding.
+          speeding_config: nil,
+          # Body param: Use this parameter to update the tags of the monitor. tags can be
+          # used for filtering monitors in the _Get Monitor List_ operation. They can also
+          # be used for easy identification of monitors. Using this parameter overwrites the
+          # existing tags of the monitor.
+          #
+          # Please note that valid tags are strings, consisting of alphanumeric characters
+          # (A-Z, a-z, 0-9) along with the underscore ('\_') and hyphen ('-') symbols.
+          tags: nil,
+          # Body param: Use this parameter to update the type of the monitor. The monitor
+          # will be able to detect the specified type of activity and create events for
+          # eligible asset. A monitor can detect following types of asset activity:
+          #
+          # - enter: The monitor will create an event when a linked asset enters into the
+          #   specified geofence.
+          #
+          # - exit: The monitor will create an event when a linked asset exits the specified
+          #   geofence.
+          #
+          # - enter_and_exit: The monitor will create an event when a linked asset either
+          #   enters or exits the specified geofence.
+          #
+          # - speeding: The monitor will create an event when a linked asset exceeds a given
+          #   speed limit.
+          #
+          # - idle: The monitor will create an event when a linked asset exhibits idle
+          #   activity.
+          #
+          # Please note that assets and geofences can be linked to a monitor using the
+          # match_filter and geofence_config attributes respectively.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        # Get Monitor List
+        sig do
+          params(
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::MonitorListParams::Cluster::OrSymbol,
+            pn: Integer,
+            ps: Integer,
+            sort: String,
+            tags: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::MonitorListResponse)
+        end
+        def list(
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # the cluster of the region you want to use
+          cluster: nil,
+          # Denotes page number. Use this along with the ps parameter to implement
+          # pagination for your searched results. This parameter does not have a maximum
+          # limit but would return an empty response in case a higher value is provided when
+          # the result-set itself is smaller.
+          pn: nil,
+          # Denotes number of search results per page. Use this along with the pn parameter
+          # to implement pagination for your searched results.
+          ps: nil,
+          # Provide a single field to sort the results by. Only updated_at or created_at
+          # fields can be selected for ordering the results.
+          #
+          # By default, the result is sorted by created_at field in the descending order.
+          # Allowed values for specifying the order are asc for ascending order and desc for
+          # descending order.
+          sort: nil,
+          # tags can be used to filter the monitors. Only those monitors which have all the
+          # tags provided here, will be included in the search result. In case multiple tags
+          # need to be specified, use , to separate them.
+          tags: nil,
+          request_options: {}
+        )
+        end
+
+        # Delete a Monitor
+        sig do
+          params(
+            id: String,
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def delete(
+          # D of the monitor to be deleted. This is the same ID that was generated at the
+          # time of creating the monitor.
+          id,
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/skynet/namespaced_apikeys.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class NamespacedApikeys
+        # Create namespace under a parent key
+        sig do
+          params(
+            key: String,
+            namespace: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Skynet::NamespacedApikeyCreateResponse
+          )
+        end
+        def create(
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API.
+          key:,
+          # Specify a name for the namespace. If the namespace specified is unique then a
+          # new namespace along with a new key is created. Whereas if the specified
+          # namespace is not unique, a new key will be created in the existing namespace.
+          # Please note that a namespace cannot be created using another namespace key.
+          namespace:,
+          request_options: {}
+        )
+        end
+
+        # Delete namespace under a parent key
+        sig do
+          params(
+            key: String,
+            key_to_delete: String,
+            namespace: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(
+            Nextbillionai::Models::Skynet::NamespacedApikeyDeleteResponse
+          )
+        end
+        def delete(
+          # A key is a unique identifier that is required to authenticate a request to the
+          # API. Please note for the delete namespace key operation another namespace key
+          # cannot be used.
+          #
+          # The namespace created using this key can be managed using the APIs & Services >
+          # Credentials section of user’s
+          # [NextBillion Console](https://console.nextbillion.ai).
+          key:,
+          # Specify the key to be deleted.
+          key_to_delete:,
+          # Specify the name of the namespace to which the \key_to_delete\ belongs. Please
+          # note that a namespace key cannot be deleted using another namespace key.
+          namespace:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Nextbillionai::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/resources/skynet/search/polygon.rbi

@@ -0,0 +1,175 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Search
+        class Polygon
+          # Polygon Search
+          sig do
+            params(
+              key: String,
+              polygon:
+                Nextbillionai::Skynet::Search::PolygonCreateParams::Polygon::OrHash,
+              filter: String,
+              match_filter:
+                Nextbillionai::Skynet::Search::PolygonCreateParams::MatchFilter::OrHash,
+              max_search_limit: T::Boolean,
+              pn: Integer,
+              ps: Integer,
+              sort:
+                Nextbillionai::Skynet::Search::PolygonCreateParams::Sort::OrHash,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(Nextbillionai::Skynet::SearchResponse)
+          end
+          def create(
+            # Query param: A key is a unique identifier that is required to authenticate a
+            # request to the API.
+            key:,
+            # Body param: An object to collect geoJSON details of a custom polygon. Please
+            # ensure that:
+            #
+            # - the polygon provided is enclosed. This can be achieved by making the last
+            #   location coordinate in the list equal to the first location coordinate of the
+            #   list.
+            #
+            # - the 'polygon' provided does not contain multiple rings.
+            #
+            # The contents of this object follow the
+            # [geoJSON standard](https://datatracker.ietf.org/doc/html/rfc7946).
+            #
+            # Please note that the maximum area of the search polygon allowed is 3000
+            # km<sup>2</sup>.
+            polygon:,
+            # Body param: **tags parameter will be deprecated soon! Please use the
+            # include_any_of_attributes or include_all_of_attributes parameters to match
+            # assets based on their labels or markers.**
+            #
+            # Use this parameter to filter the assets found inside the specified area by their
+            # tag. Multiple tag can be separated using comma (,).
+            #
+            # Please note the tags are case sensitive.
+            filter: nil,
+            # Body param: An object to define the attributes which will be used to filter the
+            # assets found within the polygon.
+            match_filter: nil,
+            # Body param: if ture, can get 16x bigger limitation in search.
+            max_search_limit: nil,
+            # Body param: Denotes page number. Use this along with the ps parameter to
+            # implement pagination for your searched results. This parameter does not have a
+            # maximum limit but would return an empty response in case a higher value is
+            # provided when the result-set itself is smaller.
+            pn: nil,
+            # Body param: Denotes number of search results per page. Use this along with the
+            # pn parameter to implement pagination for your searched results. Please note that
+            # ps has a default value of 20 and accepts integers only in the range of [1, 100].
+            ps: nil,
+            # Body param:
+            sort: nil,
+            request_options: {}
+          )
+          end
+
+          # Polygon Search
+          sig do
+            params(
+              key: String,
+              polygon: String,
+              filter: String,
+              include_all_of_attributes: String,
+              include_any_of_attributes: String,
+              max_search_limit: T::Boolean,
+              pn: Integer,
+              ps: Integer,
+              sort_by:
+                Nextbillionai::Skynet::Search::PolygonGetParams::SortBy::OrSymbol,
+              sort_destination: String,
+              sort_driving_mode:
+                Nextbillionai::Skynet::Search::PolygonGetParams::SortDrivingMode::OrSymbol,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(Nextbillionai::Skynet::SearchResponse)
+          end
+          def get(
+            # A key is a unique identifier that is required to authenticate a request to the
+            # API.
+            key:,
+            # Define a custom polygon enclosing the area to be searched. It should be a pipe
+            # (|) delimited list of location coordinates.
+            #
+            # Please ensure that the polygon provided is enclosed. This can be achieved by
+            # making the last location coordinate in the list equal to the first location
+            # coordinate of the list.
+            #
+            # Please note that the maximum area of the search polygon allowed is 3000
+            # km<sup>2</sup>.
+            polygon:,
+            # **tags parameter will be deprecated soon! Please use the
+            # include_any_of_attributes or include_all_of_attributes parameters to match
+            # assets based on their labels or markers.**
+            #
+            # Use this parameter to filter the assets found inside the specified area by their
+            # tags. Multiple tags can be separated using commas (,).
+            #
+            # Please note the tags are case sensitive.
+            filter: nil,
+            # Use this parameter to filter the assets found inside the specified area by their
+            # attributes. Only the assets having all the attributes that are added to this
+            # parameter, will be returned in the search results. Multiple attributes can be
+            # separated using pipes (|).
+            #
+            # Please note the attributes are case sensitive. Also, this parameter can not be
+            # used in conjunction with include_any_of_attributes parameter.
+            include_all_of_attributes: nil,
+            # Use this parameter to filter the assets found inside the specified area by their
+            # attributes. Assets having at least one of the attributes added to this
+            # parameter, will be returned in the search results. Multiple attributes can be
+            # separated using pipes (|).
+            #
+            # Please note the attributes are case sensitive. Also, this parameter can not be
+            # used in conjunction with include_all_of_attributes parameter.
+            include_any_of_attributes: nil,
+            # When true, the maximum limit is 20Km for around search API and 48000 Km2 for
+            # other search methods.
+            max_search_limit: nil,
+            # Denotes page number. Use this along with the ps parameter to implement
+            # pagination for your searched results. This parameter does not have a maximum
+            # limit but would return an empty response in case a higher value is provided when
+            # the result-set itself is smaller.
+            pn: nil,
+            # Denotes number of search results per page. Use this along with the pn parameter
+            # to implement pagination for your searched results.
+            ps: nil,
+            # Specify the metric to sort the assets returned in the search result. The valid
+            # values are:
+            #
+            # - **distance** : Sorts the assets by driving distance to the given
+            #   sort_destination .
+            # - **duration** : Sorts the assets by travel time to the given sort_destination .
+            # - **straight_distance** : Sort the assets by straight-line distance to the given
+            #   sort-destination .
+            sort_by: nil,
+            # Specifies the location coordinates of the point which acts as destination for
+            # sorting the assets in the search results. The service will sort each asset based
+            # on the driving distance or travel time to this destination, from its current
+            # location. Use the sort_by parameter to configure the metric that should be used
+            # for sorting the assets. Please note that sort_destination is required when
+            # sort_by is provided.
+            sort_destination: nil,
+            # Specifies the driving mode to be used for determining travel duration or driving
+            # distance for sorting the assets in search result.
+            sort_driving_mode: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig do
+            params(client: Nextbillionai::Client).returns(T.attached_class)
+          end
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end