@aws-sdk/client-geo-routes 3.683.0

package/dist-types/commands/OptimizeWaypointsCommand.d.ts

@@ -0,0 +1,251 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GeoRoutesClient";
+import { OptimizeWaypointsRequest, OptimizeWaypointsResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link OptimizeWaypointsCommand}.
+ */
+export interface OptimizeWaypointsCommandInput extends OptimizeWaypointsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link OptimizeWaypointsCommand}.
+ */
+export interface OptimizeWaypointsCommandOutput extends OptimizeWaypointsResponse, __MetadataBearer {
+}
+declare const OptimizeWaypointsCommand_base: {
+    new (input: OptimizeWaypointsCommandInput): import("@smithy/smithy-client").CommandImpl<OptimizeWaypointsCommandInput, OptimizeWaypointsCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: OptimizeWaypointsCommandInput): import("@smithy/smithy-client").CommandImpl<OptimizeWaypointsCommandInput, OptimizeWaypointsCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Calculates the optimal order to travel between a set of waypoints to minimize either the
+ *          travel time or the distance travelled during the journey, based on road network
+ *          restrictions and the traffic pattern data.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GeoRoutesClient, OptimizeWaypointsCommand } from "@aws-sdk/client-geo-routes"; // ES Modules import
+ * // const { GeoRoutesClient, OptimizeWaypointsCommand } = require("@aws-sdk/client-geo-routes"); // CommonJS import
+ * const client = new GeoRoutesClient(config);
+ * const input = { // OptimizeWaypointsRequest
+ *   Avoid: { // WaypointOptimizationAvoidanceOptions
+ *     Areas: [ // WaypointOptimizationAvoidanceAreaList
+ *       { // WaypointOptimizationAvoidanceArea
+ *         Geometry: { // WaypointOptimizationAvoidanceAreaGeometry
+ *           BoundingBox: [ // BoundingBox
+ *             Number("double"),
+ *           ],
+ *         },
+ *       },
+ *     ],
+ *     CarShuttleTrains: true || false,
+ *     ControlledAccessHighways: true || false,
+ *     DirtRoads: true || false,
+ *     Ferries: true || false,
+ *     TollRoads: true || false,
+ *     Tunnels: true || false,
+ *     UTurns: true || false,
+ *   },
+ *   DepartureTime: "STRING_VALUE",
+ *   Destination: [ // Position
+ *     Number("double"),
+ *   ],
+ *   DestinationOptions: { // WaypointOptimizationDestinationOptions
+ *     AccessHours: { // WaypointOptimizationAccessHours
+ *       From: { // WaypointOptimizationAccessHoursEntry
+ *         DayOfWeek: "STRING_VALUE", // required
+ *         TimeOfDay: "STRING_VALUE", // required
+ *       },
+ *       To: {
+ *         DayOfWeek: "STRING_VALUE", // required
+ *         TimeOfDay: "STRING_VALUE", // required
+ *       },
+ *     },
+ *     AppointmentTime: "STRING_VALUE",
+ *     Heading: Number("double"),
+ *     Id: "STRING_VALUE",
+ *     ServiceDuration: Number("long"),
+ *     SideOfStreet: { // WaypointOptimizationSideOfStreetOptions
+ *       Position: [ // required
+ *         Number("double"),
+ *       ],
+ *       UseWith: "STRING_VALUE",
+ *     },
+ *   },
+ *   Driver: { // WaypointOptimizationDriverOptions
+ *     RestCycles: { // WaypointOptimizationRestCycles
+ *       LongCycle: { // WaypointOptimizationRestCycleDurations
+ *         RestDuration: Number("long"), // required
+ *         WorkDuration: Number("long"), // required
+ *       },
+ *       ShortCycle: {
+ *         RestDuration: Number("long"), // required
+ *         WorkDuration: Number("long"), // required
+ *       },
+ *     },
+ *     RestProfile: { // WaypointOptimizationRestProfile
+ *       Profile: "STRING_VALUE", // required
+ *     },
+ *     TreatServiceTimeAs: "STRING_VALUE",
+ *   },
+ *   Exclude: { // WaypointOptimizationExclusionOptions
+ *     Countries: [ // CountryCodeList // required
+ *       "STRING_VALUE",
+ *     ],
+ *   },
+ *   Key: "STRING_VALUE",
+ *   OptimizeSequencingFor: "STRING_VALUE",
+ *   Origin: [ // required
+ *     Number("double"),
+ *   ],
+ *   OriginOptions: { // WaypointOptimizationOriginOptions
+ *     Id: "STRING_VALUE",
+ *   },
+ *   Traffic: { // WaypointOptimizationTrafficOptions
+ *     Usage: "STRING_VALUE",
+ *   },
+ *   TravelMode: "STRING_VALUE",
+ *   TravelModeOptions: { // WaypointOptimizationTravelModeOptions
+ *     Pedestrian: { // WaypointOptimizationPedestrianOptions
+ *       Speed: Number("double"),
+ *     },
+ *     Truck: { // WaypointOptimizationTruckOptions
+ *       GrossWeight: Number("long"),
+ *       HazardousCargos: [ // WaypointOptimizationHazardousCargoTypeList
+ *         "STRING_VALUE",
+ *       ],
+ *       Height: Number("long"),
+ *       Length: Number("long"),
+ *       Trailer: { // WaypointOptimizationTrailerOptions
+ *         TrailerCount: Number("int"),
+ *       },
+ *       TruckType: "STRING_VALUE",
+ *       TunnelRestrictionCode: "STRING_VALUE",
+ *       WeightPerAxle: Number("long"),
+ *       Width: Number("long"),
+ *     },
+ *   },
+ *   Waypoints: [ // WaypointOptimizationWaypointList
+ *     { // WaypointOptimizationWaypoint
+ *       AccessHours: {
+ *         From: {
+ *           DayOfWeek: "STRING_VALUE", // required
+ *           TimeOfDay: "STRING_VALUE", // required
+ *         },
+ *         To: {
+ *           DayOfWeek: "STRING_VALUE", // required
+ *           TimeOfDay: "STRING_VALUE", // required
+ *         },
+ *       },
+ *       AppointmentTime: "STRING_VALUE",
+ *       Before: [ // BeforeWaypointsList
+ *         Number("int"),
+ *       ],
+ *       Heading: Number("double"),
+ *       Id: "STRING_VALUE",
+ *       Position: [ // required
+ *         Number("double"),
+ *       ],
+ *       ServiceDuration: Number("long"),
+ *       SideOfStreet: {
+ *         Position: "<Position>", // required
+ *         UseWith: "STRING_VALUE",
+ *       },
+ *     },
+ *   ],
+ * };
+ * const command = new OptimizeWaypointsCommand(input);
+ * const response = await client.send(command);
+ * // { // OptimizeWaypointsResponse
+ * //   Connections: [ // WaypointOptimizationConnectionList // required
+ * //     { // WaypointOptimizationConnection
+ * //       Distance: Number("long"), // required
+ * //       From: "STRING_VALUE", // required
+ * //       RestDuration: Number("long"), // required
+ * //       To: "STRING_VALUE", // required
+ * //       TravelDuration: Number("long"), // required
+ * //       WaitDuration: Number("long"), // required
+ * //     },
+ * //   ],
+ * //   Distance: Number("long"), // required
+ * //   Duration: Number("long"), // required
+ * //   ImpedingWaypoints: [ // WaypointOptimizationImpedingWaypointList // required
+ * //     { // WaypointOptimizationImpedingWaypoint
+ * //       FailedConstraints: [ // WaypointOptimizationFailedConstraintList // required
+ * //         { // WaypointOptimizationFailedConstraint
+ * //           Constraint: "STRING_VALUE",
+ * //           Reason: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       Id: "STRING_VALUE", // required
+ * //       Position: [ // Position // required
+ * //         Number("double"),
+ * //       ],
+ * //     },
+ * //   ],
+ * //   OptimizedWaypoints: [ // WaypointOptimizationOptimizedWaypointList // required
+ * //     { // WaypointOptimizationOptimizedWaypoint
+ * //       ArrivalTime: "STRING_VALUE",
+ * //       DepartureTime: "STRING_VALUE", // required
+ * //       Id: "STRING_VALUE", // required
+ * //       Position: [ // required
+ * //         Number("double"),
+ * //       ],
+ * //     },
+ * //   ],
+ * //   PricingBucket: "STRING_VALUE", // required
+ * //   TimeBreakdown: { // WaypointOptimizationTimeBreakdown
+ * //     RestDuration: Number("long"), // required
+ * //     ServiceDuration: Number("long"), // required
+ * //     TravelDuration: Number("long"), // required
+ * //     WaitDuration: Number("long"), // required
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param OptimizeWaypointsCommandInput - {@link OptimizeWaypointsCommandInput}
+ * @returns {@link OptimizeWaypointsCommandOutput}
+ * @see {@link OptimizeWaypointsCommandInput} for command's `input` shape.
+ * @see {@link OptimizeWaypointsCommandOutput} for command's `response` shape.
+ * @see {@link GeoRoutesClientResolvedConfig | config} for GeoRoutesClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You don't have sufficient access to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>The request processing has failed because of an unknown error, exception or failure.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied due to request throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+ *
+ * @throws {@link GeoRoutesServiceException}
+ * <p>Base exception class for all service exceptions from GeoRoutes service.</p>
+ *
+ * @public
+ */
+export declare class OptimizeWaypointsCommand extends OptimizeWaypointsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: OptimizeWaypointsRequest;
+            output: OptimizeWaypointsResponse;
+        };
+        sdk: {
+            input: OptimizeWaypointsCommandInput;
+            output: OptimizeWaypointsCommandOutput;
+        };
+    };
+}

