nextbillionai 0.1.0.pre.alpha.4

data/lib/nextbillionai/resources/fleetify/document_templates.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      class DocumentTemplates
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::DocumentTemplateCreateParams} for more
+        # details.
+        #
+        # Create Document template
+        #
+        # @overload create(key:, content:, name:, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param content [Array<Nextbillionai::Models::Fleetify::DocumentTemplateContentRequest>] Body param: A form field that drivers must complete when executing a route step.
+        #
+        # @param name [String] Body param: Specify a name for the document template to be created.
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::DocumentTemplateCreateResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::DocumentTemplateCreateParams
+        def create(params)
+          parsed, options = Nextbillionai::Fleetify::DocumentTemplateCreateParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: "fleetify/document_templates",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Fleetify::DocumentTemplateCreateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::DocumentTemplateRetrieveParams} for more
+        # details.
+        #
+        # Retrieve template by ID
+        #
+        # @overload retrieve(id, key:, request_options: {})
+        #
+        # @param id [String] Specify the unique identifier of the document template.
+        #
+        # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::DocumentTemplateRetrieveResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::DocumentTemplateRetrieveParams
+        def retrieve(id, params)
+          parsed, options = Nextbillionai::Fleetify::DocumentTemplateRetrieveParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: ["fleetify/document_templates/%1$s", id],
+            query: parsed,
+            model: Nextbillionai::Models::Fleetify::DocumentTemplateRetrieveResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::DocumentTemplateUpdateParams} for more
+        # details.
+        #
+        # Update a document template
+        #
+        # @overload update(id, key:, content: nil, name: nil, request_options: {})
+        #
+        # @param id [String] Path param: Specify the unique identifier of the document template.
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param content [Array<Nextbillionai::Models::Fleetify::DocumentTemplateContentRequest>] Body param: An object to collect the details of form fields to be updated - data
+        #
+        # @param name [String] Body param: Specify the document template name to be updated.
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::DocumentTemplateUpdateResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::DocumentTemplateUpdateParams
+        def update(id, params)
+          parsed, options = Nextbillionai::Fleetify::DocumentTemplateUpdateParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :put,
+            path: ["fleetify/document_templates/%1$s", id],
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Fleetify::DocumentTemplateUpdateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::DocumentTemplateListParams} for more details.
+        #
+        # Get all document templates
+        #
+        # @overload list(key:, request_options: {})
+        #
+        # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::DocumentTemplateListResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::DocumentTemplateListParams
+        def list(params)
+          parsed, options = Nextbillionai::Fleetify::DocumentTemplateListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "fleetify/document_templates",
+            query: parsed,
+            model: Nextbillionai::Models::Fleetify::DocumentTemplateListResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::DocumentTemplateDeleteParams} for more
+        # details.
+        #
+        # Delete a document template
+        #
+        # @overload delete(id, key:, request_options: {})
+        #
+        # @param id [String] Specify the unique identifier of the document template.
+        #
+        # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::DocumentTemplateDeleteResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::DocumentTemplateDeleteParams
+        def delete(id, params)
+          parsed, options = Nextbillionai::Fleetify::DocumentTemplateDeleteParams.dump_request(params)
+          @client.request(
+            method: :delete,
+            path: ["fleetify/document_templates/%1$s", id],
+            query: parsed,
+            model: Nextbillionai::Models::Fleetify::DocumentTemplateDeleteResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/fleetify/routes/steps.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      class Routes
+        class Steps
+          # Some parameter documentations has been truncated, see
+          # {Nextbillionai::Models::Fleetify::Routes::StepCreateParams} for more details.
+          #
+          # Insert a new step
+          #
+          # @overload create(route_id, key:, arrival:, location:, position:, type:, address: nil, completion_mode: nil, document_template_id: nil, duration: nil, geofence_config: nil, meta: nil, request_options: {})
+          #
+          # @param route_id [String] Path param: Provide the ID of a previously dispatched route which needs to be mo
+          #
+          # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+          #
+          # @param arrival [Integer] Body param: Specify the scheduled arrival time of the driver, as an UNIX timesta
+          #
+          # @param location [Array<Float>] Body param: Specify the location coordinates where the steps should be performed
+          #
+          # @param position [Integer] Body param: Indicates the index at which to insert the step, starting from 0 up
+          #
+          # @param type [Symbol, Nextbillionai::Models::Fleetify::Routes::StepCreateParams::Type] Body param: Specify the step type. It can belong to one of the following: start,
+          #
+          # @param address [String] Body param: Specify the postal address for the step.
+          #
+          # @param completion_mode [Symbol, Nextbillionai::Models::Fleetify::Routes::RouteStepCompletionMode] Body param: Specify the mode of completion to be used for the step. Currently, f
+          #
+          # @param document_template_id [String] Body param: Specify the ID of the document template to be used for collecting pr
+          #
+          # @param duration [Integer] Body param: Specify the duration of the layover or break type steps, in seconds.
+          #
+          # @param geofence_config [Nextbillionai::Models::Fleetify::Routes::RouteStepGeofenceConfig] Body param: Specify the configurations of the geofence which will be used to det
+          #
+          # @param meta [Nextbillionai::Models::Fleetify::Routes::StepCreateParams::Meta] Body param: An object to specify any additional details about the task to be ass
+          #
+          # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Nextbillionai::Models::Fleetify::Routes::StepCreateResponse]
+          #
+          # @see Nextbillionai::Models::Fleetify::Routes::StepCreateParams
+          def create(route_id, params)
+            parsed, options = Nextbillionai::Fleetify::Routes::StepCreateParams.dump_request(params)
+            query_params = [:key]
+            @client.request(
+              method: :post,
+              path: ["fleetify/routes/%1$s/steps", route_id],
+              query: parsed.slice(*query_params),
+              body: parsed.except(*query_params),
+              model: Nextbillionai::Models::Fleetify::Routes::StepCreateResponse,
+              options: options
+            )
+          end
+
+          # Some parameter documentations has been truncated, see
+          # {Nextbillionai::Models::Fleetify::Routes::StepUpdateParams} for more details.
+          #
+          # Update a step
+          #
+          # @overload update(step_id, route_id:, key:, arrival:, position:, address: nil, completion_mode: nil, document_template_id: nil, duration: nil, geofence_config: nil, location: nil, meta: nil, type: nil, request_options: {})
+          #
+          # @param step_id [String] Path param: Provide the step ID from a previously dispatched route that you want
+          #
+          # @param route_id [String] Path param: Provide the ID of a previously dispatched route which needs to be mo
+          #
+          # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+          #
+          # @param arrival [Integer] Body param: Specify the scheduled arrival time of the driver, as an UNIX timesta
+          #
+          # @param position [Integer] Body param: Specify the new position of the step. Provide a position different f
+          #
+          # @param address [String] Body param: Specify the postal address for the step.
+          #
+          # @param completion_mode [Symbol, Nextbillionai::Models::Fleetify::Routes::RouteStepCompletionMode] Body param: Specify the mode of completion to be used for the step. Currently, f
+          #
+          # @param document_template_id [String] Body param: Update the ID of the document template to be used for collecting pro
+          #
+          # @param duration [Integer] Body param: Specify the duration of the layover or break type steps, in seconds.
+          #
+          # @param geofence_config [Nextbillionai::Models::Fleetify::Routes::RouteStepGeofenceConfig] Body param: Specify the configurations of the geofence which will be used to det
+          #
+          # @param location [Array<Float>] Body param: Specify the location coordinates where the steps should be performed
+          #
+          # @param meta [Nextbillionai::Models::Fleetify::Routes::StepUpdateParams::Meta] Body param: An object to specify any additional details about the task to be ass
+          #
+          # @param type [Symbol, Nextbillionai::Models::Fleetify::Routes::StepUpdateParams::Type] Body param: Specify the step type. It can belong to one of the following: start,
+          #
+          # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Nextbillionai::Models::Fleetify::Routes::StepUpdateResponse]
+          #
+          # @see Nextbillionai::Models::Fleetify::Routes::StepUpdateParams
+          def update(step_id, params)
+            parsed, options = Nextbillionai::Fleetify::Routes::StepUpdateParams.dump_request(params)
+            route_id =
+              parsed.delete(:route_id) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            query_params = [:key]
+            @client.request(
+              method: :put,
+              path: ["fleetify/routes/%1$s/steps/%2$s", route_id, step_id],
+              query: parsed.slice(*query_params),
+              body: parsed.except(*query_params),
+              model: Nextbillionai::Models::Fleetify::Routes::StepUpdateResponse,
+              options: options
+            )
+          end
+
+          # Some parameter documentations has been truncated, see
+          # {Nextbillionai::Models::Fleetify::Routes::StepDeleteParams} for more details.
+          #
+          # Delete a step
+          #
+          # @overload delete(step_id, route_id:, key:, request_options: {})
+          #
+          # @param step_id [String] Path param: Provide the step ID from a previously dispatched route that you want
+          #
+          # @param route_id [String] Path param: Provide the ID of a previously dispatched route which needs to be mo
+          #
+          # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+          #
+          # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Nextbillionai::Models::Fleetify::Routes::StepDeleteResponse]
+          #
+          # @see Nextbillionai::Models::Fleetify::Routes::StepDeleteParams
+          def delete(step_id, params)
+            parsed, options = Nextbillionai::Fleetify::Routes::StepDeleteParams.dump_request(params)
+            route_id =
+              parsed.delete(:route_id) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            @client.request(
+              method: :delete,
+              path: ["fleetify/routes/%1$s/steps/%2$s", route_id, step_id],
+              query: parsed,
+              model: Nextbillionai::Models::Fleetify::Routes::StepDeleteResponse,
+              options: options
+            )
+          end
+
+          # Some parameter documentations has been truncated, see
+          # {Nextbillionai::Models::Fleetify::Routes::StepCompleteParams} for more details.
+          #
+          # Complete a route step with document submission, or update the document of a
+          # completed route step.
+          #
+          # When all steps are completed, the encapsulating route’s status will change to
+          # completed automatically.
+          #
+          # Either Session Token must be provided to authenticate the request.
+          #
+          # @overload complete(step_id, route_id:, key:, document: nil, mode: nil, status: nil, request_options: {})
+          #
+          # @param step_id [String] Path param: Provide the step ID from a previously dispatched route that you want
+          #
+          # @param route_id [String] Path param: Provide the ID of a previously dispatched route which needs to be mo
+          #
+          # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+          #
+          # @param document [Object] Body param: A key-value map storing form submission data, where keys correspond
+          #
+          # @param mode [String] Body param: Sets the status of the route step. Currently only completed is suppo
+          #
+          # @param status [String] Body param: Sets the status of the route step. Currently only completed is suppo
+          #
+          # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [nil]
+          #
+          # @see Nextbillionai::Models::Fleetify::Routes::StepCompleteParams
+          def complete(step_id, params)
+            parsed, options = Nextbillionai::Fleetify::Routes::StepCompleteParams.dump_request(params)
+            route_id =
+              parsed.delete(:route_id) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            query_params = [:key]
+            @client.request(
+              method: :patch,
+              path: ["fleetify/routes/%1$s/steps/%2$s", route_id, step_id],
+              query: parsed.slice(*query_params),
+              body: parsed.except(*query_params),
+              model: NilClass,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Nextbillionai::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/fleetify/routes.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      class Routes
+        # @return [Nextbillionai::Resources::Fleetify::Routes::Steps]
+        attr_reader :steps
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::RouteCreateParams} for more details.
+        #
+        # Dispatch a new route
+        #
+        # @overload create(key:, driver_email:, steps:, distance: nil, document_template_id: nil, ro_request_id: nil, routing: nil, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param driver_email [String] Body param: Specify the e-mail address of the driver who should receive the rout
+        #
+        # @param steps [Array<Nextbillionai::Models::Fleetify::Routes::RouteStepsRequest>] Body param: An array of objects to collect the details about the intermediate st
+        #
+        # @param distance [Integer] Body param: Specify the total distance, in meters, for an informative display in
+        #
+        # @param document_template_id [String] Body param: Specify the ID of the document template that should be used to colle
+        #
+        # @param ro_request_id [String] Body param: Specify the Route Optimization request ID. When this ID is provided,
+        #
+        # @param routing [Nextbillionai::Models::Fleetify::RouteCreateParams::Routing] Body param: The routing object allows defining the routing characteristics that
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::RouteCreateResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::RouteCreateParams
+        def create(params)
+          parsed, options = Nextbillionai::Fleetify::RouteCreateParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: "fleetify/routes",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Fleetify::RouteCreateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Fleetify::RouteRedispatchParams} for more details.
+        #
+        # Re-dispatch route
+        #
+        # @overload redispatch(route_id, key:, operations:, distance: nil, request_options: {})
+        #
+        # @param route_id [String] Path param: Provide the ID of a previously dispatched route which needs to be mo
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param operations [Array<Nextbillionai::Models::Fleetify::RouteRedispatchParams::Operation>] Body param: A collection of objects with details of the steps to be modified. Ea
+        #
+        # @param distance [Float] Body param: Specify the distance of the route.
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Fleetify::RouteRedispatchResponse]
+        #
+        # @see Nextbillionai::Models::Fleetify::RouteRedispatchParams
+        def redispatch(route_id, params)
+          parsed, options = Nextbillionai::Fleetify::RouteRedispatchParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: ["fleetify/routes/%1$s/redispatch", route_id],
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Fleetify::RouteRedispatchResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+          @steps = Nextbillionai::Resources::Fleetify::Routes::Steps.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/fleetify.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Fleetify
+      # @return [Nextbillionai::Resources::Fleetify::Routes]
+      attr_reader :routes
+
+      # @return [Nextbillionai::Resources::Fleetify::DocumentTemplates]
+      attr_reader :document_templates
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+        @routes = Nextbillionai::Resources::Fleetify::Routes.new(client: client)
+        @document_templates = Nextbillionai::Resources::Fleetify::DocumentTemplates.new(client: client)
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/geocode.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Geocode
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeocodeRetrieveParams} for more details.
+      #
+      # Geocode
+      #
+      # @overload retrieve(key:, q:, at: nil, in_: nil, lang: nil, limit: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param q [String] Specify the free-text search query.
+      #
+      # @param at [String] Specify the center of the search context expressed as coordinates.
+      #
+      # @param in_ [String] Search within a geographic area. This is a hard filter. Results will be returned
+      #
+      # @param lang [String] Select the language to be used for result rendering from a list of [BCP 47](http
+      #
+      # @param limit [Integer] Sets the maximum number of results to be returned.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::GeocodeRetrieveResponse]
+      #
+      # @see Nextbillionai::Models::GeocodeRetrieveParams
+      def retrieve(params)
+        parsed, options = Nextbillionai::GeocodeRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "geocode",
+          query: parsed.transform_keys(in_: "in"),
+          model: Nextbillionai::Models::GeocodeRetrieveResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeocodeBatchCreateParams} for more details.
+      #
+      # Batch Geocode
+      #
+      # @overload batch_create(key:, body:, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param body [Array<Nextbillionai::Models::GeocodeBatchCreateParams::Body>] Body param:
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::GeocodeBatchCreateResponse]
+      #
+      # @see Nextbillionai::Models::GeocodeBatchCreateParams
+      def batch_create(params)
+        parsed, options = Nextbillionai::GeocodeBatchCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "geocode/batch",
+          query: parsed.except(:body),
+          body: parsed[:body],
+          model: Nextbillionai::Models::GeocodeBatchCreateResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeocodeStructuredRetrieveParams} for more details.
+      #
+      # Structured Geocode
+      #
+      # @overload structured_retrieve(country_code:, key:, at: nil, city: nil, county: nil, house_number: nil, in_: nil, limit: nil, postal_code: nil, state: nil, street: nil, request_options: {})
+      #
+      # @param country_code [String] Specify a valid [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_al
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param at [String] Specify the center of the search context expressed as coordinates.
+      #
+      # @param city [String] Specify the city in which the place being searched should be located.
+      #
+      # @param county [String] Specify the county division of the state in which the place being searched shoul
+      #
+      # @param house_number [String] Specify the house number of the place being searched.
+      #
+      # @param in_ [String] Search within a geographic area. This is a hard filter. Results will be returned
+      #
+      # @param limit [Integer] Sets the maximum number of results to be returned.
+      #
+      # @param postal_code [String] Specify the postal code in which the place being searched should be located.
+      #
+      # @param state [String] Specify the state division of the country in which the place being searched shou
+      #
+      # @param street [String] Specify the name of the street in which the place being searched should be locat
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::GeocodeStructuredRetrieveResponse]
+      #
+      # @see Nextbillionai::Models::GeocodeStructuredRetrieveParams
+      def structured_retrieve(params)
+        parsed, options = Nextbillionai::GeocodeStructuredRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "geocode/structured",
+          query: parsed.transform_keys(
+            country_code: "countryCode",
+            house_number: "houseNumber",
+            in_: "in",
+            postal_code: "postalCode"
+          ),
+          model: Nextbillionai::Models::GeocodeStructuredRetrieveResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end