nextbillionai 0.1.0.pre.alpha.4

data/lib/nextbillionai/resources/geofence/batch.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Geofence
+      class Batch
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Geofence::BatchCreateParams} for more details.
+        #
+        # Batch Creation of Geofence
+        #
+        # @overload create(key:, geofences: nil, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param geofences [Array<Nextbillionai::Models::GeofenceEntityCreate>] Body param: An array of objects to collect the details of the multiple geofences
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Geofence::BatchCreateResponse]
+        #
+        # @see Nextbillionai::Models::Geofence::BatchCreateParams
+        def create(params)
+          parsed, options = Nextbillionai::Geofence::BatchCreateParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :post,
+            path: "geofence/batch",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Models::Geofence::BatchCreateResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Geofence::BatchListParams} for more details.
+        #
+        # Batch Query of Geofence
+        #
+        # @overload list(ids:, key:, request_options: {})
+        #
+        # @param ids [String] Comma(,) separated list of IDs of the geofences to be searched.
+        #
+        # @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::Geofence::BatchListResponse]
+        #
+        # @see Nextbillionai::Models::Geofence::BatchListParams
+        def list(params)
+          parsed, options = Nextbillionai::Geofence::BatchListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "geofence/batch",
+            query: parsed,
+            model: Nextbillionai::Models::Geofence::BatchListResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Geofence::BatchDeleteParams} for more details.
+        #
+        # Delete Batch Geofence
+        #
+        # @overload delete(key:, ids: nil, request_options: {})
+        #
+        # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+        #
+        # @param ids [Array<String>] Body param: An array IDs of the geofence to be deleted. These are the IDs that w
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Skynet::SimpleResp]
+        #
+        # @see Nextbillionai::Models::Geofence::BatchDeleteParams
+        def delete(params)
+          parsed, options = Nextbillionai::Geofence::BatchDeleteParams.dump_request(params)
+          query_params = [:key]
+          @client.request(
+            method: :delete,
+            path: "geofence/batch",
+            query: parsed.slice(*query_params),
+            body: parsed.except(*query_params),
+            model: Nextbillionai::Skynet::SimpleResp,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/geofence/console.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Geofence
+      class Console
+        # Some parameter documentations has been truncated, see
+        # {Nextbillionai::Models::Geofence::ConsolePreviewParams} for more details.
+        #
+        # preview geofence geojson
+        #
+        # @overload preview(type:, circle: nil, custom_id: nil, isochrone: nil, meta_data: nil, name: nil, polygon: nil, tags: nil, request_options: {})
+        #
+        # @param type [Symbol, Nextbillionai::Models::GeofenceEntityCreate::Type] Specify the type of the geofence that is being created.
+        #
+        # @param circle [Nextbillionai::Models::GeofenceEntityCreate::Circle] Provide the details to create a circular geofence. Please note that this object
+        #
+        # @param custom_id [String] Set an unique ID for the new geofence. If not provided, an ID will be automatica
+        #
+        # @param isochrone [Nextbillionai::Models::GeofenceEntityCreate::Isochrone] Provide the details to create an isochrone based geofence. Use this object when
+        #
+        # @param meta_data [Object] Metadata of the geofence. Use this field to define custom attributes that provid
+        #
+        # @param name [String] Name of the geofence. Use this field to assign a meaningful, custom name to the
+        #
+        # @param polygon [Nextbillionai::Models::GeofenceEntityCreate::Polygon] Provide the details to create a custom polygon type of geofence. Please note tha
+        #
+        # @param tags [Array<String>] An array of strings to associate multiple tags to the geofence. tags can be used
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Geofence::ConsolePreviewResponse]
+        #
+        # @see Nextbillionai::Models::Geofence::ConsolePreviewParams
+        def preview(params)
+          parsed, options = Nextbillionai::Geofence::ConsolePreviewParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "geofence/console/preview",
+            body: parsed,
+            model: Nextbillionai::Models::Geofence::ConsolePreviewResponse,
+            options: options
+          )
+        end
+
+        # Console Geofence Search API
+        #
+        # @overload search(query:, request_options: {})
+        #
+        # @param query [String] string to be searched, will used to match name or id of geofence.
+        #
+        # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Nextbillionai::Models::Geofence::ConsoleSearchResponse]
+        #
+        # @see Nextbillionai::Models::Geofence::ConsoleSearchParams
+        def search(params)
+          parsed, options = Nextbillionai::Geofence::ConsoleSearchParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "geofence/console/search",
+            query: parsed,
+            model: Nextbillionai::Models::Geofence::ConsoleSearchResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Nextbillionai::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/geofence.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Geofence
+      # @return [Nextbillionai::Resources::Geofence::Console]
+      attr_reader :console
+
+      # @return [Nextbillionai::Resources::Geofence::Batch]
+      attr_reader :batch
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeofenceCreateParams} for more details.
+      #
+      # Create a geofence
+      #
+      # @overload create(key:, type:, circle: nil, custom_id: nil, isochrone: nil, meta_data: nil, name: nil, polygon: nil, tags: nil, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param type [Symbol, Nextbillionai::Models::GeofenceEntityCreate::Type] Body param: Specify the type of the geofence that is being created.
+      #
+      # @param circle [Nextbillionai::Models::GeofenceEntityCreate::Circle] Body param: Provide the details to create a circular geofence. Please note that
+      #
+      # @param custom_id [String] Body param: Set an unique ID for the new geofence. If not provided, an ID will b
+      #
+      # @param isochrone [Nextbillionai::Models::GeofenceEntityCreate::Isochrone] Body param: Provide the details to create an isochrone based geofence. Use this
+      #
+      # @param meta_data [Object] Body param: Metadata of the geofence. Use this field to define custom attributes
+      #
+      # @param name [String] Body param: Name of the geofence. Use this field to assign a meaningful, custom
+      #
+      # @param polygon [Nextbillionai::Models::GeofenceEntityCreate::Polygon] Body param: Provide the details to create a custom polygon type of geofence. Ple
+      #
+      # @param tags [Array<String>] Body param: An array of strings to associate multiple tags to the geofence. tags
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::GeofenceCreateResponse]
+      #
+      # @see Nextbillionai::Models::GeofenceCreateParams
+      def create(params)
+        parsed, options = Nextbillionai::GeofenceCreateParams.dump_request(params)
+        query_params = [:key]
+        @client.request(
+          method: :post,
+          path: "geofence",
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::Models::GeofenceCreateResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeofenceRetrieveParams} for more details.
+      #
+      # Get a Geofence
+      #
+      # @overload retrieve(id, key:, request_options: {})
+      #
+      # @param id [String] ID of the geofence to be fetched. This is the ID that was generated/provided at
+      #
+      # @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::GeofenceRetrieveResponse]
+      #
+      # @see Nextbillionai::Models::GeofenceRetrieveParams
+      def retrieve(id, params)
+        parsed, options = Nextbillionai::GeofenceRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["geofence/%1$s", id],
+          query: parsed,
+          model: Nextbillionai::Models::GeofenceRetrieveResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeofenceUpdateParams} for more details.
+      #
+      # Update a Geofence
+      #
+      # @overload update(id, key:, circle: nil, isochrone: nil, meta_data: nil, name: nil, polygon: nil, tags: nil, type: nil, request_options: {})
+      #
+      # @param id [String] Path param: ID of the geofence to be updated. This is the ID that was generated/
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param circle [Nextbillionai::Models::GeofenceUpdateParams::Circle] Body param: Use this object to update details of a circular geofence. Please not
+      #
+      # @param isochrone [Nextbillionai::Models::GeofenceUpdateParams::Isochrone] Body param: Use this object to update details of an isochrone based geofence. Pl
+      #
+      # @param meta_data [Object] Body param: Updated the meta_data associated with a geofence. Use this field to
+      #
+      # @param name [String] Body param: Use this parameter to update the name of a geofence. Users can assig
+      #
+      # @param polygon [Nextbillionai::Models::GeofenceUpdateParams::Polygon] Body param: Use this object to update details of a custom polygon geofence. Plea
+      #
+      # @param tags [Array<String>] Body param: Use this parameter to add/modify one or multiple tags of a geofence.
+      #
+      # @param type [Symbol, Nextbillionai::Models::GeofenceUpdateParams::Type] Body param: Use this parameter to update the type of a geofence. Please note tha
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::Skynet::SimpleResp]
+      #
+      # @see Nextbillionai::Models::GeofenceUpdateParams
+      def update(id, params)
+        parsed, options = Nextbillionai::GeofenceUpdateParams.dump_request(params)
+        query_params = [:key]
+        @client.request(
+          method: :put,
+          path: ["geofence/%1$s", id],
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::Skynet::SimpleResp,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeofenceListParams} for more details.
+      #
+      # Get Geofence List
+      #
+      # @overload list(key:, pn: nil, ps: nil, tags: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param pn [Integer] Denotes page number. Use this along with the ps parameter to implement paginatio
+      #
+      # @param ps [Integer] Denotes number of search results per page. Use this along with the pn parameter
+      #
+      # @param tags [String] Comma (,) separated list of tags which will be used to filter the geofences.
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::GeofenceListResponse]
+      #
+      # @see Nextbillionai::Models::GeofenceListParams
+      def list(params)
+        parsed, options = Nextbillionai::GeofenceListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "geofence/list",
+          query: parsed,
+          model: Nextbillionai::Models::GeofenceListResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeofenceDeleteParams} for more details.
+      #
+      # Delete a Geofence
+      #
+      # @overload delete(id, key:, request_options: {})
+      #
+      # @param id [String] ID of the geofence to be deleted. This is the ID that was generated/provided at
+      #
+      # @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::Skynet::SimpleResp]
+      #
+      # @see Nextbillionai::Models::GeofenceDeleteParams
+      def delete(id, params)
+        parsed, options = Nextbillionai::GeofenceDeleteParams.dump_request(params)
+        @client.request(
+          method: :delete,
+          path: ["geofence/%1$s", id],
+          query: parsed,
+          model: Nextbillionai::Skynet::SimpleResp,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::GeofenceContainsParams} for more details.
+      #
+      # Geofence Contains
+      #
+      # @overload contains(key:, locations:, geofences: nil, verbose: nil, request_options: {})
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param locations [String] Pipe (|) separated coordinates, in [latitude,longitude] format, of the locations
+      #
+      # @param geofences [String] A , separated list geofence IDs against which the locations will be searched. If
+      #
+      # @param verbose [String] When true, an array with detailed information of geofences is returned. When fal
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::GeofenceContainsResponse]
+      #
+      # @see Nextbillionai::Models::GeofenceContainsParams
+      def contains(params)
+        parsed, options = Nextbillionai::GeofenceContainsParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "geofence/contain",
+          query: parsed,
+          model: Nextbillionai::Models::GeofenceContainsResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+        @console = Nextbillionai::Resources::Geofence::Console.new(client: client)
+        @batch = Nextbillionai::Resources::Geofence::Batch.new(client: client)
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/isochrone.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Isochrone
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::IsochroneComputeParams} for more details.
+      #
+      # The NextBillion.ai Isochrone API computes areas that are reachable within a
+      # specified amount of time from a location, and returns the reachable regions as
+      # contours of polygons or lines that you can display on a map.
+      #
+      # @overload compute(contours_meters:, contours_minutes:, coordinates:, key:, contours_colors: nil, denoise: nil, departure_time: nil, generalize: nil, mode: nil, polygons: nil, request_options: {})
+      #
+      # @param contours_meters [Integer] The distances, in meters, to use for each isochrone contour. You can specify up
+      #
+      # @param contours_minutes [Integer] The times, in minutes, to use for each isochrone contour. You can specify up to
+      #
+      # @param coordinates [String] The coordinates of the location which acts as the starting point for which the i
+      #
+      # @param key [String] A key is a unique identifier that is required to authenticate a request to the A
+      #
+      # @param contours_colors [String] The hex code of the color to fill isochrone contour. When requesting multiple co
+      #
+      # @param denoise [Float] A floating point value from 0.0 to 1.0 can be used to remove smaller contours. T
+      #
+      # @param departure_time [Integer] Use this parameter to set a departure time, expressed as UNIX epoch timestamp in
+      #
+      # @param generalize [Float] A positive floating point value, in meters, used as the tolerance for Douglas-Pe
+      #
+      # @param mode [Symbol, Nextbillionai::Models::IsochroneComputeParams::Mode] Set which driving mode the service should use to determine the contour. For exam
+      #
+      # @param polygons [Boolean] Specify whether to return the contours as GeoJSON polygons (true) or linestrings
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::IsochroneComputeResponse]
+      #
+      # @see Nextbillionai::Models::IsochroneComputeParams
+      def compute(params)
+        parsed, options = Nextbillionai::IsochroneComputeParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "isochrone/json",
+          query: parsed,
+          model: Nextbillionai::Models::IsochroneComputeResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/lookup.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Lookup
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::LookupByIDParams} for more details.
+      #
+      # Lookup By ID
+      #
+      # @overload by_id(id:, key:, request_options: {})
+      #
+      # @param id [String] Specify the unique identifier of a specific POI, Street, Geography, Point Addres
+      #
+      # @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::LookupByIDResponse]
+      #
+      # @see Nextbillionai::Models::LookupByIDParams
+      def by_id(params)
+        parsed, options = Nextbillionai::LookupByIDParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "lookup",
+          query: parsed,
+          model: Nextbillionai::Models::LookupByIDResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/map.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Map
+      # Road Segments
+      #
+      # @overload create_segment(request_options: {})
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Nextbillionai::Models::MapCreateSegmentParams
+      def create_segment(params = {})
+        @client.request(
+          method: :post,
+          path: "map/segments",
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/nextbillionai/resources/mdm.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Nextbillionai
+  module Resources
+    class Mdm
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::MdmCreateDistanceMatrixParams} for more details.
+      #
+      # Create a massive distance matrix task
+      #
+      # @overload create_distance_matrix(key:, option:, origins:, spliter: nil, area: nil, avoid: nil, cross_border: nil, departure_time: nil, destinations: nil, destinations_approach: nil, hazmat_type: nil, mode: nil, origins_approach: nil, route_type: nil, truck_axle_load: nil, truck_size: nil, truck_weight: nil, request_options: {})
+      #
+      # @param key [String] Query param: A key is a unique identifier that is required to authenticate a req
+      #
+      # @param option [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Option] Query param: Use this option to switch to truck-specific routing or time based r
+      #
+      # @param origins [String] Body param: origins are the starting point of your route. Ensure that origins ar
+      #
+      # @param spliter [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Spliter] Query param: Specify a spliter to split the matrix by. It accepts 2 values:
+      #
+      # @param area [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Area] Body param: Provide the country that the coordinates belong to.
+      #
+      # @param avoid [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Avoid] Body param: Setting this will ensure the route avoids the object(s) specified as
+      #
+      # @param cross_border [Boolean] Body param: Specify if crossing an international border is expected for operatio
+      #
+      # @param departure_time [Integer] Body param: This is a number in UNIX epoch timestamp in seconds format that can
+      #
+      # @param destinations [String] Body param: destinations are the ending coordinates of your route. Ensure that d
+      #
+      # @param destinations_approach [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::DestinationsApproach] Body param: Specify the side of the road from which to approach destinations poi
+      #
+      # @param hazmat_type [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::HazmatType] Body param: Specify the type of hazardous material being carried and the service
+      #
+      # @param mode [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::Mode] Body param: Set which driving mode the service should use to determine a route.
+      #
+      # @param origins_approach [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::OriginsApproach] Body param: Specify the side of the road from which to approach origins points.
+      #
+      # @param route_type [Symbol, Nextbillionai::Models::MdmCreateDistanceMatrixParams::RouteType] Body param: Set the route type that needs to be returned. Please note that route
+      #
+      # @param truck_axle_load [Float] Body param: Specify the total load per axle (including the weight of trailers an
+      #
+      # @param truck_size [String] Body param: This defines the dimensions of a truck in centimeters (cm) in the fo
+      #
+      # @param truck_weight [Integer] Body param: This parameter defines the weight of the truck including trailers an
+      #
+      # @param request_options [Nextbillionai::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Nextbillionai::Models::MdmCreateDistanceMatrixResponse]
+      #
+      # @see Nextbillionai::Models::MdmCreateDistanceMatrixParams
+      def create_distance_matrix(params)
+        parsed, options = Nextbillionai::MdmCreateDistanceMatrixParams.dump_request(params)
+        query_params = [:key, :option, :spliter]
+        @client.request(
+          method: :post,
+          path: "mdm/create",
+          query: parsed.slice(*query_params),
+          body: parsed.except(*query_params),
+          model: Nextbillionai::Models::MdmCreateDistanceMatrixResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Nextbillionai::Models::MdmGetDistanceMatrixStatusParams} for more details.
+      #
+      # Get massive distance matrix task status
+      #
+      # @overload get_distance_matrix_status(id:, key:, request_options: {})
+      #
+      # @param id [String] Provide the unique ID that was returned on successful submission of the Asynchro
+      #
+      # @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::MdmGetDistanceMatrixStatusResponse]
+      #
+      # @see Nextbillionai::Models::MdmGetDistanceMatrixStatusParams
+      def get_distance_matrix_status(params)
+        parsed, options = Nextbillionai::MdmGetDistanceMatrixStatusParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "mdm/status",
+          query: parsed,
+          model: Nextbillionai::Models::MdmGetDistanceMatrixStatusResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Nextbillionai::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end