nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/resources/skynet/asset/event.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Asset
+        class Event
+          # Event History of an Asset
+          sig do
+            params(
+              id: String,
+              key: String,
+              cluster:
+                Nextbillionai::Skynet::Asset::EventListParams::Cluster::OrSymbol,
+              end_time: Integer,
+              monitor_id: String,
+              pn: Integer,
+              ps: Integer,
+              start_time: Integer,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(Nextbillionai::Models::Skynet::Asset::EventListResponse)
+          end
+          def list(
+            # ID of the asset whose event history needs to be fetched. This is the same ID
+            # that was generated/provided at the time of creating the asset.
+            id,
+            # 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,
+            # Time before which the events triggered by the asset need to be retrieved.
+            end_time: nil,
+            # Filter the events by monitor_id. When provided, only the events triggered by the
+            # monitor will be returned in response.
+            #
+            # Please note that if the attributes of the asset identified by id and those of
+            # the monitor do not match, then no events might be returned for this monitor_id.
+            monitor_id: 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,
+            # Time after which the events triggered by the asset need to be retrieved.
+            start_time: 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

data/rbi/nextbillionai/resources/skynet/asset/location.rbi

@@ -0,0 +1,106 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Asset
+        class Location
+          # Track locations of an asset
+          sig do
+            params(
+              id: String,
+              key: String,
+              cluster:
+                Nextbillionai::Skynet::Asset::LocationListParams::Cluster::OrSymbol,
+              correction: String,
+              end_time: Integer,
+              geometry_type:
+                Nextbillionai::Skynet::Asset::LocationListParams::GeometryType::OrSymbol,
+              pn: Integer,
+              ps: Integer,
+              start_time: Integer,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(
+              Nextbillionai::Models::Skynet::Asset::LocationListResponse
+            )
+          end
+          def list(
+            # ID of the asset for which the location track information needs to be retrieved.
+            # This is the same ID that was generated/provided at the time of creating the
+            # asset.
+            id,
+            # 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,
+            # Describe the geometry characteristics through a , separated list of properties.
+            #
+            # Setting mapmatch to 1 returns the geometry of the tracked points, snapped to the
+            # nearest road.
+            #
+            # Setting interpolate to 1 smoothens the snapped geometry by adding more points,
+            # as needed. Please note, mapmatch should be set to 1 for interpolate to be
+            # effective.
+            #
+            # mode is used to set the transport mode for which the snapped route will be
+            # determined. Allowed values for mode are car and truck.
+            correction: nil,
+            # Time until which the tracked locations of the asset need to be retrieved.
+            end_time: nil,
+            # Set the geometry format to encode the path linking the tracked locations of the
+            # asset.
+            #
+            # Please note that geometry_type is effective only when mapmatch property of
+            # correction parameter is set to 1.
+            geometry_type: 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,
+            # Time after which the tracked locations of the asset need to be retrieved.
+            start_time: nil,
+            request_options: {}
+          )
+          end
+
+          # Track the last location of an asset
+          sig do
+            params(
+              id: String,
+              key: String,
+              cluster:
+                Nextbillionai::Skynet::Asset::LocationGetLastParams::Cluster::OrSymbol,
+              request_options: Nextbillionai::RequestOptions::OrHash
+            ).returns(
+              Nextbillionai::Models::Skynet::Asset::LocationGetLastResponse
+            )
+          end
+          def get_last(
+            # ID of the asset whose last location is to be retrieved. This is the same ID that
+            # was generated/provided at the time of creating the asset.
+            id,
+            # 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,
+            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

data/rbi/nextbillionai/resources/skynet/asset.rbi

@@ -0,0 +1,336 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Asset
+        sig { returns(Nextbillionai::Resources::Skynet::Asset::Event) }
+        attr_reader :event
+
+        sig { returns(Nextbillionai::Resources::Skynet::Asset::Location) }
+        attr_reader :location
+
+        # Create an Asset
+        sig do
+          params(
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::AssetCreateParams::Cluster::OrSymbol,
+            attributes: T.anything,
+            custom_id: String,
+            description: String,
+            meta_data: T.anything,
+            name: String,
+            tags: T::Array[String],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::AssetCreateResponse)
+        end
+        def create(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          # Body param: attributes can be used to store custom information about an asset in
+          # key:value format. Use attributes to add any useful information or context to
+          # your assets like the vehicle type, shift timing etc. Moreover, these attributes
+          # can be used to filter assets in **Search**, **Monitor**, and _Get Asset List_
+          # queries.
+          #
+          # Please note that the maximum number of key:value pairs that can be added to an
+          # attributes object is 100. Also, the overall size of attributes object should not
+          # exceed 65kb.
+          attributes: nil,
+          # Body param: Set a unique ID for the new asset. 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 asset can not be changed once it is created.
+          custom_id: nil,
+          # Body param: Description for the asset.
+          description: 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 asset. Use this field to assign a meaningful, custom
+          # name to the asset being created.
+          name: nil,
+          # Body param: **This parameter will be deprecated soon! Please use the attributes
+          # parameter to add labels or markers for the asset.**
+          #
+          # Tags of the asset. tags can be used for filtering assets in operations like _Get
+          # Asset List_ and asset **Search** methods. They can also be used for monitoring
+          # of assets using the **Monitor** methods after linking tags and asset.
+          #
+          # Valid tags are strings consisting of alphanumeric characters (A-Z, a-z, 0-9)
+          # along with the underscore ('\_') and hyphen ('-') symbols.
+          tags: nil,
+          request_options: {}
+        )
+        end
+
+        # Get an Asset
+        sig do
+          params(
+            id: String,
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::AssetRetrieveParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::AssetRetrieveResponse)
+        end
+        def retrieve(
+          # ID of the asset to be fetched. This is the same ID that was generated/provided
+          # at the time of creating the asset.
+          id,
+          # 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,
+          request_options: {}
+        )
+        end
+
+        # Update an Asset
+        sig do
+          params(
+            id: String,
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::AssetUpdateParams::Cluster::OrSymbol,
+            attributes: T.anything,
+            description: String,
+            meta_data: T.anything,
+            name: String,
+            tags: T::Array[String],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def update(
+          # Path param: ID of the asset to be updated. This is the same ID that was
+          # generated/provided at the time of creating the asset.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          # Body param: Use this param to update the attributes of an asset in key:value
+          # format. Users can maintain any useful information or context about the assets by
+          # utilising this parameter.
+          #
+          # Please be careful when using this parameter while updating an asset as the new
+          # attributes object provided will completely overwrite the old attributes object.
+          # Use the _Update Asset Attributes_ method to add new or modify existing
+          # attributes.
+          #
+          # Another point to note is that the overall size of the attributes object cannot
+          # exceed 65kb and the maximum number of key:value pairs that can be added to this
+          # object is 100.
+          attributes: nil,
+          # Body param: Use this param to update the description of an asset.
+          description: 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 param to update the name of an asset. Users can assign
+          # meaningful custom names to their assets.
+          name: nil,
+          # Body param: **This parameter will be deprecated soon! Please use the attributes
+          # parameter to add labels or markers for the asset.**
+          #
+          # Use this param to update the tags of an asset. tags can be used to filter asset
+          # in _Get Asset List_, **Search** and **Monitor** queries.
+          tags: nil,
+          request_options: {}
+        )
+        end
+
+        # Get Asset List
+        sig do
+          params(
+            key: String,
+            cluster: Nextbillionai::Skynet::AssetListParams::Cluster::OrSymbol,
+            include_all_of_attributes: String,
+            include_any_of_attributes: String,
+            pn: Integer,
+            ps: Integer,
+            sort: String,
+            tags: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::AssetListResponse)
+        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,
+          # Use this parameter to filter the assets by their attributes. Only the assets
+          # having all the attributes added to this parameter, will be returned in the
+          # response. 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 by their attributes. Assets having at
+          # least one of the attributes added to this parameter, will be returned in the
+          # response. 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,
+          # 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,
+          # **This parameter will be deprecated soon! Please use the
+          # include_all_of_attributes or include_any_of_attributes parameters to provide
+          # labels or markers for the assets to be retrieved.**
+          #
+          # tags can be used to filter the assets. Only those assets which have all the tags
+          # provided, will be included in the result. In case multiple tags need to be
+          # specified, use , to separate them.
+          tags: nil,
+          request_options: {}
+        )
+        end
+
+        # Delete an Asset
+        sig do
+          params(
+            id: String,
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::AssetDeleteParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def delete(
+          # ID of the asset to be deleted. This is the same ID that was generated/provided
+          # at the time of creating the asset.
+          id,
+          # 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,
+          request_options: {}
+        )
+        end
+
+        # Bind asset to device
+        sig do
+          params(
+            id: String,
+            key: String,
+            device_id: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def bind(
+          # Path param: ID of asset to which a device needs to be linked. This is the same
+          # ID that was generated/provided at the time of creating the asset.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: Device ID to be linked to the asset identified by id.
+          #
+          # Please note that the device needs to be linked to an asset before using it in
+          # the _Upload locations of an Asset_ method for sending GPS information about the
+          # asset.
+          device_id:,
+          request_options: {}
+        )
+        end
+
+        # Upload track info
+        sig do
+          params(
+            id: String,
+            key: String,
+            device_id: String,
+            locations:
+              Nextbillionai::Skynet::AssetTrackParams::Locations::OrHash,
+            cluster: Nextbillionai::Skynet::AssetTrackParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def track(
+          # Path param: ID of the asset whose track information is to be uploaded. This is
+          # the same ID that was generated/provided at the time of creating the asset.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: ID of the device used to upload the tracking information of the
+          # asset.
+          #
+          # Please note that the device_id used here must already be linked to the asset.
+          # Use the _Bind Device to Asset_ method to link a device with your asset.
+          device_id:,
+          # Body param: An array of objects to collect the location tracking information for
+          # an asset. Each object must correspond to details of only one location.
+          locations:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          request_options: {}
+        )
+        end
+
+        # Update asset attributes. (add)
+        sig do
+          params(
+            id: String,
+            key: String,
+            attributes: T.anything,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def update_attributes(
+          # Path param: ID of the asset whose attributes need to be updated. This is the
+          # same ID that was generated/provided at the time of creating the asset.
+          id,
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Body param: attributes can be used to add any useful information or context to
+          # your assets like the vehicle type, shift timing etc. These attributes can also
+          # be used to filter assets in **Search**, **Monitor**, and _Get Asset List_
+          # queries.
+          #
+          # Provide the attributes to be added or updated, in key:value format. If an
+          # existing key is provided in the input, then the value will be modified as per
+          # the input value. If a new key is provided in the input, then the key would be
+          # added to the existing set. The contents of any value field are neither altered
+          # nor removed unless specifically referred to by its key in the input request.
+          #
+          # Please note that the maximum number of key:value pairs that can be added to an
+          # attributes object is 100. Also, the overall size of attributes object should not
+          # exceed 65kb.
+          attributes:,
+          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/config.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Nextbillionai
+  module Resources
+    class Skynet
+      class Config
+        # Get webhook configuration
+        sig do
+          params(
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::ConfigRetrieveParams::Cluster::OrSymbol,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::ConfigRetrieveResponse)
+        end
+        def retrieve(
+          # 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,
+          request_options: {}
+        )
+        end
+
+        # Update webhook configuration
+        sig do
+          params(
+            key: String,
+            cluster:
+              Nextbillionai::Skynet::ConfigUpdateParams::Cluster::OrSymbol,
+            webhook: T::Array[String],
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Skynet::SimpleResp)
+        end
+        def update(
+          # Query param: A key is a unique identifier that is required to authenticate a
+          # request to the API.
+          key:,
+          # Query param: the cluster of the region you want to use
+          cluster: nil,
+          # Body param: Use this array to update information about the webhooks. Please note
+          # that the webhooks will be overwritten every time this method is used.
+          webhook: nil,
+          request_options: {}
+        )
+        end
+
+        # Test webhook configurations
+        sig do
+          params(
+            key: String,
+            request_options: Nextbillionai::RequestOptions::OrHash
+          ).returns(Nextbillionai::Models::Skynet::ConfigTestWebhookResponse)
+        end
+        def test_webhook(
+          # 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