nextbillionai 0.1.0.pre.alpha.4

data/rbi/nextbillionai/models/multigeocode/place_update_params.rbi

@@ -0,0 +1,245 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    module Multigeocode
+      class PlaceUpdateParams < Nextbillionai::Internal::Type::BaseModel
+        extend Nextbillionai::Internal::Type::RequestParameters::Converter
+        include Nextbillionai::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::Multigeocode::PlaceUpdateParams,
+              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
+
+        # dataSource values can be updated to enhance or prioritize the search results to
+        # better suit specific business use cases.
+        sig do
+          returns(
+            T.nilable(
+              Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource
+            )
+          )
+        end
+        attr_reader :data_source
+
+        sig do
+          params(
+            data_source:
+              Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::OrHash
+          ).void
+        end
+        attr_writer :data_source
+
+        # This parameter represents the place details, including geographical information,
+        # address and other related information.
+        sig do
+          returns(T.nilable(T::Array[Nextbillionai::Multigeocode::PlaceItem]))
+        end
+        attr_reader :place
+
+        sig do
+          params(
+            place: T::Array[Nextbillionai::Multigeocode::PlaceItem::OrHash]
+          ).void
+        end
+        attr_writer :place
+
+        # Search score of the place. This is calculated based on how ‘richly’ the place is
+        # defined. For instance, a place with street name, city, state and country
+        # attributes set might be ranked lower than a place which has values of house,
+        # building, street name, city, state and country attributes set. The score
+        # determines the rank of the place among search results. You can also use this
+        # field to set a custom score as per its relevance to rank it among the search
+        # results from multiple data sources.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :score
+
+        sig { params(score: Integer).void }
+        attr_writer :score
+
+        sig do
+          params(
+            key: String,
+            data_source:
+              Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::OrHash,
+            place: T::Array[Nextbillionai::Multigeocode::PlaceItem::OrHash],
+            score: Integer,
+            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:,
+          # dataSource values can be updated to enhance or prioritize the search results to
+          # better suit specific business use cases.
+          data_source: nil,
+          # This parameter represents the place details, including geographical information,
+          # address and other related information.
+          place: nil,
+          # Search score of the place. This is calculated based on how ‘richly’ the place is
+          # defined. For instance, a place with street name, city, state and country
+          # attributes set might be ranked lower than a place which has values of house,
+          # building, street name, city, state and country attributes set. The score
+          # determines the rank of the place among search results. You can also use this
+          # field to set a custom score as per its relevance to rank it among the search
+          # results from multiple data sources.
+          score: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              key: String,
+              data_source:
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource,
+              place: T::Array[Nextbillionai::Multigeocode::PlaceItem],
+              score: Integer,
+              request_options: Nextbillionai::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class DataSource < Nextbillionai::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource,
+                Nextbillionai::Internal::AnyHash
+              )
+            end
+
+          # This parameter represents the unique reference ID associated with the data
+          # source.
+          sig { returns(T.nilable(String)) }
+          attr_reader :ref_id
+
+          sig { params(ref_id: String).void }
+          attr_writer :ref_id
+
+          # 1. Move the place to a new dataset by setting the value to a unique dataset
+          #    name. You can also move the place to an existing dataset by using an existing
+          #    dataset name other than the current one. In both cases, the current
+          #    datasource will be replaced for the specified docID.
+          #
+          # 2. Update the place in an existing dataset by setting the name to the current
+          #    value.
+          sig { returns(T.nilable(String)) }
+          attr_reader :source
+
+          sig { params(source: String).void }
+          attr_writer :source
+
+          # Set this to either enable or disable to allow the place to be retrieved by a
+          # search API or block it respectively.
+          sig do
+            returns(
+              T.nilable(
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::OrSymbol
+              )
+            )
+          end
+          attr_reader :status
+
+          sig do
+            params(
+              status:
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::OrSymbol
+            ).void
+          end
+          attr_writer :status
+
+          # dataSource values can be updated to enhance or prioritize the search results to
+          # better suit specific business use cases.
+          sig do
+            params(
+              ref_id: String,
+              source: String,
+              status:
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # This parameter represents the unique reference ID associated with the data
+            # source.
+            ref_id: nil,
+            # 1. Move the place to a new dataset by setting the value to a unique dataset
+            #    name. You can also move the place to an existing dataset by using an existing
+            #    dataset name other than the current one. In both cases, the current
+            #    datasource will be replaced for the specified docID.
+            #
+            # 2. Update the place in an existing dataset by setting the name to the current
+            #    value.
+            source: nil,
+            # Set this to either enable or disable to allow the place to be retrieved by a
+            # search API or block it respectively.
+            status: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                ref_id: String,
+                source: String,
+                status:
+                  Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::OrSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Set this to either enable or disable to allow the place to be retrieved by a
+          # search API or block it respectively.
+          module Status
+            extend Nextbillionai::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            ENABLE =
+              T.let(
+                :enable,
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::TaggedSymbol
+              )
+            DISABLE =
+              T.let(
+                :disable,
+                Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Nextbillionai::Multigeocode::PlaceUpdateParams::DataSource::Status::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/multigeocode/place_update_response.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    module Multigeocode
+      class PlaceUpdateResponse < Nextbillionai::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::Models::Multigeocode::PlaceUpdateResponse,
+              Nextbillionai::Internal::AnyHash
+            )
+          end
+
+        # This could be “Ok” representing success or “not found” representing error in
+        # processing the request.
+        sig { returns(T.nilable(String)) }
+        attr_reader :msg
+
+        sig { params(msg: String).void }
+        attr_writer :msg
+
+        # Represents the status of the response.
+        sig { returns(T.nilable(String)) }
+        attr_reader :status
+
+        sig { params(status: String).void }
+        attr_writer :status
+
+        sig { params(msg: String, status: String).returns(T.attached_class) }
+        def self.new(
+          # This could be “Ok” representing success or “not found” representing error in
+          # processing the request.
+          msg: nil,
+          # Represents the status of the response.
+          status: nil
+        )
+        end
+
+        sig { override.returns({ msg: String, status: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/nextbillionai/models/multigeocode_search_params.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module Nextbillionai
+  module Models
+    class MultigeocodeSearchParams < Nextbillionai::Internal::Type::BaseModel
+      extend Nextbillionai::Internal::Type::RequestParameters::Converter
+      include Nextbillionai::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Nextbillionai::MultigeocodeSearchParams,
+            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
+
+      # Specify the center of the search context expressed as coordinates.
+      sig { returns(Nextbillionai::MultigeocodeSearchParams::At) }
+      attr_reader :at
+
+      sig do
+        params(at: Nextbillionai::MultigeocodeSearchParams::At::OrHash).void
+      end
+      attr_writer :at
+
+      # A free-form, complete or incomplete string to be searched. It allows searching
+      # for places using keywords or names.
+      sig { returns(String) }
+      attr_accessor :query
+
+      # Specifies the primary city of the place.
+      sig { returns(T.nilable(String)) }
+      attr_reader :city
+
+      sig { params(city: String).void }
+      attr_writer :city
+
+      # Country of the search context provided as comma-separated
+      # [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) country
+      # codes.
+      # Note: Country codes should be provided in uppercase.
+      sig { returns(T.nilable(String)) }
+      attr_reader :country
+
+      sig { params(country: String).void }
+      attr_writer :country
+
+      # Specifies the district of the search place.
+      sig { returns(T.nilable(String)) }
+      attr_reader :district
+
+      sig { params(district: String).void }
+      attr_writer :district
+
+      # Sets the maximum number of results to be returned.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Filters the results to places within the specified radius from the 'at'
+      # location.
+      #
+      # Note: Supports 'meter' (m) and 'kilometer' (km) units. If no radius is given,
+      # the search method returns as many results as specified in limit.
+      sig { returns(T.nilable(String)) }
+      attr_reader :radius
+
+      sig { params(radius: String).void }
+      attr_writer :radius
+
+      # Specifies the state of the search place.
+      sig { returns(T.nilable(String)) }
+      attr_reader :state
+
+      sig { params(state: String).void }
+      attr_writer :state
+
+      # Specifies the street name of the search place.
+      sig { returns(T.nilable(String)) }
+      attr_reader :street
+
+      sig { params(street: String).void }
+      attr_writer :street
+
+      # Specifies the subDistrict of the search place.
+      sig { returns(T.nilable(String)) }
+      attr_reader :sub_district
+
+      sig { params(sub_district: String).void }
+      attr_writer :sub_district
+
+      sig do
+        params(
+          key: String,
+          at: Nextbillionai::MultigeocodeSearchParams::At::OrHash,
+          query: String,
+          city: String,
+          country: String,
+          district: String,
+          limit: Integer,
+          radius: String,
+          state: String,
+          street: String,
+          sub_district: 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:,
+        # Specify the center of the search context expressed as coordinates.
+        at:,
+        # A free-form, complete or incomplete string to be searched. It allows searching
+        # for places using keywords or names.
+        query:,
+        # Specifies the primary city of the place.
+        city: nil,
+        # Country of the search context provided as comma-separated
+        # [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) country
+        # codes.
+        # Note: Country codes should be provided in uppercase.
+        country: nil,
+        # Specifies the district of the search place.
+        district: nil,
+        # Sets the maximum number of results to be returned.
+        limit: nil,
+        # Filters the results to places within the specified radius from the 'at'
+        # location.
+        #
+        # Note: Supports 'meter' (m) and 'kilometer' (km) units. If no radius is given,
+        # the search method returns as many results as specified in limit.
+        radius: nil,
+        # Specifies the state of the search place.
+        state: nil,
+        # Specifies the street name of the search place.
+        street: nil,
+        # Specifies the subDistrict of the search place.
+        sub_district: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            key: String,
+            at: Nextbillionai::MultigeocodeSearchParams::At,
+            query: String,
+            city: String,
+            country: String,
+            district: String,
+            limit: Integer,
+            radius: String,
+            state: String,
+            street: String,
+            sub_district: String,
+            request_options: Nextbillionai::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class At < Nextbillionai::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Nextbillionai::MultigeocodeSearchParams::At,
+              Nextbillionai::Internal::AnyHash
+            )
+          end
+
+        # Latitude coordinate of the location
+        sig { returns(Float) }
+        attr_accessor :lat
+
+        # Longitude coordinate of the location.
+        sig { returns(Float) }
+        attr_accessor :lng
+
+        # Specify the center of the search context expressed as coordinates.
+        sig { params(lat: Float, lng: Float).returns(T.attached_class) }
+        def self.new(
+          # Latitude coordinate of the location
+          lat:,
+          # Longitude coordinate of the location.
+          lng:
+        )
+        end
+
+        sig { override.returns({ lat: Float, lng: Float }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end