package/dist-types/commands/SnapToRoadsCommand.d.ts

@@ -0,0 +1,140 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GeoRoutesClient";
+import { SnapToRoadsRequest, SnapToRoadsResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link SnapToRoadsCommand}.
+ */
+export interface SnapToRoadsCommandInput extends SnapToRoadsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link SnapToRoadsCommand}.
+ */
+export interface SnapToRoadsCommandOutput extends SnapToRoadsResponse, __MetadataBearer {
+}
+declare const SnapToRoadsCommand_base: {
+    new (input: SnapToRoadsCommandInput): import("@smithy/smithy-client").CommandImpl<SnapToRoadsCommandInput, SnapToRoadsCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: SnapToRoadsCommandInput): import("@smithy/smithy-client").CommandImpl<SnapToRoadsCommandInput, SnapToRoadsCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>The SnapToRoads action matches GPS trace to roads most likely traveled on.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GeoRoutesClient, SnapToRoadsCommand } from "@aws-sdk/client-geo-routes"; // ES Modules import
+ * // const { GeoRoutesClient, SnapToRoadsCommand } = require("@aws-sdk/client-geo-routes"); // CommonJS import
+ * const client = new GeoRoutesClient(config);
+ * const input = { // SnapToRoadsRequest
+ *   Key: "STRING_VALUE",
+ *   SnappedGeometryFormat: "STRING_VALUE",
+ *   SnapRadius: Number("long"),
+ *   TracePoints: [ // RoadSnapTracePointList // required
+ *     { // RoadSnapTracePoint
+ *       Heading: Number("double"),
+ *       Position: [ // Position // required
+ *         Number("double"),
+ *       ],
+ *       Speed: Number("double"),
+ *       Timestamp: "STRING_VALUE",
+ *     },
+ *   ],
+ *   TravelMode: "STRING_VALUE",
+ *   TravelModeOptions: { // RoadSnapTravelModeOptions
+ *     Truck: { // RoadSnapTruckOptions
+ *       GrossWeight: Number("long"),
+ *       HazardousCargos: [ // RoadSnapHazardousCargoTypeList
+ *         "STRING_VALUE",
+ *       ],
+ *       Height: Number("long"),
+ *       Length: Number("long"),
+ *       Trailer: { // RoadSnapTrailerOptions
+ *         TrailerCount: Number("int"),
+ *       },
+ *       TunnelRestrictionCode: "STRING_VALUE",
+ *       Width: Number("long"),
+ *     },
+ *   },
+ * };
+ * const command = new SnapToRoadsCommand(input);
+ * const response = await client.send(command);
+ * // { // SnapToRoadsResponse
+ * //   Notices: [ // RoadSnapNoticeList // required
+ * //     { // RoadSnapNotice
+ * //       Code: "STRING_VALUE", // required
+ * //       Title: "STRING_VALUE", // required
+ * //       TracePointIndexes: [ // RoadSnapTracePointIndexList // required
+ * //         Number("int"),
+ * //       ],
+ * //     },
+ * //   ],
+ * //   PricingBucket: "STRING_VALUE", // required
+ * //   SnappedGeometry: { // RoadSnapSnappedGeometry
+ * //     LineString: [ // LineString
+ * //       [ // Position
+ * //         Number("double"),
+ * //       ],
+ * //     ],
+ * //     Polyline: "STRING_VALUE",
+ * //   },
+ * //   SnappedGeometryFormat: "STRING_VALUE", // required
+ * //   SnappedTracePoints: [ // RoadSnapSnappedTracePointList // required
+ * //     { // RoadSnapSnappedTracePoint
+ * //       Confidence: Number("double"), // required
+ * //       OriginalPosition: [ // required
+ * //         Number("double"),
+ * //       ],
+ * //       SnappedPosition: [ // required
+ * //         Number("double"),
+ * //       ],
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param SnapToRoadsCommandInput - {@link SnapToRoadsCommandInput}
+ * @returns {@link SnapToRoadsCommandOutput}
+ * @see {@link SnapToRoadsCommandInput} for command's `input` shape.
+ * @see {@link SnapToRoadsCommandOutput} for command's `response` shape.
+ * @see {@link GeoRoutesClientResolvedConfig | config} for GeoRoutesClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You don't have sufficient access to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>The request processing has failed because of an unknown error, exception or failure.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied due to request throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The input fails to satisfy the constraints specified by an AWS service.</p>
+ *
+ * @throws {@link GeoRoutesServiceException}
+ * <p>Base exception class for all service exceptions from GeoRoutes service.</p>
+ *
+ * @public
+ */
+export declare class SnapToRoadsCommand extends SnapToRoadsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: SnapToRoadsRequest;
+            output: SnapToRoadsResponse;
+        };
+        sdk: {
+            input: SnapToRoadsCommandInput;
+            output: SnapToRoadsCommandOutput;
+        };
+    };
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./CalculateIsolinesCommand";
+export * from "./CalculateRouteMatrixCommand";
+export * from "./CalculateRoutesCommand";
+export * from "./OptimizeWaypointsCommand";
+export * from "./SnapToRoadsCommand";

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,40 @@
+import { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2, Provider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface ClientInputEndpointParameters {
+    useDualstackEndpoint?: boolean | Provider<boolean>;
+    useFipsEndpoint?: boolean | Provider<boolean>;
+    endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+    region?: string | Provider<string>;
+}
+export type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export declare const commonParams: {
+    readonly UseFIPS: {
+        readonly type: "builtInParams";
+        readonly name: "useFipsEndpoint";
+    };
+    readonly Endpoint: {
+        readonly type: "builtInParams";
+        readonly name: "endpoint";
+    };
+    readonly Region: {
+        readonly type: "builtInParams";
+        readonly name: "region";
+    };
+    readonly UseDualStack: {
+        readonly type: "builtInParams";
+        readonly name: "useDualstackEndpoint";
+    };
+};
+export interface EndpointParameters extends __EndpointParameters {
+    UseDualStack?: boolean;
+    UseFIPS?: boolean;
+    Endpoint?: string;
+    Region?: string;
+}

package/dist-types/endpoint/endpointResolver.d.ts

@@ -0,0 +1,5 @@
+import { EndpointV2, Logger } from "@smithy/types";
+import { EndpointParameters } from "./EndpointParameters";
+export declare const defaultEndpointResolver: (endpointParams: EndpointParameters, context?: {
+    logger?: Logger;
+}) => EndpointV2;

package/dist-types/endpoint/ruleset.d.ts

@@ -0,0 +1,2 @@
+import { RuleSetObject } from "@smithy/types";
+export declare const ruleSet: RuleSetObject;

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,9 @@
+import { AwsRegionExtensionConfiguration } from "@aws-sdk/types";
+import { HttpHandlerExtensionConfiguration } from "@smithy/protocol-http";
+import { DefaultExtensionConfiguration } from "@smithy/types";
+import { HttpAuthExtensionConfiguration } from "./auth/httpAuthExtensionConfiguration";
+/**
+ * @internal
+ */
+export interface GeoRoutesExtensionConfiguration extends HttpHandlerExtensionConfiguration, DefaultExtensionConfiguration, AwsRegionExtensionConfiguration, HttpAuthExtensionConfiguration {
+}

package/dist-types/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * <p>With the Amazon Location Routes API you can calculate
+ *        routes and estimate travel time based on up-to-date road network and live
+ *        traffic information.</p>
+ *          <p>Calculate optimal travel routes and estimate travel times using up-to-date road network and traffic data. Key features include:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Point-to-point routing with estimated travel time, distance, and turn-by-turn directions</p>
+ *             </li>
+ *             <li>
+ *                <p>Multi-point route optimization to minimize travel time or distance</p>
+ *             </li>
+ *             <li>
+ *                <p>Route matrices for efficient multi-destination planning</p>
+ *             </li>
+ *             <li>
+ *                <p>Isoline calculations to determine reachable areas within specified time or distance thresholds</p>
+ *             </li>
+ *             <li>
+ *                <p>Map-matching to align GPS traces with the road network</p>
+ *             </li>
+ *          </ul>
+ *
+ * @packageDocumentation
+ */
+export * from "./GeoRoutesClient";
+export * from "./GeoRoutes";
+export { ClientInputEndpointParameters } from "./endpoint/EndpointParameters";
+export type { RuntimeExtension } from "./runtimeExtensions";
+export type { GeoRoutesExtensionConfiguration } from "./extensionConfiguration";
+export * from "./commands";
+export * from "./models";
+export { GeoRoutesServiceException } from "./models/GeoRoutesServiceException";

package/dist-types/models/GeoRoutesServiceException.d.ts

@@ -0,0 +1,14 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@smithy/smithy-client";
+export type { __ServiceExceptionOptions };
+export { __ServiceException };
+/**
+ * @public
+ *
+ * Base exception class for all service exceptions from GeoRoutes service.
+ */
+export declare class GeoRoutesServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";