nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/models/fleetify/route_create_response.rbi

@@ -0,0 +1,360 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    module Fleetify
+      class RouteCreateResponse < Nextbillionai::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::Models::Fleetify::RouteCreateResponse,
+              Nextbillionai::Internal::AnyHash
+            )
+          end
+
+        # An array of objects containing the details of each step in the dispatched route.
+        # Each object represents a single step.
+        sig do
+          returns(
+            T.nilable(
+              Nextbillionai::Models::Fleetify::RouteCreateResponse::Data
+            )
+          )
+        end
+        attr_reader :data
+
+        sig do
+          params(
+            data:
+              Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        # Returns the status code of the response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :status
+
+        sig { params(status: Integer).void }
+        attr_writer :status
+
+        sig do
+          params(
+            data:
+              Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::OrHash,
+            status: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # An array of objects containing the details of each step in the dispatched route.
+          # Each object represents a single step.
+          data: nil,
+          # Returns the status code of the response.
+          status: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              data: Nextbillionai::Models::Fleetify::RouteCreateResponse::Data,
+              status: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Nextbillionai::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Nextbillionai::Models::Fleetify::RouteCreateResponse::Data,
+                Nextbillionai::Internal::AnyHash
+              )
+            end
+
+          # Returns the unique ID of the dispatched route.
+          sig { returns(T.nilable(String)) }
+          attr_reader :id
+
+          sig { params(id: String).void }
+          attr_writer :id
+
+          # Returns the UNIX timestamp, in seconds precision, at which this route dispatch
+          # request was created.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :created_at
+
+          sig { params(created_at: Integer).void }
+          attr_writer :created_at
+
+          # Returns the total route distance, in meters, for informative display in the
+          # driver app. It is the same as the value provided for distance field in the input
+          # request.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :distance
+
+          sig { params(distance: Integer).void }
+          attr_writer :distance
+
+          # Returns the details of the document that was specified in the input for
+          # collecting the proof-of-completion for all steps in the dispatched routes. Each
+          # object represents a new field in the document.
+          sig { returns(T.nilable(T::Array[T.anything])) }
+          attr_reader :document_snapshot
+
+          sig { params(document_snapshot: T::Array[T.anything]).void }
+          attr_writer :document_snapshot
+
+          # An object returning the details of the driver to whom the route was dispatched.
+          sig do
+            returns(
+              T.nilable(
+                Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::Driver
+              )
+            )
+          end
+          attr_reader :driver
+
+          sig do
+            params(
+              driver:
+                Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::Driver::OrHash
+            ).void
+          end
+          attr_writer :driver
+
+          # Returns the route optimization request ID which was used to dispatch the route.
+          # An empty string is returned if the corresponding input was not provided.
+          sig { returns(T.nilable(String)) }
+          attr_reader :ro_request_id
+
+          sig { params(ro_request_id: String).void }
+          attr_writer :ro_request_id
+
+          # An object returning the routing characteristics that are used to generate the
+          # route and turn-by-turn navigation steps for the dispatched route. The route and
+          # navigation steps are available when driver uses the in-app navigation.
+          #
+          # Please note the routing characteristics returned here are the same as those
+          # configured in the input request. The fields which were not specified in the
+          # input will be returned as blanks.
+          sig { returns(T.nilable(Nextbillionai::Fleetify::RoutingResponse)) }
+          attr_reader :routing
+
+          sig do
+            params(
+              routing: Nextbillionai::Fleetify::RoutingResponse::OrHash
+            ).void
+          end
+          attr_writer :routing
+
+          # Returns a shorter unique ID of the dispatched route for easier referencing and
+          # displaying purposes.
+          sig { returns(T.nilable(String)) }
+          attr_reader :short_id
+
+          sig { params(short_id: String).void }
+          attr_writer :short_id
+
+          # An array of objects containing the details of all steps to be performed as part
+          # of the dispatched route. Each object represents a single step during the route.
+          sig do
+            returns(
+              T.nilable(
+                T::Array[Nextbillionai::Fleetify::Routes::RouteStepsResponse]
+              )
+            )
+          end
+          attr_reader :steps
+
+          sig do
+            params(
+              steps:
+                T::Array[
+                  Nextbillionai::Fleetify::Routes::RouteStepsResponse::OrHash
+                ]
+            ).void
+          end
+          attr_writer :steps
+
+          # Returns the total number of steps in the dispatched route.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :total_steps
+
+          sig { params(total_steps: Integer).void }
+          attr_writer :total_steps
+
+          # Returns the UNIX timestamp, in seconds precision, at which this route dispatch
+          # request was updated.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :updated_at
+
+          sig { params(updated_at: Integer).void }
+          attr_writer :updated_at
+
+          # Returns the ID of the vehicle to which the route was dispatched. The vehicle ID
+          # returned here is the same as the one used in the route optimization request for
+          # the given vehicle. An empty string is returned if the ro_request_id was not
+          # provided in the input.
+          sig { returns(T.nilable(String)) }
+          attr_reader :vehicle_id
+
+          sig { params(vehicle_id: String).void }
+          attr_writer :vehicle_id
+
+          # An array of objects containing the details of each step in the dispatched route.
+          # Each object represents a single step.
+          sig do
+            params(
+              id: String,
+              created_at: Integer,
+              distance: Integer,
+              document_snapshot: T::Array[T.anything],
+              driver:
+                Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::Driver::OrHash,
+              ro_request_id: String,
+              routing: Nextbillionai::Fleetify::RoutingResponse::OrHash,
+              short_id: String,
+              steps:
+                T::Array[
+                  Nextbillionai::Fleetify::Routes::RouteStepsResponse::OrHash
+                ],
+              total_steps: Integer,
+              updated_at: Integer,
+              vehicle_id: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Returns the unique ID of the dispatched route.
+            id: nil,
+            # Returns the UNIX timestamp, in seconds precision, at which this route dispatch
+            # request was created.
+            created_at: nil,
+            # Returns the total route distance, in meters, for informative display in the
+            # driver app. It is the same as the value provided for distance field in the input
+            # request.
+            distance: nil,
+            # Returns the details of the document that was specified in the input for
+            # collecting the proof-of-completion for all steps in the dispatched routes. Each
+            # object represents a new field in the document.
+            document_snapshot: nil,
+            # An object returning the details of the driver to whom the route was dispatched.
+            driver: nil,
+            # Returns the route optimization request ID which was used to dispatch the route.
+            # An empty string is returned if the corresponding input was not provided.
+            ro_request_id: nil,
+            # An object returning the routing characteristics that are used to generate the
+            # route and turn-by-turn navigation steps for the dispatched route. The route and
+            # navigation steps are available when driver uses the in-app navigation.
+            #
+            # Please note the routing characteristics returned here are the same as those
+            # configured in the input request. The fields which were not specified in the
+            # input will be returned as blanks.
+            routing: nil,
+            # Returns a shorter unique ID of the dispatched route for easier referencing and
+            # displaying purposes.
+            short_id: nil,
+            # An array of objects containing the details of all steps to be performed as part
+            # of the dispatched route. Each object represents a single step during the route.
+            steps: nil,
+            # Returns the total number of steps in the dispatched route.
+            total_steps: nil,
+            # Returns the UNIX timestamp, in seconds precision, at which this route dispatch
+            # request was updated.
+            updated_at: nil,
+            # Returns the ID of the vehicle to which the route was dispatched. The vehicle ID
+            # returned here is the same as the one used in the route optimization request for
+            # the given vehicle. An empty string is returned if the ro_request_id was not
+            # provided in the input.
+            vehicle_id: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                created_at: Integer,
+                distance: Integer,
+                document_snapshot: T::Array[T.anything],
+                driver:
+                  Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::Driver,
+                ro_request_id: String,
+                routing: Nextbillionai::Fleetify::RoutingResponse,
+                short_id: String,
+                steps:
+                  T::Array[Nextbillionai::Fleetify::Routes::RouteStepsResponse],
+                total_steps: Integer,
+                updated_at: Integer,
+                vehicle_id: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Driver < Nextbillionai::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Nextbillionai::Models::Fleetify::RouteCreateResponse::Data::Driver,
+                  Nextbillionai::Internal::AnyHash
+                )
+              end
+
+            # Returns the ID of the driver as specified in the
+            # [NextBillion.ai](http://NextBillion.ai) Cloud Console.
+            sig { returns(T.nilable(String)) }
+            attr_reader :id
+
+            sig { params(id: String).void }
+            attr_writer :id
+
+            # Returns the email of the driver as specified in the
+            # [NextBillion.ai](http://NextBillion.ai) Cloud Console.
+            sig { returns(T.nilable(String)) }
+            attr_reader :email
+
+            sig { params(email: String).void }
+            attr_writer :email
+
+            # Returns the full name of the driver as specified in
+            # [NextBillion.ai](http://NextBillion.ai) Cloud Console.
+            sig { returns(T.nilable(String)) }
+            attr_reader :fullname
+
+            sig { params(fullname: String).void }
+            attr_writer :fullname
+
+            # An object returning the details of the driver to whom the route was dispatched.
+            sig do
+              params(id: String, email: String, fullname: String).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # Returns the ID of the driver as specified in the
+              # [NextBillion.ai](http://NextBillion.ai) Cloud Console.
+              id: nil,
+              # Returns the email of the driver as specified in the
+              # [NextBillion.ai](http://NextBillion.ai) Cloud Console.
+              email: nil,
+              # Returns the full name of the driver as specified in
+              # [NextBillion.ai](http://NextBillion.ai) Cloud Console.
+              fullname: nil
+            )
+            end
+
+            sig do
+              override.returns({ id: String, email: String, fullname: String })
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/fleetify/route_redispatch_params.rbi

