@aws-sdk/client-geo-routes 3.683.0

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

@@ -0,0 +1,315 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GeoRoutesClient";
+import { CalculateIsolinesRequest, CalculateIsolinesResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link CalculateIsolinesCommand}.
+ */
+export interface CalculateIsolinesCommandInput extends CalculateIsolinesRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CalculateIsolinesCommand}.
+ */
+export interface CalculateIsolinesCommandOutput extends CalculateIsolinesResponse, __MetadataBearer {
+}
+declare const CalculateIsolinesCommand_base: {
+    new (input: CalculateIsolinesCommandInput): import("@smithy/smithy-client").CommandImpl<CalculateIsolinesCommandInput, CalculateIsolinesCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: CalculateIsolinesCommandInput): import("@smithy/smithy-client").CommandImpl<CalculateIsolinesCommandInput, CalculateIsolinesCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Use the <code>CalculateIsolines</code> action to find service areas that can be reached
+ *          in a given threshold of time, distance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GeoRoutesClient, CalculateIsolinesCommand } from "@aws-sdk/client-geo-routes"; // ES Modules import
+ * // const { GeoRoutesClient, CalculateIsolinesCommand } = require("@aws-sdk/client-geo-routes"); // CommonJS import
+ * const client = new GeoRoutesClient(config);
+ * const input = { // CalculateIsolinesRequest
+ *   Allow: { // IsolineAllowOptions
+ *     Hot: true || false,
+ *     Hov: true || false,
+ *   },
+ *   ArrivalTime: "STRING_VALUE",
+ *   Avoid: { // IsolineAvoidanceOptions
+ *     Areas: [ // IsolineAvoidanceAreaList
+ *       { // IsolineAvoidanceArea
+ *         Except: [ // IsolineAvoidanceAreaGeometryList
+ *           { // IsolineAvoidanceAreaGeometry
+ *             BoundingBox: [ // BoundingBox
+ *               Number("double"),
+ *             ],
+ *             Corridor: { // Corridor
+ *               LineString: [ // LineString // required
+ *                 [ // Position
+ *                   Number("double"),
+ *                 ],
+ *               ],
+ *               Radius: Number("int"), // required
+ *             },
+ *             Polygon: [ // LinearRings
+ *               [ // LinearRing
+ *                 [
+ *                   Number("double"),
+ *                 ],
+ *               ],
+ *             ],
+ *             PolylineCorridor: { // PolylineCorridor
+ *               Polyline: "STRING_VALUE", // required
+ *               Radius: Number("int"), // required
+ *             },
+ *             PolylinePolygon: [ // PolylineRingList
+ *               "STRING_VALUE",
+ *             ],
+ *           },
+ *         ],
+ *         Geometry: {
+ *           BoundingBox: [
+ *             Number("double"),
+ *           ],
+ *           Corridor: {
+ *             LineString: [ // required
+ *               [
+ *                 Number("double"),
+ *               ],
+ *             ],
+ *             Radius: Number("int"), // required
+ *           },
+ *           Polygon: [
+ *             [
+ *               [
+ *                 Number("double"),
+ *               ],
+ *             ],
+ *           ],
+ *           PolylineCorridor: {
+ *             Polyline: "STRING_VALUE", // required
+ *             Radius: Number("int"), // required
+ *           },
+ *           PolylinePolygon: [
+ *             "STRING_VALUE",
+ *           ],
+ *         },
+ *       },
+ *     ],
+ *     CarShuttleTrains: true || false,
+ *     ControlledAccessHighways: true || false,
+ *     DirtRoads: true || false,
+ *     Ferries: true || false,
+ *     SeasonalClosure: true || false,
+ *     TollRoads: true || false,
+ *     TollTransponders: true || false,
+ *     TruckRoadTypes: [ // TruckRoadTypeList
+ *       "STRING_VALUE",
+ *     ],
+ *     Tunnels: true || false,
+ *     UTurns: true || false,
+ *     ZoneCategories: [ // IsolineAvoidanceZoneCategoryList
+ *       { // IsolineAvoidanceZoneCategory
+ *         Category: "STRING_VALUE",
+ *       },
+ *     ],
+ *   },
+ *   DepartNow: true || false,
+ *   DepartureTime: "STRING_VALUE",
+ *   Destination: "<Position>",
+ *   DestinationOptions: { // IsolineDestinationOptions
+ *     AvoidActionsForDistance: Number("long"),
+ *     Heading: Number("double"),
+ *     Matching: { // IsolineMatchingOptions
+ *       NameHint: "STRING_VALUE",
+ *       OnRoadThreshold: Number("long"),
+ *       Radius: Number("long"),
+ *       Strategy: "STRING_VALUE",
+ *     },
+ *     SideOfStreet: { // IsolineSideOfStreetOptions
+ *       Position: "<Position>", // required
+ *       UseWith: "STRING_VALUE",
+ *     },
+ *   },
+ *   IsolineGeometryFormat: "STRING_VALUE",
+ *   IsolineGranularity: { // IsolineGranularityOptions
+ *     MaxPoints: Number("int"),
+ *     MaxResolution: Number("long"),
+ *   },
+ *   Key: "STRING_VALUE",
+ *   OptimizeIsolineFor: "STRING_VALUE",
+ *   OptimizeRoutingFor: "STRING_VALUE",
+ *   Origin: "<Position>",
+ *   OriginOptions: { // IsolineOriginOptions
+ *     AvoidActionsForDistance: Number("long"),
+ *     Heading: Number("double"),
+ *     Matching: {
+ *       NameHint: "STRING_VALUE",
+ *       OnRoadThreshold: Number("long"),
+ *       Radius: Number("long"),
+ *       Strategy: "STRING_VALUE",
+ *     },
+ *     SideOfStreet: {
+ *       Position: "<Position>", // required
+ *       UseWith: "STRING_VALUE",
+ *     },
+ *   },
+ *   Thresholds: { // IsolineThresholds
+ *     Distance: [ // DistanceThresholdList
+ *       Number("long"),
+ *     ],
+ *     Time: [ // TimeThresholdList
+ *       Number("long"),
+ *     ],
+ *   },
+ *   Traffic: { // IsolineTrafficOptions
+ *     FlowEventThresholdOverride: Number("long"),
+ *     Usage: "STRING_VALUE",
+ *   },
+ *   TravelMode: "STRING_VALUE",
+ *   TravelModeOptions: { // IsolineTravelModeOptions
+ *     Car: { // IsolineCarOptions
+ *       EngineType: "STRING_VALUE",
+ *       LicensePlate: { // IsolineVehicleLicensePlate
+ *         LastCharacter: "STRING_VALUE",
+ *       },
+ *       MaxSpeed: Number("double"),
+ *       Occupancy: Number("int"),
+ *     },
+ *     Scooter: { // IsolineScooterOptions
+ *       EngineType: "STRING_VALUE",
+ *       LicensePlate: {
+ *         LastCharacter: "STRING_VALUE",
+ *       },
+ *       MaxSpeed: Number("double"),
+ *       Occupancy: Number("int"),
+ *     },
+ *     Truck: { // IsolineTruckOptions
+ *       AxleCount: Number("int"),
+ *       EngineType: "STRING_VALUE",
+ *       GrossWeight: Number("long"),
+ *       HazardousCargos: [ // IsolineHazardousCargoTypeList
+ *         "STRING_VALUE",
+ *       ],
+ *       Height: Number("long"),
+ *       HeightAboveFirstAxle: Number("long"),
+ *       KpraLength: Number("long"),
+ *       Length: Number("long"),
+ *       LicensePlate: {
+ *         LastCharacter: "STRING_VALUE",
+ *       },
+ *       MaxSpeed: Number("double"),
+ *       Occupancy: Number("int"),
+ *       PayloadCapacity: Number("long"),
+ *       TireCount: Number("int"),
+ *       Trailer: { // IsolineTrailerOptions
+ *         AxleCount: Number("int"),
+ *         TrailerCount: Number("int"),
+ *       },
+ *       TruckType: "STRING_VALUE",
+ *       TunnelRestrictionCode: "STRING_VALUE",
+ *       WeightPerAxle: Number("long"),
+ *       WeightPerAxleGroup: { // WeightPerAxleGroup
+ *         Single: Number("long"),
+ *         Tandem: Number("long"),
+ *         Triple: Number("long"),
+ *         Quad: Number("long"),
+ *         Quint: Number("long"),
+ *       },
+ *       Width: Number("long"),
+ *     },
+ *   },
+ * };
+ * const command = new CalculateIsolinesCommand(input);
+ * const response = await client.send(command);
+ * // { // CalculateIsolinesResponse
+ * //   ArrivalTime: "STRING_VALUE",
+ * //   DepartureTime: "STRING_VALUE",
+ * //   IsolineGeometryFormat: "STRING_VALUE", // required
+ * //   Isolines: [ // IsolineList // required
+ * //     { // Isoline
+ * //       Connections: [ // IsolineConnectionList // required
+ * //         { // IsolineConnection
+ * //           FromPolygonIndex: Number("int"), // required
+ * //           Geometry: { // IsolineConnectionGeometry
+ * //             LineString: [ // LineString
+ * //               [ // Position
+ * //                 Number("double"),
+ * //               ],
+ * //             ],
+ * //             Polyline: "STRING_VALUE",
+ * //           },
+ * //           ToPolygonIndex: Number("int"), // required
+ * //         },
+ * //       ],
+ * //       DistanceThreshold: Number("long"),
+ * //       Geometries: [ // IsolineShapeGeometryList // required
+ * //         { // IsolineShapeGeometry
+ * //           Polygon: [ // LinearRings
+ * //             [ // LinearRing
+ * //               [
+ * //                 Number("double"),
+ * //               ],
+ * //             ],
+ * //           ],
+ * //           PolylinePolygon: [ // PolylineRingList
+ * //             "STRING_VALUE",
+ * //           ],
+ * //         },
+ * //       ],
+ * //       TimeThreshold: Number("long"),
+ * //     },
+ * //   ],
+ * //   PricingBucket: "STRING_VALUE", // required
+ * //   SnappedDestination: [
+ * //     Number("double"),
+ * //   ],
+ * //   SnappedOrigin: [
+ * //     Number("double"),
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param CalculateIsolinesCommandInput - {@link CalculateIsolinesCommandInput}
+ * @returns {@link CalculateIsolinesCommandOutput}
+ * @see {@link CalculateIsolinesCommandInput} for command's `input` shape.
+ * @see {@link CalculateIsolinesCommandOutput} 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 CalculateIsolinesCommand extends CalculateIsolinesCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: CalculateIsolinesRequest;
+            output: CalculateIsolinesResponse;
+        };
+        sdk: {
+            input: CalculateIsolinesCommandInput;
+            output: CalculateIsolinesCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,281 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GeoRoutesClient";
+import { CalculateRouteMatrixRequest, CalculateRouteMatrixResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link CalculateRouteMatrixCommand}.
+ */
+export interface CalculateRouteMatrixCommandInput extends CalculateRouteMatrixRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CalculateRouteMatrixCommand}.
+ */
+export interface CalculateRouteMatrixCommandOutput extends CalculateRouteMatrixResponse, __MetadataBearer {
+}
+declare const CalculateRouteMatrixCommand_base: {
+    new (input: CalculateRouteMatrixCommandInput): import("@smithy/smithy-client").CommandImpl<CalculateRouteMatrixCommandInput, CalculateRouteMatrixCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: CalculateRouteMatrixCommandInput): import("@smithy/smithy-client").CommandImpl<CalculateRouteMatrixCommandInput, CalculateRouteMatrixCommandOutput, GeoRoutesClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Calculates route matrix containing the results for all pairs of
+ *       Origins to Destinations. Each row corresponds to one entry in Origins.
+ *       Each entry in the row corresponds to the route from that entry in Origins to an entry in Destinations positions.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GeoRoutesClient, CalculateRouteMatrixCommand } from "@aws-sdk/client-geo-routes"; // ES Modules import
+ * // const { GeoRoutesClient, CalculateRouteMatrixCommand } = require("@aws-sdk/client-geo-routes"); // CommonJS import
+ * const client = new GeoRoutesClient(config);
+ * const input = { // CalculateRouteMatrixRequest
+ *   Allow: { // RouteMatrixAllowOptions
+ *     Hot: true || false,
+ *     Hov: true || false,
+ *   },
+ *   Avoid: { // RouteMatrixAvoidanceOptions
+ *     Areas: [ // RouteMatrixAvoidanceAreaList
+ *       { // RouteMatrixAvoidanceArea
+ *         Geometry: { // RouteMatrixAvoidanceAreaGeometry
+ *           BoundingBox: [ // BoundingBox
+ *             Number("double"),
+ *           ],
+ *           Polygon: [ // LinearRings
+ *             [ // LinearRing
+ *               [ // Position
+ *                 Number("double"),
+ *               ],
+ *             ],
+ *           ],
+ *           PolylinePolygon: [ // PolylineRingList
+ *             "STRING_VALUE",
+ *           ],
+ *         },
+ *       },
+ *     ],
+ *     CarShuttleTrains: true || false,
+ *     ControlledAccessHighways: true || false,
+ *     DirtRoads: true || false,
+ *     Ferries: true || false,
+ *     TollRoads: true || false,
+ *     TollTransponders: true || false,
+ *     TruckRoadTypes: [ // TruckRoadTypeList
+ *       "STRING_VALUE",
+ *     ],
+ *     Tunnels: true || false,
+ *     UTurns: true || false,
+ *     ZoneCategories: [ // RouteMatrixAvoidanceZoneCategoryList
+ *       { // RouteMatrixAvoidanceZoneCategory
+ *         Category: "STRING_VALUE",
+ *       },
+ *     ],
+ *   },
+ *   DepartNow: true || false,
+ *   DepartureTime: "STRING_VALUE",
+ *   Destinations: [ // RouteMatrixDestinationList // required
+ *     { // RouteMatrixDestination
+ *       Options: { // RouteMatrixDestinationOptions
+ *         AvoidActionsForDistance: Number("long"),
+ *         Heading: Number("double"),
+ *         Matching: { // RouteMatrixMatchingOptions
+ *           NameHint: "STRING_VALUE",
+ *           OnRoadThreshold: Number("long"),
+ *           Radius: Number("long"),
+ *           Strategy: "STRING_VALUE",
+ *         },
+ *         SideOfStreet: { // RouteMatrixSideOfStreetOptions
+ *           Position: [ // required
+ *             Number("double"),
+ *           ],
+ *           UseWith: "STRING_VALUE",
+ *         },
+ *       },
+ *       Position: "<Position>", // required
+ *     },
+ *   ],
+ *   Exclude: { // RouteMatrixExclusionOptions
+ *     Countries: [ // CountryCodeList // required
+ *       "STRING_VALUE",
+ *     ],
+ *   },
+ *   Key: "STRING_VALUE",
+ *   OptimizeRoutingFor: "STRING_VALUE",
+ *   Origins: [ // RouteMatrixOriginList // required
+ *     { // RouteMatrixOrigin
+ *       Options: { // RouteMatrixOriginOptions
+ *         AvoidActionsForDistance: Number("long"),
+ *         Heading: Number("double"),
+ *         Matching: {
+ *           NameHint: "STRING_VALUE",
+ *           OnRoadThreshold: Number("long"),
+ *           Radius: Number("long"),
+ *           Strategy: "STRING_VALUE",
+ *         },
+ *         SideOfStreet: {
+ *           Position: "<Position>", // required
+ *           UseWith: "STRING_VALUE",
+ *         },
+ *       },
+ *       Position: "<Position>", // required
+ *     },
+ *   ],
+ *   RoutingBoundary: { // RouteMatrixBoundary
+ *     Geometry: { // RouteMatrixBoundaryGeometry
+ *       AutoCircle: { // RouteMatrixAutoCircle
+ *         Margin: Number("long"),
+ *         MaxRadius: Number("long"),
+ *       },
+ *       Circle: { // Circle
+ *         Center: "<Position>", // required
+ *         Radius: Number("double"), // required
+ *       },
+ *       BoundingBox: [
+ *         Number("double"),
+ *       ],
+ *       Polygon: [
+ *         [
+ *           "<Position>",
+ *         ],
+ *       ],
+ *     },
+ *     Unbounded: true || false,
+ *   },
+ *   Traffic: { // RouteMatrixTrafficOptions
+ *     FlowEventThresholdOverride: Number("long"),
+ *     Usage: "STRING_VALUE",
+ *   },
+ *   TravelMode: "STRING_VALUE",
+ *   TravelModeOptions: { // RouteMatrixTravelModeOptions
+ *     Car: { // RouteMatrixCarOptions
+ *       LicensePlate: { // RouteMatrixVehicleLicensePlate
+ *         LastCharacter: "STRING_VALUE",
+ *       },
+ *       MaxSpeed: Number("double"),
+ *       Occupancy: Number("int"),
+ *     },
+ *     Scooter: { // RouteMatrixScooterOptions
+ *       LicensePlate: {
+ *         LastCharacter: "STRING_VALUE",
+ *       },
+ *       MaxSpeed: Number("double"),
+ *       Occupancy: Number("int"),
+ *     },
+ *     Truck: { // RouteMatrixTruckOptions
+ *       AxleCount: Number("int"),
+ *       GrossWeight: Number("long"),
+ *       HazardousCargos: [ // RouteMatrixHazardousCargoTypeList
+ *         "STRING_VALUE",
+ *       ],
+ *       Height: Number("long"),
+ *       KpraLength: Number("long"),
+ *       Length: Number("long"),
+ *       LicensePlate: {
+ *         LastCharacter: "STRING_VALUE",
+ *       },
+ *       MaxSpeed: Number("double"),
+ *       Occupancy: Number("int"),
+ *       PayloadCapacity: Number("long"),
+ *       Trailer: { // RouteMatrixTrailerOptions
+ *         TrailerCount: Number("int"),
+ *       },
+ *       TruckType: "STRING_VALUE",
+ *       TunnelRestrictionCode: "STRING_VALUE",
+ *       WeightPerAxle: Number("long"),
+ *       WeightPerAxleGroup: { // WeightPerAxleGroup
+ *         Single: Number("long"),
+ *         Tandem: Number("long"),
+ *         Triple: Number("long"),
+ *         Quad: Number("long"),
+ *         Quint: Number("long"),
+ *       },
+ *       Width: Number("long"),
+ *     },
+ *   },
+ * };
+ * const command = new CalculateRouteMatrixCommand(input);
+ * const response = await client.send(command);
+ * // { // CalculateRouteMatrixResponse
+ * //   ErrorCount: Number("int"), // required
+ * //   PricingBucket: "STRING_VALUE", // required
+ * //   RouteMatrix: [ // RouteMatrix // required
+ * //     [ // RouteMatrixRow
+ * //       { // RouteMatrixEntry
+ * //         Distance: Number("long"), // required
+ * //         Duration: Number("long"), // required
+ * //         Error: "STRING_VALUE",
+ * //       },
+ * //     ],
+ * //   ],
+ * //   RoutingBoundary: { // RouteMatrixBoundary
+ * //     Geometry: { // RouteMatrixBoundaryGeometry
+ * //       AutoCircle: { // RouteMatrixAutoCircle
+ * //         Margin: Number("long"),
+ * //         MaxRadius: Number("long"),
+ * //       },
+ * //       Circle: { // Circle
+ * //         Center: [ // Position // required
+ * //           Number("double"),
+ * //         ],
+ * //         Radius: Number("double"), // required
+ * //       },
+ * //       BoundingBox: [ // BoundingBox
+ * //         Number("double"),
+ * //       ],
+ * //       Polygon: [ // LinearRings
+ * //         [ // LinearRing
+ * //           [
+ * //             Number("double"),
+ * //           ],
+ * //         ],
+ * //       ],
+ * //     },
+ * //     Unbounded: true || false,
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param CalculateRouteMatrixCommandInput - {@link CalculateRouteMatrixCommandInput}
+ * @returns {@link CalculateRouteMatrixCommandOutput}
+ * @see {@link CalculateRouteMatrixCommandInput} for command's `input` shape.
+ * @see {@link CalculateRouteMatrixCommandOutput} 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 CalculateRouteMatrixCommand extends CalculateRouteMatrixCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: CalculateRouteMatrixRequest;
+            output: CalculateRouteMatrixResponse;
+        };
+        sdk: {
+            input: CalculateRouteMatrixCommandInput;
+            output: CalculateRouteMatrixCommandOutput;
+        };
+    };
+}