@@ -0,0 +1,307 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    module Fleetify
+      class RouteRedispatchParams < Nextbillionai::Internal::Type::BaseModel
+        extend Nextbillionai::Internal::Type::RequestParameters::Converter
+        include Nextbillionai::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::Fleetify::RouteRedispatchParams,
+              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
+
+        # A collection of objects with details of the steps to be modified. Each object
+        # corresponds to a single step.
+        sig do
+          returns(
+            T::Array[Nextbillionai::Fleetify::RouteRedispatchParams::Operation]
+          )
+        end
+        attr_accessor :operations
+
+        # Specify the distance of the route.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :distance
+
+        sig { params(distance: Float).void }
+        attr_writer :distance
+
+        sig do
+          params(
+            key: String,
+            operations:
+              T::Array[
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::OrHash
+              ],
+            distance: Float,
+            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:,
+          # A collection of objects with details of the steps to be modified. Each object
+          # corresponds to a single step.
+          operations:,
+          # Specify the distance of the route.
+          distance: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              key: String,
+              operations:
+                T::Array[
+                  Nextbillionai::Fleetify::RouteRedispatchParams::Operation
+                ],
+              distance: Float,
+              request_options: Nextbillionai::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Operation < Nextbillionai::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation,
+                Nextbillionai::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Data
+            )
+          end
+          attr_reader :data
+
+          sig do
+            params(
+              data:
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Data::OrHash
+            ).void
+          end
+          attr_writer :data
+
+          # Specify the type of operation to be performed for the step.
+          sig do
+            returns(
+              Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::OrSymbol
+            )
+          end
+          attr_accessor :operation
+
+          sig do
+            params(
+              data:
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Data::OrHash,
+              operation:
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            data:,
+            # Specify the type of operation to be performed for the step.
+            operation:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                data:
+                  Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Data,
+                operation:
+                  Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::OrSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Data < Nextbillionai::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Data,
+                  Nextbillionai::Internal::AnyHash
+                )
+              end
+
+            # Specify the mode of completion to be used for the step. Currently, following
+            # values are allowed:
+            #
+            # - manual: Steps must be marked as completed manually through the Driver App.
+            # - geofence: Steps are marked as completed automatically based on the entry
+            #   conditions and geofence specified.
+            # - geofence_manual_fallback: Steps will be marked as completed automatically
+            #   based on geofence and entry condition configurations but there will also be a
+            #   provision for manually updating the status in case, geofence detection fails.
+            sig do
+              returns(
+                T.nilable(
+                  Nextbillionai::Fleetify::Routes::RouteStepCompletionMode::OrSymbol
+                )
+              )
+            end
+            attr_reader :completion_mode
+
+            sig do
+              params(
+                completion_mode:
+                  Nextbillionai::Fleetify::Routes::RouteStepCompletionMode::OrSymbol
+              ).void
+            end
+            attr_writer :completion_mode
+
+            # Specify the ID of the document template to be used for collecting proof of
+            # completion for the step. It would be applied to step which not be bind to
+            # document template. Use the
+            # [Documents API](https://docs.nextbillion.ai/docs/dispatches/documents-api) to
+            # create, read and manage the document templates.
+            #
+            # Please note that the document template ID can not be assigned to following step
+            # types - start, end, break, layover.
+            sig { returns(T.nilable(String)) }
+            attr_reader :document_template_id
+
+            sig { params(document_template_id: String).void }
+            attr_writer :document_template_id
+
+            sig do
+              returns(
+                T.nilable(Nextbillionai::Fleetify::Routes::RouteStepsRequest)
+              )
+            end
+            attr_reader :step
+
+            sig do
+              params(
+                step: Nextbillionai::Fleetify::Routes::RouteStepsRequest::OrHash
+              ).void
+            end
+            attr_writer :step
+
+            # Specify the ID of the step to be updated or deleted. Either one of id or
+            # short_id of the step can be provided. This input will be ignored when operation:
+            # create .
+            sig { returns(T.nilable(String)) }
+            attr_reader :step_id
+
+            sig { params(step_id: String).void }
+            attr_writer :step_id
+
+            sig do
+              params(
+                completion_mode:
+                  Nextbillionai::Fleetify::Routes::RouteStepCompletionMode::OrSymbol,
+                document_template_id: String,
+                step:
+                  Nextbillionai::Fleetify::Routes::RouteStepsRequest::OrHash,
+                step_id: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Specify the mode of completion to be used for the step. Currently, following
+              # values are allowed:
+              #
+              # - manual: Steps must be marked as completed manually through the Driver App.
+              # - geofence: Steps are marked as completed automatically based on the entry
+              #   conditions and geofence specified.
+              # - geofence_manual_fallback: Steps will be marked as completed automatically
+              #   based on geofence and entry condition configurations but there will also be a
+              #   provision for manually updating the status in case, geofence detection fails.
+              completion_mode: nil,
+              # Specify the ID of the document template to be used for collecting proof of
+              # completion for the step. It would be applied to step which not be bind to
+              # document template. Use the
+              # [Documents API](https://docs.nextbillion.ai/docs/dispatches/documents-api) to
+              # create, read and manage the document templates.
+              #
+              # Please note that the document template ID can not be assigned to following step
+              # types - start, end, break, layover.
+              document_template_id: nil,
+              step: nil,
+              # Specify the ID of the step to be updated or deleted. Either one of id or
+              # short_id of the step can be provided. This input will be ignored when operation:
+              # create .
+              step_id: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  completion_mode:
+                    Nextbillionai::Fleetify::Routes::RouteStepCompletionMode::OrSymbol,
+                  document_template_id: String,
+                  step: Nextbillionai::Fleetify::Routes::RouteStepsRequest,
+                  step_id: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          # Specify the type of operation to be performed for the step.
+          module Operation
+            extend Nextbillionai::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CREATE =
+              T.let(
+                :create,
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::TaggedSymbol
+              )
+            UPDATE =
+              T.let(
+                :update,
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::TaggedSymbol
+              )
+            DELETE =
+              T.let(
+                :delete,
+                Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Nextbillionai::Fleetify::RouteRedispatchParams::Operation::Operation::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end