@aws-amplify/geo 1.2.5-unstable.8 → 1.2.5-unstable.9

package/dist/aws-amplify-geo.js

@@ -24843,6 +24843,1035 @@ function locateWindow() {
 }
 
 
+/***/ }),
+
+/***/ "../../node_modules/@turf/boolean-clockwise/dist/es/index.js":
+/*!******************************************************************************!*\
+  !*** /root/amplify-js/node_modules/@turf/boolean-clockwise/dist/es/index.js ***!
+  \******************************************************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return booleanClockwise; });
+/* harmony import */ var _turf_invariant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @turf/invariant */ "../../node_modules/@turf/invariant/dist/es/index.js");
+
+/**
+ * Takes a ring and return true or false whether or not the ring is clockwise or counter-clockwise.
+ *
+ * @name booleanClockwise
+ * @param {Feature<LineString>|LineString|Array<Array<number>>} line to be evaluated
+ * @returns {boolean} true/false
+ * @example
+ * var clockwiseRing = turf.lineString([[0,0],[1,1],[1,0],[0,0]]);
+ * var counterClockwiseRing = turf.lineString([[0,0],[1,0],[1,1],[0,0]]);
+ *
+ * turf.booleanClockwise(clockwiseRing)
+ * //=true
+ * turf.booleanClockwise(counterClockwiseRing)
+ * //=false
+ */
+function booleanClockwise(line) {
+    var ring = Object(_turf_invariant__WEBPACK_IMPORTED_MODULE_0__["getCoords"])(line);
+    var sum = 0;
+    var i = 1;
+    var prev;
+    var cur;
+    while (i < ring.length) {
+        prev = cur || ring[0];
+        cur = ring[i];
+        sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
+        i++;
+    }
+    return sum > 0;
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/@turf/helpers/dist/es/index.js":
+/*!********************************************************************!*\
+  !*** /root/amplify-js/node_modules/@turf/helpers/dist/es/index.js ***!
+  \********************************************************************/
+/*! exports provided: earthRadius, factors, unitsFactors, areaFactors, feature, geometry, point, points, polygon, polygons, lineString, lineStrings, featureCollection, multiLineString, multiPoint, multiPolygon, geometryCollection, round, radiansToLength, lengthToRadians, lengthToDegrees, bearingToAzimuth, radiansToDegrees, degreesToRadians, convertLength, convertArea, isNumber, isObject, validateBBox, validateId */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "earthRadius", function() { return earthRadius; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "factors", function() { return factors; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unitsFactors", function() { return unitsFactors; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "areaFactors", function() { return areaFactors; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "feature", function() { return feature; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "geometry", function() { return geometry; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "point", function() { return point; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "points", function() { return points; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polygon", function() { return polygon; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polygons", function() { return polygons; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lineString", function() { return lineString; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lineStrings", function() { return lineStrings; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "featureCollection", function() { return featureCollection; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiLineString", function() { return multiLineString; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiPoint", function() { return multiPoint; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiPolygon", function() { return multiPolygon; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "geometryCollection", function() { return geometryCollection; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "round", function() { return round; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "radiansToLength", function() { return radiansToLength; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lengthToRadians", function() { return lengthToRadians; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lengthToDegrees", function() { return lengthToDegrees; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bearingToAzimuth", function() { return bearingToAzimuth; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "radiansToDegrees", function() { return radiansToDegrees; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "degreesToRadians", function() { return degreesToRadians; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "convertLength", function() { return convertLength; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "convertArea", function() { return convertArea; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isNumber", function() { return isNumber; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isObject", function() { return isObject; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateBBox", function() { return validateBBox; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateId", function() { return validateId; });
+/**
+ * @module helpers
+ */
+/**
+ * Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
+ *
+ * @memberof helpers
+ * @type {number}
+ */
+var earthRadius = 6371008.8;
+/**
+ * Unit of measurement factors using a spherical (non-ellipsoid) earth radius.
+ *
+ * @memberof helpers
+ * @type {Object}
+ */
+var factors = {
+    centimeters: earthRadius * 100,
+    centimetres: earthRadius * 100,
+    degrees: earthRadius / 111325,
+    feet: earthRadius * 3.28084,
+    inches: earthRadius * 39.37,
+    kilometers: earthRadius / 1000,
+    kilometres: earthRadius / 1000,
+    meters: earthRadius,
+    metres: earthRadius,
+    miles: earthRadius / 1609.344,
+    millimeters: earthRadius * 1000,
+    millimetres: earthRadius * 1000,
+    nauticalmiles: earthRadius / 1852,
+    radians: 1,
+    yards: earthRadius * 1.0936,
+};
+/**
+ * Units of measurement factors based on 1 meter.
+ *
+ * @memberof helpers
+ * @type {Object}
+ */
+var unitsFactors = {
+    centimeters: 100,
+    centimetres: 100,
+    degrees: 1 / 111325,
+    feet: 3.28084,
+    inches: 39.37,
+    kilometers: 1 / 1000,
+    kilometres: 1 / 1000,
+    meters: 1,
+    metres: 1,
+    miles: 1 / 1609.344,
+    millimeters: 1000,
+    millimetres: 1000,
+    nauticalmiles: 1 / 1852,
+    radians: 1 / earthRadius,
+    yards: 1.0936133,
+};
+/**
+ * Area of measurement factors based on 1 square meter.
+ *
+ * @memberof helpers
+ * @type {Object}
+ */
+var areaFactors = {
+    acres: 0.000247105,
+    centimeters: 10000,
+    centimetres: 10000,
+    feet: 10.763910417,
+    hectares: 0.0001,
+    inches: 1550.003100006,
+    kilometers: 0.000001,
+    kilometres: 0.000001,
+    meters: 1,
+    metres: 1,
+    miles: 3.86e-7,
+    millimeters: 1000000,
+    millimetres: 1000000,
+    yards: 1.195990046,
+};
+/**
+ * Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
+ *
+ * @name feature
+ * @param {Geometry} geometry input geometry
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature} a GeoJSON Feature
+ * @example
+ * var geometry = {
+ *   "type": "Point",
+ *   "coordinates": [110, 50]
+ * };
+ *
+ * var feature = turf.feature(geometry);
+ *
+ * //=feature
+ */
+function feature(geom, properties, options) {
+    if (options === void 0) { options = {}; }
+    var feat = { type: "Feature" };
+    if (options.id === 0 || options.id) {
+        feat.id = options.id;
+    }
+    if (options.bbox) {
+        feat.bbox = options.bbox;
+    }
+    feat.properties = properties || {};
+    feat.geometry = geom;
+    return feat;
+}
+/**
+ * Creates a GeoJSON {@link Geometry} from a Geometry string type & coordinates.
+ * For GeometryCollection type use `helpers.geometryCollection`
+ *
+ * @name geometry
+ * @param {string} type Geometry Type
+ * @param {Array<any>} coordinates Coordinates
+ * @param {Object} [options={}] Optional Parameters
+ * @returns {Geometry} a GeoJSON Geometry
+ * @example
+ * var type = "Point";
+ * var coordinates = [110, 50];
+ * var geometry = turf.geometry(type, coordinates);
+ * // => geometry
+ */
+function geometry(type, coordinates, _options) {
+    if (_options === void 0) { _options = {}; }
+    switch (type) {
+        case "Point":
+            return point(coordinates).geometry;
+        case "LineString":
+            return lineString(coordinates).geometry;
+        case "Polygon":
+            return polygon(coordinates).geometry;
+        case "MultiPoint":
+            return multiPoint(coordinates).geometry;
+        case "MultiLineString":
+            return multiLineString(coordinates).geometry;
+        case "MultiPolygon":
+            return multiPolygon(coordinates).geometry;
+        default:
+            throw new Error(type + " is invalid");
+    }
+}
+/**
+ * Creates a {@link Point} {@link Feature} from a Position.
+ *
+ * @name point
+ * @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<Point>} a Point feature
+ * @example
+ * var point = turf.point([-75.343, 39.984]);
+ *
+ * //=point
+ */
+function point(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    if (!coordinates) {
+        throw new Error("coordinates is required");
+    }
+    if (!Array.isArray(coordinates)) {
+        throw new Error("coordinates must be an Array");
+    }
+    if (coordinates.length < 2) {
+        throw new Error("coordinates must be at least 2 numbers long");
+    }
+    if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+        throw new Error("coordinates must contain numbers");
+    }
+    var geom = {
+        type: "Point",
+        coordinates: coordinates,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Creates a {@link Point} {@link FeatureCollection} from an Array of Point coordinates.
+ *
+ * @name points
+ * @param {Array<Array<number>>} coordinates an array of Points
+ * @param {Object} [properties={}] Translate these properties to each Feature
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north]
+ * associated with the FeatureCollection
+ * @param {string|number} [options.id] Identifier associated with the FeatureCollection
+ * @returns {FeatureCollection<Point>} Point Feature
+ * @example
+ * var points = turf.points([
+ *   [-75, 39],
+ *   [-80, 45],
+ *   [-78, 50]
+ * ]);
+ *
+ * //=points
+ */
+function points(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    return featureCollection(coordinates.map(function (coords) {
+        return point(coords, properties);
+    }), options);
+}
+/**
+ * Creates a {@link Polygon} {@link Feature} from an Array of LinearRings.
+ *
+ * @name polygon
+ * @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<Polygon>} Polygon Feature
+ * @example
+ * var polygon = turf.polygon([[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]], { name: 'poly1' });
+ *
+ * //=polygon
+ */
+function polygon(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    for (var _i = 0, coordinates_1 = coordinates; _i < coordinates_1.length; _i++) {
+        var ring = coordinates_1[_i];
+        if (ring.length < 4) {
+            throw new Error("Each LinearRing of a Polygon must have 4 or more Positions.");
+        }
+        for (var j = 0; j < ring[ring.length - 1].length; j++) {
+            // Check if first point of Polygon contains two numbers
+            if (ring[ring.length - 1][j] !== ring[0][j]) {
+                throw new Error("First and last Position are not equivalent.");
+            }
+        }
+    }
+    var geom = {
+        type: "Polygon",
+        coordinates: coordinates,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Creates a {@link Polygon} {@link FeatureCollection} from an Array of Polygon coordinates.
+ *
+ * @name polygons
+ * @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygon coordinates
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the FeatureCollection
+ * @returns {FeatureCollection<Polygon>} Polygon FeatureCollection
+ * @example
+ * var polygons = turf.polygons([
+ *   [[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]],
+ *   [[[-15, 42], [-14, 46], [-12, 41], [-17, 44], [-15, 42]]],
+ * ]);
+ *
+ * //=polygons
+ */
+function polygons(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    return featureCollection(coordinates.map(function (coords) {
+        return polygon(coords, properties);
+    }), options);
+}
+/**
+ * Creates a {@link LineString} {@link Feature} from an Array of Positions.
+ *
+ * @name lineString
+ * @param {Array<Array<number>>} coordinates an array of Positions
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<LineString>} LineString Feature
+ * @example
+ * var linestring1 = turf.lineString([[-24, 63], [-23, 60], [-25, 65], [-20, 69]], {name: 'line 1'});
+ * var linestring2 = turf.lineString([[-14, 43], [-13, 40], [-15, 45], [-10, 49]], {name: 'line 2'});
+ *
+ * //=linestring1
+ * //=linestring2
+ */
+function lineString(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    if (coordinates.length < 2) {
+        throw new Error("coordinates must be an array of two or more positions");
+    }
+    var geom = {
+        type: "LineString",
+        coordinates: coordinates,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Creates a {@link LineString} {@link FeatureCollection} from an Array of LineString coordinates.
+ *
+ * @name lineStrings
+ * @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north]
+ * associated with the FeatureCollection
+ * @param {string|number} [options.id] Identifier associated with the FeatureCollection
+ * @returns {FeatureCollection<LineString>} LineString FeatureCollection
+ * @example
+ * var linestrings = turf.lineStrings([
+ *   [[-24, 63], [-23, 60], [-25, 65], [-20, 69]],
+ *   [[-14, 43], [-13, 40], [-15, 45], [-10, 49]]
+ * ]);
+ *
+ * //=linestrings
+ */
+function lineStrings(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    return featureCollection(coordinates.map(function (coords) {
+        return lineString(coords, properties);
+    }), options);
+}
+/**
+ * Takes one or more {@link Feature|Features} and creates a {@link FeatureCollection}.
+ *
+ * @name featureCollection
+ * @param {Feature[]} features input features
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {FeatureCollection} FeatureCollection of Features
+ * @example
+ * var locationA = turf.point([-75.343, 39.984], {name: 'Location A'});
+ * var locationB = turf.point([-75.833, 39.284], {name: 'Location B'});
+ * var locationC = turf.point([-75.534, 39.123], {name: 'Location C'});
+ *
+ * var collection = turf.featureCollection([
+ *   locationA,
+ *   locationB,
+ *   locationC
+ * ]);
+ *
+ * //=collection
+ */
+function featureCollection(features, options) {
+    if (options === void 0) { options = {}; }
+    var fc = { type: "FeatureCollection" };
+    if (options.id) {
+        fc.id = options.id;
+    }
+    if (options.bbox) {
+        fc.bbox = options.bbox;
+    }
+    fc.features = features;
+    return fc;
+}
+/**
+ * Creates a {@link Feature<MultiLineString>} based on a
+ * coordinate array. Properties can be added optionally.
+ *
+ * @name multiLineString
+ * @param {Array<Array<Array<number>>>} coordinates an array of LineStrings
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<MultiLineString>} a MultiLineString feature
+ * @throws {Error} if no coordinates are passed
+ * @example
+ * var multiLine = turf.multiLineString([[[0,0],[10,10]]]);
+ *
+ * //=multiLine
+ */
+function multiLineString(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    var geom = {
+        type: "MultiLineString",
+        coordinates: coordinates,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Creates a {@link Feature<MultiPoint>} based on a
+ * coordinate array. Properties can be added optionally.
+ *
+ * @name multiPoint
+ * @param {Array<Array<number>>} coordinates an array of Positions
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<MultiPoint>} a MultiPoint feature
+ * @throws {Error} if no coordinates are passed
+ * @example
+ * var multiPt = turf.multiPoint([[0,0],[10,10]]);
+ *
+ * //=multiPt
+ */
+function multiPoint(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    var geom = {
+        type: "MultiPoint",
+        coordinates: coordinates,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Creates a {@link Feature<MultiPolygon>} based on a
+ * coordinate array. Properties can be added optionally.
+ *
+ * @name multiPolygon
+ * @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygons
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<MultiPolygon>} a multipolygon feature
+ * @throws {Error} if no coordinates are passed
+ * @example
+ * var multiPoly = turf.multiPolygon([[[[0,0],[0,10],[10,10],[10,0],[0,0]]]]);
+ *
+ * //=multiPoly
+ *
+ */
+function multiPolygon(coordinates, properties, options) {
+    if (options === void 0) { options = {}; }
+    var geom = {
+        type: "MultiPolygon",
+        coordinates: coordinates,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Creates a {@link Feature<GeometryCollection>} based on a
+ * coordinate array. Properties can be added optionally.
+ *
+ * @name geometryCollection
+ * @param {Array<Geometry>} geometries an array of GeoJSON Geometries
+ * @param {Object} [properties={}] an Object of key-value pairs to add as properties
+ * @param {Object} [options={}] Optional Parameters
+ * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
+ * @param {string|number} [options.id] Identifier associated with the Feature
+ * @returns {Feature<GeometryCollection>} a GeoJSON GeometryCollection Feature
+ * @example
+ * var pt = turf.geometry("Point", [100, 0]);
+ * var line = turf.geometry("LineString", [[101, 0], [102, 1]]);
+ * var collection = turf.geometryCollection([pt, line]);
+ *
+ * // => collection
+ */
+function geometryCollection(geometries, properties, options) {
+    if (options === void 0) { options = {}; }
+    var geom = {
+        type: "GeometryCollection",
+        geometries: geometries,
+    };
+    return feature(geom, properties, options);
+}
+/**
+ * Round number to precision
+ *
+ * @param {number} num Number
+ * @param {number} [precision=0] Precision
+ * @returns {number} rounded number
+ * @example
+ * turf.round(120.4321)
+ * //=120
+ *
+ * turf.round(120.4321, 2)
+ * //=120.43
+ */
+function round(num, precision) {
+    if (precision === void 0) { precision = 0; }
+    if (precision && !(precision >= 0)) {
+        throw new Error("precision must be a positive number");
+    }
+    var multiplier = Math.pow(10, precision || 0);
+    return Math.round(num * multiplier) / multiplier;
+}
+/**
+ * Convert a distance measurement (assuming a spherical Earth) from radians to a more friendly unit.
+ * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
+ *
+ * @name radiansToLength
+ * @param {number} radians in radians across the sphere
+ * @param {string} [units="kilometers"] can be degrees, radians, miles, inches, yards, metres,
+ * meters, kilometres, kilometers.
+ * @returns {number} distance
+ */
+function radiansToLength(radians, units) {
+    if (units === void 0) { units = "kilometers"; }
+    var factor = factors[units];
+    if (!factor) {
+        throw new Error(units + " units is invalid");
+    }
+    return radians * factor;
+}
+/**
+ * Convert a distance measurement (assuming a spherical Earth) from a real-world unit into radians
+ * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
+ *
+ * @name lengthToRadians
+ * @param {number} distance in real units
+ * @param {string} [units="kilometers"] can be degrees, radians, miles, inches, yards, metres,
+ * meters, kilometres, kilometers.
+ * @returns {number} radians
+ */
+function lengthToRadians(distance, units) {
+    if (units === void 0) { units = "kilometers"; }
+    var factor = factors[units];
+    if (!factor) {
+        throw new Error(units + " units is invalid");
+    }
+    return distance / factor;
+}
+/**
+ * Convert a distance measurement (assuming a spherical Earth) from a real-world unit into degrees
+ * Valid units: miles, nauticalmiles, inches, yards, meters, metres, centimeters, kilometres, feet
+ *
+ * @name lengthToDegrees
+ * @param {number} distance in real units
+ * @param {string} [units="kilometers"] can be degrees, radians, miles, inches, yards, metres,
+ * meters, kilometres, kilometers.
+ * @returns {number} degrees
+ */
+function lengthToDegrees(distance, units) {
+    return radiansToDegrees(lengthToRadians(distance, units));
+}
+/**
+ * Converts any bearing angle from the north line direction (positive clockwise)
+ * and returns an angle between 0-360 degrees (positive clockwise), 0 being the north line
+ *
+ * @name bearingToAzimuth
+ * @param {number} bearing angle, between -180 and +180 degrees
+ * @returns {number} angle between 0 and 360 degrees
+ */
+function bearingToAzimuth(bearing) {
+    var angle = bearing % 360;
+    if (angle < 0) {
+        angle += 360;
+    }
+    return angle;
+}
+/**
+ * Converts an angle in radians to degrees
+ *
+ * @name radiansToDegrees
+ * @param {number} radians angle in radians
+ * @returns {number} degrees between 0 and 360 degrees
+ */
+function radiansToDegrees(radians) {
+    var degrees = radians % (2 * Math.PI);
+    return (degrees * 180) / Math.PI;
+}
+/**
+ * Converts an angle in degrees to radians
+ *
+ * @name degreesToRadians
+ * @param {number} degrees angle between 0 and 360 degrees
+ * @returns {number} angle in radians
+ */
+function degreesToRadians(degrees) {
+    var radians = degrees % 360;
+    return (radians * Math.PI) / 180;
+}
+/**
+ * Converts a length to the requested unit.
+ * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
+ *
+ * @param {number} length to be converted
+ * @param {Units} [originalUnit="kilometers"] of the length
+ * @param {Units} [finalUnit="kilometers"] returned unit
+ * @returns {number} the converted length
+ */
+function convertLength(length, originalUnit, finalUnit) {
+    if (originalUnit === void 0) { originalUnit = "kilometers"; }
+    if (finalUnit === void 0) { finalUnit = "kilometers"; }
+    if (!(length >= 0)) {
+        throw new Error("length must be a positive number");
+    }
+    return radiansToLength(lengthToRadians(length, originalUnit), finalUnit);
+}
+/**
+ * Converts a area to the requested unit.
+ * Valid units: kilometers, kilometres, meters, metres, centimetres, millimeters, acres, miles, yards, feet, inches, hectares
+ * @param {number} area to be converted
+ * @param {Units} [originalUnit="meters"] of the distance
+ * @param {Units} [finalUnit="kilometers"] returned unit
+ * @returns {number} the converted area
+ */
+function convertArea(area, originalUnit, finalUnit) {
+    if (originalUnit === void 0) { originalUnit = "meters"; }
+    if (finalUnit === void 0) { finalUnit = "kilometers"; }
+    if (!(area >= 0)) {
+        throw new Error("area must be a positive number");
+    }
+    var startFactor = areaFactors[originalUnit];
+    if (!startFactor) {
+        throw new Error("invalid original units");
+    }
+    var finalFactor = areaFactors[finalUnit];
+    if (!finalFactor) {
+        throw new Error("invalid final units");
+    }
+    return (area / startFactor) * finalFactor;
+}
+/**
+ * isNumber
+ *
+ * @param {*} num Number to validate
+ * @returns {boolean} true/false
+ * @example
+ * turf.isNumber(123)
+ * //=true
+ * turf.isNumber('foo')
+ * //=false
+ */
+function isNumber(num) {
+    return !isNaN(num) && num !== null && !Array.isArray(num);
+}
+/**
+ * isObject
+ *
+ * @param {*} input variable to validate
+ * @returns {boolean} true/false
+ * @example
+ * turf.isObject({elevation: 10})
+ * //=true
+ * turf.isObject('foo')
+ * //=false
+ */
+function isObject(input) {
+    return !!input && input.constructor === Object;
+}
+/**
+ * Validate BBox
+ *
+ * @private
+ * @param {Array<number>} bbox BBox to validate
+ * @returns {void}
+ * @throws Error if BBox is not valid
+ * @example
+ * validateBBox([-180, -40, 110, 50])
+ * //=OK
+ * validateBBox([-180, -40])
+ * //=Error
+ * validateBBox('Foo')
+ * //=Error
+ * validateBBox(5)
+ * //=Error
+ * validateBBox(null)
+ * //=Error
+ * validateBBox(undefined)
+ * //=Error
+ */
+function validateBBox(bbox) {
+    if (!bbox) {
+        throw new Error("bbox is required");
+    }
+    if (!Array.isArray(bbox)) {
+        throw new Error("bbox must be an Array");
+    }
+    if (bbox.length !== 4 && bbox.length !== 6) {
+        throw new Error("bbox must be an Array of 4 or 6 numbers");
+    }
+    bbox.forEach(function (num) {
+        if (!isNumber(num)) {
+            throw new Error("bbox must only contain numbers");
+        }
+    });
+}
+/**
+ * Validate Id
+ *
+ * @private
+ * @param {string|number} id Id to validate
+ * @returns {void}
+ * @throws Error if Id is not valid
+ * @example
+ * validateId([-180, -40, 110, 50])
+ * //=Error
+ * validateId([-180, -40])
+ * //=Error
+ * validateId('Foo')
+ * //=OK
+ * validateId(5)
+ * //=OK
+ * validateId(null)
+ * //=Error
+ * validateId(undefined)
+ * //=Error
+ */
+function validateId(id) {
+    if (!id) {
+        throw new Error("id is required");
+    }
+    if (["string", "number"].indexOf(typeof id) === -1) {
+        throw new Error("id must be a number or a string");
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/@turf/invariant/dist/es/index.js":
+/*!**********************************************************************!*\
+  !*** /root/amplify-js/node_modules/@turf/invariant/dist/es/index.js ***!
+  \**********************************************************************/
+/*! exports provided: getCoord, getCoords, containsNumber, geojsonType, featureOf, collectionOf, getGeom, getType */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getCoord", function() { return getCoord; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getCoords", function() { return getCoords; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "containsNumber", function() { return containsNumber; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "geojsonType", function() { return geojsonType; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "featureOf", function() { return featureOf; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "collectionOf", function() { return collectionOf; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getGeom", function() { return getGeom; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getType", function() { return getType; });
+/* harmony import */ var _turf_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @turf/helpers */ "../../node_modules/@turf/helpers/dist/es/index.js");
+
+/**
+ * Unwrap a coordinate from a Point Feature, Geometry or a single coordinate.
+ *
+ * @name getCoord
+ * @param {Array<number>|Geometry<Point>|Feature<Point>} coord GeoJSON Point or an Array of numbers
+ * @returns {Array<number>} coordinates
+ * @example
+ * var pt = turf.point([10, 10]);
+ *
+ * var coord = turf.getCoord(pt);
+ * //= [10, 10]
+ */
+function getCoord(coord) {
+    if (!coord) {
+        throw new Error("coord is required");
+    }
+    if (!Array.isArray(coord)) {
+        if (coord.type === "Feature" &&
+            coord.geometry !== null &&
+            coord.geometry.type === "Point") {
+            return coord.geometry.coordinates;
+        }
+        if (coord.type === "Point") {
+            return coord.coordinates;
+        }
+    }
+    if (Array.isArray(coord) &&
+        coord.length >= 2 &&
+        !Array.isArray(coord[0]) &&
+        !Array.isArray(coord[1])) {
+        return coord;
+    }
+    throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+/**
+ * Unwrap coordinates from a Feature, Geometry Object or an Array
+ *
+ * @name getCoords
+ * @param {Array<any>|Geometry|Feature} coords Feature, Geometry Object or an Array
+ * @returns {Array<any>} coordinates
+ * @example
+ * var poly = turf.polygon([[[119.32, -8.7], [119.55, -8.69], [119.51, -8.54], [119.32, -8.7]]]);
+ *
+ * var coords = turf.getCoords(poly);
+ * //= [[[119.32, -8.7], [119.55, -8.69], [119.51, -8.54], [119.32, -8.7]]]
+ */
+function getCoords(coords) {
+    if (Array.isArray(coords)) {
+        return coords;
+    }
+    // Feature
+    if (coords.type === "Feature") {
+        if (coords.geometry !== null) {
+            return coords.geometry.coordinates;
+        }
+    }
+    else {
+        // Geometry
+        if (coords.coordinates) {
+            return coords.coordinates;
+        }
+    }
+    throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array");
+}
+/**
+ * Checks if coordinates contains a number
+ *
+ * @name containsNumber
+ * @param {Array<any>} coordinates GeoJSON Coordinates
+ * @returns {boolean} true if Array contains a number
+ */
+function containsNumber(coordinates) {
+    if (coordinates.length > 1 &&
+        Object(_turf_helpers__WEBPACK_IMPORTED_MODULE_0__["isNumber"])(coordinates[0]) &&
+        Object(_turf_helpers__WEBPACK_IMPORTED_MODULE_0__["isNumber"])(coordinates[1])) {
+        return true;
+    }
+    if (Array.isArray(coordinates[0]) && coordinates[0].length) {
+        return containsNumber(coordinates[0]);
+    }
+    throw new Error("coordinates must only contain numbers");
+}
+/**
+ * Enforce expectations about types of GeoJSON objects for Turf.
+ *
+ * @name geojsonType
+ * @param {GeoJSON} value any GeoJSON object
+ * @param {string} type expected GeoJSON type
+ * @param {string} name name of calling function
+ * @throws {Error} if value is not the expected type.
+ */
+function geojsonType(value, type, name) {
+    if (!type || !name) {
+        throw new Error("type and name required");
+    }
+    if (!value || value.type !== type) {
+        throw new Error("Invalid input to " +
+            name +
+            ": must be a " +
+            type +
+            ", given " +
+            value.type);
+    }
+}
+/**
+ * Enforce expectations about types of {@link Feature} inputs for Turf.
+ * Internally this uses {@link geojsonType} to judge geometry types.
+ *
+ * @name featureOf
+ * @param {Feature} feature a feature with an expected geometry type
+ * @param {string} type expected GeoJSON type
+ * @param {string} name name of calling function
+ * @throws {Error} error if value is not the expected type.
+ */
+function featureOf(feature, type, name) {
+    if (!feature) {
+        throw new Error("No feature passed");
+    }
+    if (!name) {
+        throw new Error(".featureOf() requires a name");
+    }
+    if (!feature || feature.type !== "Feature" || !feature.geometry) {
+        throw new Error("Invalid input to " + name + ", Feature with geometry required");
+    }
+    if (!feature.geometry || feature.geometry.type !== type) {
+        throw new Error("Invalid input to " +
+            name +
+            ": must be a " +
+            type +
+            ", given " +
+            feature.geometry.type);
+    }
+}
+/**
+ * Enforce expectations about types of {@link FeatureCollection} inputs for Turf.
+ * Internally this uses {@link geojsonType} to judge geometry types.
+ *
+ * @name collectionOf
+ * @param {FeatureCollection} featureCollection a FeatureCollection for which features will be judged
+ * @param {string} type expected GeoJSON type
+ * @param {string} name name of calling function
+ * @throws {Error} if value is not the expected type.
+ */
+function collectionOf(featureCollection, type, name) {
+    if (!featureCollection) {
+        throw new Error("No featureCollection passed");
+    }
+    if (!name) {
+        throw new Error(".collectionOf() requires a name");
+    }
+    if (!featureCollection || featureCollection.type !== "FeatureCollection") {
+        throw new Error("Invalid input to " + name + ", FeatureCollection required");
+    }
+    for (var _i = 0, _a = featureCollection.features; _i < _a.length; _i++) {
+        var feature = _a[_i];
+        if (!feature || feature.type !== "Feature" || !feature.geometry) {
+            throw new Error("Invalid input to " + name + ", Feature with geometry required");
+        }
+        if (!feature.geometry || feature.geometry.type !== type) {
+            throw new Error("Invalid input to " +
+                name +
+                ": must be a " +
+                type +
+                ", given " +
+                feature.geometry.type);
+        }
+    }
+}
+/**
+ * Get Geometry from Feature or Geometry Object
+ *
+ * @param {Feature|Geometry} geojson GeoJSON Feature or Geometry Object
+ * @returns {Geometry|null} GeoJSON Geometry Object
+ * @throws {Error} if geojson is not a Feature or Geometry Object
+ * @example
+ * var point = {
+ *   "type": "Feature",
+ *   "properties": {},
+ *   "geometry": {
+ *     "type": "Point",
+ *     "coordinates": [110, 40]
+ *   }
+ * }
+ * var geom = turf.getGeom(point)
+ * //={"type": "Point", "coordinates": [110, 40]}
+ */
+function getGeom(geojson) {
+    if (geojson.type === "Feature") {
+        return geojson.geometry;
+    }
+    return geojson;
+}
+/**
+ * Get GeoJSON object's type, Geometry type is prioritize.
+ *
+ * @param {GeoJSON} geojson GeoJSON object
+ * @param {string} [name="geojson"] name of the variable to display in error message (unused)
+ * @returns {string} GeoJSON type
+ * @example
+ * var point = {
+ *   "type": "Feature",
+ *   "properties": {},
+ *   "geometry": {
+ *     "type": "Point",
+ *     "coordinates": [110, 40]
+ *   }
+ * }
+ * var geom = turf.getType(point)
+ * //="Point"
+ */
+function getType(geojson, _name) {
+    if (geojson.type === "FeatureCollection") {
+        return "FeatureCollection";
+    }
+    if (geojson.type === "GeometryCollection") {
+        return "GeometryCollection";
+    }
+    if (geojson.type === "Feature" && geojson.geometry !== null) {
+        return geojson.geometry.type;
+    }
+    return geojson.type;
+}
+
+
 /***/ }),
 
 /***/ "../../node_modules/base64-js/index.js":
@@ -27556,6 +28585,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _Providers_AmazonLocationServiceProvider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Providers/AmazonLocationServiceProvider */ "./lib-esm/Providers/AmazonLocationServiceProvider.js");
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./util */ "./lib-esm/util.js");
 var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function (resolve) {
@@ -27698,6 +28728,33 @@ var __generator = undefined && undefined.__generator || function (thisArg, body)
     };
   }
 };
+
+var __read = undefined && undefined.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
 /*
  * Copyright 2017-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
@@ -27714,6 +28771,7 @@ var __generator = undefined && undefined.__generator || function (thisArg, body)
 
 
 
+
 var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__["ConsoleLogger"]('Geo');
 var DEFAULT_PROVIDER = 'AmazonLocationService';
 
@@ -27823,25 +28881,213 @@ function () {
    */
 
 
-  GeoClass.prototype.getDefaultMap = function (provider) {
-    if (provider === void 0) {
-      provider = DEFAULT_PROVIDER;
-    }
+  GeoClass.prototype.getDefaultMap = function (provider) {
+    if (provider === void 0) {
+      provider = DEFAULT_PROVIDER;
+    }
+
+    var prov = this.getPluggable(provider);
+    return prov.getDefaultMap();
+  };
+  /**
+   * Search by text input with optional parameters
+   * @param  {string} text - The text string that is to be searched for
+   * @param  {SearchByTextOptions} options? - Optional parameters to the search
+   * @returns {Promise<Place[]>} - Promise resolves to a list of Places that match search parameters
+   */
+
+
+  GeoClass.prototype.searchByText = function (text, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, providerName, prov, error_1;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            _a = (options || {}).providerName, providerName = _a === void 0 ? DEFAULT_PROVIDER : _a;
+            prov = this.getPluggable(providerName);
+            _b.label = 1;
+
+          case 1:
+            _b.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , prov.searchByText(text, options)];
+
+          case 2:
+            return [2
+            /*return*/
+            , _b.sent()];
+
+          case 3:
+            error_1 = _b.sent();
+            logger.debug(error_1);
+            throw error_1;
+
+          case 4:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+  /**
+   * Reverse geocoding search via a coordinate point on the map
+   * @param coordinates - Coordinates array for the search input
+   * @param options - Options parameters for the search
+   * @returns {Promise<Place>} - Promise that resolves to a place matching search coordinates
+   */
+
+
+  GeoClass.prototype.searchByCoordinates = function (coordinates, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, providerName, prov, _b, lng, lat, error_2;
+
+      return __generator(this, function (_c) {
+        switch (_c.label) {
+          case 0:
+            _a = (options || {}).providerName, providerName = _a === void 0 ? DEFAULT_PROVIDER : _a;
+            prov = this.getPluggable(providerName);
+            _b = __read(coordinates, 2), lng = _b[0], lat = _b[1];
+            _c.label = 1;
+
+          case 1:
+            _c.trys.push([1, 3,, 4]);
+
+            Object(_util__WEBPACK_IMPORTED_MODULE_2__["validateCoordinates"])(lng, lat);
+            return [4
+            /*yield*/
+            , prov.searchByCoordinates(coordinates, options)];
+
+          case 2:
+            return [2
+            /*return*/
+            , _c.sent()];
+
+          case 3:
+            error_2 = _c.sent();
+            logger.debug(error_2);
+            throw error_2;
+
+          case 4:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+  /**
+   * Create geofences
+   * @param geofences - Single or array of geofence objects to create
+   * @param options? - Optional parameters for creating geofences
+   * @returns {Promise<SaveGeofencesResults>} - Promise that resolves to an object with:
+   *   successes: list of geofences successfully created
+   *   errors: list of geofences that failed to create
+   */
+
+
+  GeoClass.prototype.saveGeofences = function (geofences, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, providerName, prov, geofenceInputArray, error_3;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            _a = (options || {}).providerName, providerName = _a === void 0 ? DEFAULT_PROVIDER : _a;
+            prov = this.getPluggable(providerName);
+
+            if (!Array.isArray(geofences)) {
+              geofenceInputArray = [geofences];
+            } else {
+              geofenceInputArray = geofences;
+            }
+
+            _b.label = 1;
+
+          case 1:
+            _b.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , prov.saveGeofences(geofenceInputArray, options)];
+
+          case 2:
+            return [2
+            /*return*/
+            , _b.sent()];
+
+          case 3:
+            error_3 = _b.sent();
+            logger.debug(error_3);
+            throw error_3;
+
+          case 4:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+  /**
+   * Get a single geofence by geofenceId
+   * @param geofenceId: GeofenceId - The string id of the geofence to get
+   * @param options?: GeofenceOptions - Optional parameters for getting a geofence
+   * @returns Promise<Geofence> - Promise that resolves to a geofence object
+   */
+
+
+  GeoClass.prototype.getGeofence = function (geofenceId, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, providerName, prov, error_4;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            _a = (options || {}).providerName, providerName = _a === void 0 ? DEFAULT_PROVIDER : _a;
+            prov = this.getPluggable(providerName);
+            _b.label = 1;
+
+          case 1:
+            _b.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , prov.getGeofence(geofenceId, options)];
 
-    var prov = this.getPluggable(provider);
-    return prov.getDefaultMap();
+          case 2:
+            return [2
+            /*return*/
+            , _b.sent()];
+
+          case 3:
+            error_4 = _b.sent();
+            logger.debug(error_4);
+            throw error_4;
+
+          case 4:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
   };
   /**
-   * Search by text input with optional parameters
-   * @param  {string} text - The text string that is to be searched for
-   * @param  {SearchByTextOptions} options? - Optional parameters to the search
-   * @returns {Promise<Place[]>} - Promise resolves to a list of Places that match search parameters
+   * List geofences
+   * @param  options?: ListGeofenceOptions
+   * @returns {Promise<ListGeofencesResults>} - Promise that resolves to an object with:
+   *   entries: list of geofences - 100 geofences are listed per page
+   *   nextToken: token for next page of geofences
    */
 
 
-  GeoClass.prototype.searchByText = function (text, options) {
+  GeoClass.prototype.listGeofences = function (options) {
     return __awaiter(this, void 0, void 0, function () {
-      var _a, providerName, prov, error_1;
+      var _a, providerName, prov, error_5;
 
       return __generator(this, function (_b) {
         switch (_b.label) {
@@ -27855,7 +29101,7 @@ function () {
 
             return [4
             /*yield*/
-            , prov.searchByText(text, options)];
+            , prov.listGeofences(options)];
 
           case 2:
             return [2
@@ -27863,9 +29109,9 @@ function () {
             , _b.sent()];
 
           case 3:
-            error_1 = _b.sent();
-            logger.debug(error_1);
-            throw error_1;
+            error_5 = _b.sent();
+            logger.debug(error_5);
+            throw error_5;
 
           case 4:
             return [2
@@ -27876,22 +29122,31 @@ function () {
     });
   };
   /**
-   * Reverse geocoding search via a coordinate point on the map
-   * @param coordinates - Coordinates array for the search input
-   * @param options - Options parameters for the search
-   * @returns {Promise<Place>} - Promise that resolves to a place matching search coordinates
+   * Delete geofences
+   * @param geofenceIds: string|string[]
+   * @param options?: GeofenceOptions
+   * @returns {Promise<DeleteGeofencesResults>} - Promise that resolves to an object with:
+   *  successes: list of geofences successfully deleted
+   *  errors: list of geofences that failed to delete
    */
 
 
-  GeoClass.prototype.searchByCoordinates = function (coordinates, options) {
+  GeoClass.prototype.deleteGeofences = function (geofenceIds, options) {
     return __awaiter(this, void 0, void 0, function () {
-      var _a, providerName, prov, error_2;
+      var _a, providerName, prov, geofenceIdsInputArray, error_6;
 
       return __generator(this, function (_b) {
         switch (_b.label) {
           case 0:
             _a = (options || {}).providerName, providerName = _a === void 0 ? DEFAULT_PROVIDER : _a;
             prov = this.getPluggable(providerName);
+
+            if (!Array.isArray(geofenceIds)) {
+              geofenceIdsInputArray = [geofenceIds];
+            } else {
+              geofenceIdsInputArray = geofenceIds;
+            }
+
             _b.label = 1;
 
           case 1:
@@ -27899,7 +29154,7 @@ function () {
 
             return [4
             /*yield*/
-            , prov.searchByCoordinates(coordinates, options)];
+            , prov.deleteGeofences(geofenceIdsInputArray, options)];
 
           case 2:
             return [2
@@ -27907,9 +29162,9 @@ function () {
             , _b.sent()];
 
           case 3:
-            error_2 = _b.sent();
-            logger.debug(error_2);
-            throw error_2;
+            error_6 = _b.sent();
+            logger.debug(error_6);
+            throw error_6;
 
           case 4:
             return [2
@@ -27945,6 +29200,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__);
 /* harmony import */ var _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @aws-sdk/client-location */ "../../node_modules/@aws-sdk/client-location/dist-es/index.js");
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../util */ "./lib-esm/util.js");
 var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function (resolve) {
@@ -28087,6 +29343,41 @@ var __generator = undefined && undefined.__generator || function (thisArg, body)
     };
   }
 };
+
+var __read = undefined && undefined.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+
+var __spread = undefined && undefined.__spread || function () {
+  for (var ar = [], i = 0; i < arguments.length; i++) {
+    ar = ar.concat(__read(arguments[i]));
+  }
+
+  return ar;
+};
 /*
  * Copyright 2017-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
@@ -28104,6 +29395,7 @@ var __generator = undefined && undefined.__generator || function (thisArg, body)
 
 
 
+
 var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["ConsoleLogger"]('AmazonLocationServiceProvider');
 
 var AmazonLocationServiceProvider =
@@ -28251,7 +29543,309 @@ function () {
               region: this._config.region,
               customUserAgent: Object(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["getAmplifyUserAgent"])()
             });
-            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["SearchPlaceIndexForTextCommand"](locationServiceInput);
+            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["SearchPlaceIndexForTextCommand"](locationServiceInput);
+            _a.label = 2;
+
+          case 2:
+            _a.trys.push([2, 4,, 5]);
+
+            return [4
+            /*yield*/
+            , client.send(command)];
+
+          case 3:
+            response = _a.sent();
+            return [3
+            /*break*/
+            , 5];
+
+          case 4:
+            error_1 = _a.sent();
+            logger.debug(error_1);
+            throw error_1;
+
+          case 5:
+            PascalResults = response.Results.map(function (result) {
+              return result.Place;
+            });
+            results = camelcase_keys__WEBPACK_IMPORTED_MODULE_0___default()(PascalResults, {
+              deep: true
+            });
+            return [2
+            /*return*/
+            , results];
+        }
+      });
+    });
+  };
+  /**
+   * Reverse geocoding search via a coordinate point on the map
+   * @param coordinates - Coordinates array for the search input
+   * @param options - Options parameters for the search
+   * @returns {Promise<Place>} - Promise that resolves to a place matching search coordinates
+   */
+
+
+  AmazonLocationServiceProvider.prototype.searchByCoordinates = function (coordinates, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var credentialsOK, locationServiceInput, client, command, response, error_2, PascalResults, results;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this._ensureCredentials()];
+
+          case 1:
+            credentialsOK = _a.sent();
+
+            if (!credentialsOK) {
+              throw new Error('No credentials');
+            }
+
+            this._verifySearchIndex(options === null || options === void 0 ? void 0 : options.searchIndexName);
+
+            locationServiceInput = {
+              Position: coordinates,
+              IndexName: this._config.search_indices["default"]
+            };
+
+            if (options) {
+              if (options.searchIndexName) {
+                locationServiceInput.IndexName = options.searchIndexName;
+              }
+
+              locationServiceInput.MaxResults = options.maxResults;
+            }
+
+            client = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["LocationClient"]({
+              credentials: this._config.credentials,
+              region: this._config.region,
+              customUserAgent: Object(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["getAmplifyUserAgent"])()
+            });
+            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["SearchPlaceIndexForPositionCommand"](locationServiceInput);
+            _a.label = 2;
+
+          case 2:
+            _a.trys.push([2, 4,, 5]);
+
+            return [4
+            /*yield*/
+            , client.send(command)];
+
+          case 3:
+            response = _a.sent();
+            return [3
+            /*break*/
+            , 5];
+
+          case 4:
+            error_2 = _a.sent();
+            logger.debug(error_2);
+            throw error_2;
+
+          case 5:
+            PascalResults = response.Results.map(function (result) {
+              return result.Place;
+            });
+            results = camelcase_keys__WEBPACK_IMPORTED_MODULE_0___default()(PascalResults[0], {
+              deep: true
+            });
+            return [2
+            /*return*/
+            , results];
+        }
+      });
+    });
+  };
+  /**
+   * Create geofences inside of a geofence collection
+   * @param geofences - Array of geofence objects to create
+   * @param options? - Optional parameters for creating geofences
+   * @returns {Promise<AmazonLocationServiceSaveGeofencesResults>} - Promise that resolves to an object with:
+   *   successes: list of geofences successfully created
+   *   errors: list of geofences that failed to create
+   */
+
+
+  AmazonLocationServiceProvider.prototype.saveGeofences = function (geofences, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var credentialsOK, PascalGeofences, results, geofenceBatches, apiLimit;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (geofences.length < 1) {
+              throw new Error('Geofence input array is empty');
+            }
+
+            return [4
+            /*yield*/
+            , this._ensureCredentials()];
+
+          case 1:
+            credentialsOK = _a.sent();
+
+            if (!credentialsOK) {
+              throw new Error('No credentials');
+            } // Verify geofence collection exists in aws-config.js
+
+
+            try {
+              this._verifyGeofenceCollections(options === null || options === void 0 ? void 0 : options.collectionName);
+            } catch (error) {
+              logger.debug(error);
+              throw error;
+            }
+
+            Object(_util__WEBPACK_IMPORTED_MODULE_3__["validateGeofencesInput"])(geofences);
+            PascalGeofences = geofences.map(function (_a) {
+              var geofenceId = _a.geofenceId,
+                  polygon = _a.geometry.polygon;
+              return {
+                GeofenceId: geofenceId,
+                Geometry: {
+                  Polygon: polygon
+                }
+              };
+            });
+            results = {
+              successes: [],
+              errors: []
+            };
+            geofenceBatches = [];
+
+            while (PascalGeofences.length > 0) {
+              apiLimit = 10;
+              geofenceBatches.push(PascalGeofences.splice(0, apiLimit));
+            }
+
+            return [4
+            /*yield*/
+            , Promise.all(geofenceBatches.map(function (batch) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var response, error_3;
+                return __generator(this, function (_a) {
+                  switch (_a.label) {
+                    case 0:
+                      _a.trys.push([0, 2,, 3]);
+
+                      return [4
+                      /*yield*/
+                      , this._AmazonLocationServiceBatchPutGeofenceCall(batch, (options === null || options === void 0 ? void 0 : options.collectionName) || this._config.geofenceCollections["default"])];
+
+                    case 1:
+                      response = _a.sent();
+                      return [3
+                      /*break*/
+                      , 3];
+
+                    case 2:
+                      error_3 = _a.sent(); // If the API call fails, add the geofences to the errors array and move to next batch
+
+                      batch.forEach(function (geofence) {
+                        results.errors.push({
+                          geofenceId: geofence.GeofenceId,
+                          error: {
+                            code: 'APIConnectionError',
+                            message: error_3.message
+                          }
+                        });
+                      });
+                      return [2
+                      /*return*/
+                      ];
+
+                    case 3:
+                      // Push all successes to results
+                      response.Successes.forEach(function (success) {
+                        var GeofenceId = success.GeofenceId,
+                            CreateTime = success.CreateTime,
+                            UpdateTime = success.UpdateTime;
+                        results.successes.push({
+                          geofenceId: GeofenceId,
+                          createTime: CreateTime,
+                          updateTime: UpdateTime
+                        });
+                      }); // Push all errors to results
+
+                      response.Errors.forEach(function (error) {
+                        var _a = error.Error,
+                            Code = _a.Code,
+                            Message = _a.Message,
+                            GeofenceId = error.GeofenceId;
+                        results.errors.push({
+                          error: {
+                            code: Code,
+                            message: Message
+                          },
+                          geofenceId: GeofenceId
+                        });
+                      });
+                      return [2
+                      /*return*/
+                      ];
+                  }
+                });
+              });
+            }))];
+
+          case 2:
+            _a.sent();
+
+            return [2
+            /*return*/
+            , results];
+        }
+      });
+    });
+  };
+  /**
+   * Get geofence from a geofence collection
+   * @param geofenceId:string
+   * @param options?: Optional parameters for getGeofence
+   * @returns {Promise<AmazonLocationServiceGeofence>} - Promise that resolves to a geofence object
+   */
+
+
+  AmazonLocationServiceProvider.prototype.getGeofence = function (geofenceId, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var credentialsOK, client, commandInput, command, response, error_4, GeofenceId, CreateTime, UpdateTime, Status, Geometry, geofence;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this._ensureCredentials()];
+
+          case 1:
+            credentialsOK = _a.sent();
+
+            if (!credentialsOK) {
+              throw new Error('No credentials');
+            } // Verify geofence collection exists in aws-config.js
+
+
+            try {
+              this._verifyGeofenceCollections(options === null || options === void 0 ? void 0 : options.collectionName);
+            } catch (error) {
+              logger.debug(error);
+              throw error;
+            }
+
+            Object(_util__WEBPACK_IMPORTED_MODULE_3__["validateGeofenceId"])(geofenceId);
+            client = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["LocationClient"]({
+              credentials: this._config.credentials,
+              region: this._config.region,
+              customUserAgent: Object(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["getAmplifyUserAgent"])()
+            });
+            commandInput = {
+              GeofenceId: geofenceId,
+              CollectionName: (options === null || options === void 0 ? void 0 : options.collectionName) || this._config.geofenceCollections["default"]
+            };
+            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["GetGeofenceCommand"](commandInput);
             _a.label = 2;
 
           case 2:
@@ -28268,35 +29862,40 @@ function () {
             , 5];
 
           case 4:
-            error_1 = _a.sent();
-            logger.debug(error_1);
-            throw error_1;
+            error_4 = _a.sent();
+            logger.debug(error_4);
+            throw error_4;
 
           case 5:
-            PascalResults = response.Results.map(function (result) {
-              return result.Place;
-            });
-            results = camelcase_keys__WEBPACK_IMPORTED_MODULE_0___default()(PascalResults, {
-              deep: true
-            });
+            GeofenceId = response.GeofenceId, CreateTime = response.CreateTime, UpdateTime = response.UpdateTime, Status = response.Status, Geometry = response.Geometry;
+            geofence = {
+              createTime: CreateTime,
+              geofenceId: GeofenceId,
+              geometry: {
+                polygon: Geometry.Polygon
+              },
+              status: Status,
+              updateTime: UpdateTime
+            };
             return [2
             /*return*/
-            , results];
+            , geofence];
         }
       });
     });
   };
   /**
-   * Reverse geocoding search via a coordinate point on the map
-   * @param coordinates - Coordinates array for the search input
-   * @param options - Options parameters for the search
-   * @returns {Promise<Place>} - Promise that resolves to a place matching search coordinates
+   * List geofences from a geofence collection
+   * @param  options?: ListGeofenceOptions
+   * @returns {Promise<ListGeofencesResults>} - Promise that resolves to an object with:
+   *   entries: list of geofences - 100 geofences are listed per page
+   *   nextToken: token for next page of geofences
    */
 
 
-  AmazonLocationServiceProvider.prototype.searchByCoordinates = function (coordinates, options) {
+  AmazonLocationServiceProvider.prototype.listGeofences = function (options) {
     return __awaiter(this, void 0, void 0, function () {
-      var credentialsOK, locationServiceInput, client, command, response, error_2, PascalResults, results;
+      var credentialsOK, client, listGeofencesInput, command, response, error_5, NextToken, Entries, results;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
@@ -28309,21 +29908,14 @@ function () {
 
             if (!credentialsOK) {
               throw new Error('No credentials');
-            }
-
-            this._verifySearchIndex(options === null || options === void 0 ? void 0 : options.searchIndexName);
-
-            locationServiceInput = {
-              Position: coordinates,
-              IndexName: this._config.search_indices["default"]
-            };
+            } // Verify geofence collection exists in aws-config.js
 
-            if (options) {
-              if (options.searchIndexName) {
-                locationServiceInput.IndexName = options.searchIndexName;
-              }
 
-              locationServiceInput.MaxResults = options.maxResults;
+            try {
+              this._verifyGeofenceCollections(options === null || options === void 0 ? void 0 : options.collectionName);
+            } catch (error) {
+              logger.debug(error);
+              throw error;
             }
 
             client = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["LocationClient"]({
@@ -28331,7 +29923,11 @@ function () {
               region: this._config.region,
               customUserAgent: Object(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["getAmplifyUserAgent"])()
             });
-            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["SearchPlaceIndexForPositionCommand"](locationServiceInput);
+            listGeofencesInput = {
+              NextToken: options === null || options === void 0 ? void 0 : options.nextToken,
+              CollectionName: (options === null || options === void 0 ? void 0 : options.collectionName) || this._config.geofenceCollections["default"]
+            };
+            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["ListGeofencesCommand"](listGeofencesInput);
             _a.label = 2;
 
           case 2:
@@ -28348,17 +29944,158 @@ function () {
             , 5];
 
           case 4:
-            error_2 = _a.sent();
-            logger.debug(error_2);
-            throw error_2;
+            error_5 = _a.sent();
+            logger.debug(error_5);
+            throw error_5;
 
           case 5:
-            PascalResults = response.Results.map(function (result) {
-              return result.Place;
-            });
-            results = camelcase_keys__WEBPACK_IMPORTED_MODULE_0___default()(PascalResults[0], {
-              deep: true
+            NextToken = response.NextToken, Entries = response.Entries;
+            results = {
+              entries: Entries.map(function (_a) {
+                var GeofenceId = _a.GeofenceId,
+                    CreateTime = _a.CreateTime,
+                    UpdateTime = _a.UpdateTime,
+                    Status = _a.Status,
+                    Polygon = _a.Geometry.Polygon;
+                return {
+                  geofenceId: GeofenceId,
+                  createTime: CreateTime,
+                  updateTime: UpdateTime,
+                  status: Status,
+                  geometry: {
+                    polygon: Polygon
+                  }
+                };
+              }),
+              nextToken: NextToken
+            };
+            return [2
+            /*return*/
+            , results];
+        }
+      });
+    });
+  };
+  /**
+   * Delete geofences from a geofence collection
+   * @param geofenceIds: string|string[]
+   * @param options?: GeofenceOptions
+   * @returns {Promise<DeleteGeofencesResults>} - Promise that resolves to an object with:
+   *  successes: list of geofences successfully deleted
+   *  errors: list of geofences that failed to delete
+   */
+
+
+  AmazonLocationServiceProvider.prototype.deleteGeofences = function (geofenceIds, options) {
+    return __awaiter(this, void 0, void 0, function () {
+      var credentialsOK, badGeofenceIds, results, geofenceIdBatches, count;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (geofenceIds.length < 1) {
+              throw new Error('GeofenceId input array is empty');
+            }
+
+            return [4
+            /*yield*/
+            , this._ensureCredentials()];
+
+          case 1:
+            credentialsOK = _a.sent();
+
+            if (!credentialsOK) {
+              throw new Error('No credentials');
+            }
+
+            this._verifyGeofenceCollections(options === null || options === void 0 ? void 0 : options.collectionName);
+
+            badGeofenceIds = geofenceIds.filter(function (geofenceId) {
+              try {
+                Object(_util__WEBPACK_IMPORTED_MODULE_3__["validateGeofenceId"])(geofenceId);
+              } catch (error) {
+                return true;
+              }
             });
+
+            if (badGeofenceIds.length > 0) {
+              throw new Error("Invalid geofence ids: " + badGeofenceIds.join(', '));
+            }
+
+            results = {
+              successes: [],
+              errors: []
+            };
+            geofenceIdBatches = [];
+            count = 0;
+
+            while (count < geofenceIds.length) {
+              geofenceIdBatches.push(geofenceIds.slice(count, count += 10));
+            }
+
+            return [4
+            /*yield*/
+            , Promise.all(geofenceIdBatches.map(function (batch) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var response, error_6, badGeofenceIds;
+
+                var _a;
+
+                return __generator(this, function (_b) {
+                  switch (_b.label) {
+                    case 0:
+                      _b.trys.push([0, 2,, 3]);
+
+                      return [4
+                      /*yield*/
+                      , this._AmazonLocationServiceBatchDeleteGeofenceCall(batch, (options === null || options === void 0 ? void 0 : options.collectionName) || this._config.geofenceCollections["default"])];
+
+                    case 1:
+                      response = _b.sent();
+                      return [3
+                      /*break*/
+                      , 3];
+
+                    case 2:
+                      error_6 = _b.sent(); // If the API call fails, add the geofences to the errors array and move to next batch
+
+                      batch.forEach(function (geofenceId) {
+                        var errorObject = {
+                          geofenceId: geofenceId,
+                          error: {
+                            code: error_6.message,
+                            message: error_6.message
+                          }
+                        };
+                        results.errors.push(errorObject);
+                      });
+                      return [2
+                      /*return*/
+                      ];
+
+                    case 3:
+                      badGeofenceIds = response.Errors.map(function (_a) {
+                        var geofenceId = _a.geofenceId;
+                        return geofenceId;
+                      });
+
+                      (_a = results.successes).push.apply(_a, __spread(batch.filter(function (Id) {
+                        return !badGeofenceIds.includes(Id);
+                      })));
+
+                      return [2
+                      /*return*/
+                      ];
+                  }
+                });
+              });
+            }))];
+
+          case 2:
+            _a.sent();
+
             return [2
             /*return*/
             , results];
@@ -28373,7 +30110,7 @@ function () {
 
   AmazonLocationServiceProvider.prototype._ensureCredentials = function () {
     return __awaiter(this, void 0, void 0, function () {
-      var credentials, cred, error_3;
+      var credentials, cred, error_7;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
@@ -28396,8 +30133,8 @@ function () {
             , true];
 
           case 2:
-            error_3 = _a.sent();
-            logger.warn('Ensure credentials error. Credentials are:', error_3);
+            error_7 = _a.sent();
+            logger.debug('Ensure credentials error. Credentials are:', error_7);
             return [2
             /*return*/
             , false];
@@ -28413,26 +30150,122 @@ function () {
 
   AmazonLocationServiceProvider.prototype._verifyMapResources = function () {
     if (!this._config.maps) {
-      var errorString = "No map resources found in amplify config, run 'amplify add geo' to create them and run `amplify push` after";
-      logger.warn(errorString);
+      var errorString = "No map resources found in amplify config, run 'amplify add geo' to create one and run `amplify push` after";
+      logger.debug(errorString);
       throw new Error(errorString);
     }
 
     if (!this._config.maps["default"]) {
       var errorString = "No default map resource found in amplify config, run 'amplify add geo' to create one and run `amplify push` after";
-      logger.warn(errorString);
+      logger.debug(errorString);
       throw new Error(errorString);
     }
   };
 
   AmazonLocationServiceProvider.prototype._verifySearchIndex = function (optionalSearchIndex) {
     if ((!this._config.search_indices || !this._config.search_indices["default"]) && !optionalSearchIndex) {
-      var errorString = 'No Search Index found, please run `amplify add geo` to add one and run `amplify push` after.';
-      logger.warn(errorString);
+      var errorString = 'No Search Index found in amplify config, please run `amplify add geo` to create one and run `amplify push` after.';
+      logger.debug(errorString);
+      throw new Error(errorString);
+    }
+  };
+
+  AmazonLocationServiceProvider.prototype._verifyGeofenceCollections = function (optionalGeofenceCollectionName) {
+    if ((!this._config.geofenceCollections || !this._config.geofenceCollections["default"]) && !optionalGeofenceCollectionName) {
+      var errorString = 'No Geofence Collections found, please run `amplify add geo` to create one and run `amplify push` after.';
+      logger.debug(errorString);
       throw new Error(errorString);
     }
   };
 
+  AmazonLocationServiceProvider.prototype._AmazonLocationServiceBatchPutGeofenceCall = function (PascalGeofences, collectionName) {
+    return __awaiter(this, void 0, void 0, function () {
+      var geofenceInput, client, command, response, error_8;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            geofenceInput = {
+              Entries: PascalGeofences,
+              CollectionName: collectionName || this._config.geofenceCollections["default"]
+            };
+            client = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["LocationClient"]({
+              credentials: this._config.credentials,
+              region: this._config.region,
+              customUserAgent: Object(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["getAmplifyUserAgent"])()
+            });
+            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["BatchPutGeofenceCommand"](geofenceInput);
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , client.send(command)];
+
+          case 2:
+            response = _a.sent();
+            return [3
+            /*break*/
+            , 4];
+
+          case 3:
+            error_8 = _a.sent();
+            throw error_8;
+
+          case 4:
+            return [2
+            /*return*/
+            , response];
+        }
+      });
+    });
+  };
+
+  AmazonLocationServiceProvider.prototype._AmazonLocationServiceBatchDeleteGeofenceCall = function (geofenceIds, collectionName) {
+    return __awaiter(this, void 0, void 0, function () {
+      var deleteGeofencesInput, client, command, response, error_9;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            deleteGeofencesInput = {
+              GeofenceIds: geofenceIds,
+              CollectionName: collectionName || this._config.geofenceCollections["default"]
+            };
+            client = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["LocationClient"]({
+              credentials: this._config.credentials,
+              region: this._config.region,
+              customUserAgent: Object(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["getAmplifyUserAgent"])()
+            });
+            command = new _aws_sdk_client_location__WEBPACK_IMPORTED_MODULE_2__["BatchDeleteGeofenceCommand"](deleteGeofencesInput);
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , client.send(command)];
+
+          case 2:
+            response = _a.sent();
+            return [3
+            /*break*/
+            , 4];
+
+          case 3:
+            error_9 = _a.sent();
+            throw error_9;
+
+          case 4:
+            return [2
+            /*return*/
+            , response];
+        }
+      });
+    });
+  };
+
   AmazonLocationServiceProvider.CATEGORY = 'Geo';
   AmazonLocationServiceProvider.PROVIDER_NAME = 'AmazonLocationService';
   return AmazonLocationServiceProvider;
@@ -28456,6 +30289,197 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/***/ }),
+
+/***/ "./lib-esm/util.js":
+/*!*************************!*\
+  !*** ./lib-esm/util.js ***!
+  \*************************/
+/*! exports provided: validateCoordinates, validateGeofenceId, validateLinearRing, validatePolygon, validateGeofencesInput */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateCoordinates", function() { return validateCoordinates; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateGeofenceId", function() { return validateGeofenceId; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateLinearRing", function() { return validateLinearRing; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validatePolygon", function() { return validatePolygon; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateGeofencesInput", function() { return validateGeofencesInput; });
+/* harmony import */ var _turf_boolean_clockwise__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @turf/boolean-clockwise */ "../../node_modules/@turf/boolean-clockwise/dist/es/index.js");
+var __read = undefined && undefined.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+      r,
+      ar = [],
+      e;
+
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
+      ar.push(r.value);
+    }
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+
+  return ar;
+};
+/*
+ * Copyright 2017-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+
+
+function validateCoordinates(lng, lat) {
+  if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
+    throw new Error("Invalid coordinates: [" + lng + "," + lat + "]");
+  }
+
+  if (lat < -90 || 90 < lat) {
+    throw new Error('Latitude must be between -90 and 90 degrees inclusive.');
+  } else if (lng < -180 || 180 < lng) {
+    throw new Error('Longitude must be between -180 and 180 degrees inclusive.');
+  }
+}
+function validateGeofenceId(geofenceId) {
+  var geofenceIdRegex = /^(?:[\x2D\.0-9A-Z_a-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDF70-\uDF81\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF30-\uDF3B\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF2\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDE70-\uDEBE\uDEC0-\uDEC9\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE96\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])+$/i; // Check if geofenceId is valid
+
+  if (!geofenceIdRegex.test(geofenceId)) {
+    throw new Error("Invalid geofenceId: '" + geofenceId + "' - IDs can only contain alphanumeric characters, hyphens, underscores and periods.");
+  }
+}
+function validateLinearRing(linearRing, geofenceId) {
+  var errorPrefix = geofenceId ? geofenceId + ": " : ''; // Validate LinearRing size, must be at least 4 points
+
+  if (linearRing.length < 4) {
+    throw new Error(errorPrefix + "LinearRing must contain 4 or more coordinates.");
+  } // Validate all coordinates are valid, error with which ones are bad
+
+
+  var badCoordinates = [];
+  linearRing.forEach(function (coordinates) {
+    try {
+      validateCoordinates(coordinates[0], coordinates[1]);
+    } catch (error) {
+      badCoordinates.push({
+        coordinates: coordinates,
+        error: error.message
+      });
+    }
+  });
+
+  if (badCoordinates.length > 0) {
+    throw new Error(errorPrefix + "One or more of the coordinates in the Polygon LinearRing are not valid: " + JSON.stringify(badCoordinates));
+  } // Validate first and last coordinates are the same
+
+
+  var _a = __read(linearRing[0], 2),
+      lngA = _a[0],
+      latA = _a[1];
+
+  var _b = __read(linearRing[linearRing.length - 1], 2),
+      lngB = _b[0],
+      latB = _b[1];
+
+  if (lngA !== lngB || latA !== latB) {
+    throw new Error(errorPrefix + "LinearRing's first and last coordinates are not the same");
+  }
+
+  if (Object(_turf_boolean_clockwise__WEBPACK_IMPORTED_MODULE_0__["default"])(linearRing)) {
+    throw new Error(errorPrefix + "LinearRing coordinates must be wound counterclockwise");
+  }
+}
+function validatePolygon(polygon, geofenceId) {
+  var errorPrefix = geofenceId ? geofenceId + ": " : '';
+
+  if (!Array.isArray(polygon)) {
+    throw new Error(errorPrefix + "Polygon is of incorrect structure. It should be an array of LinearRings");
+  }
+
+  if (polygon.length < 1) {
+    throw new Error(errorPrefix + "Polygon must have a single LinearRing array.");
+  }
+
+  if (polygon.length > 1) {
+    throw new Error(errorPrefix + "Polygon must have a single LinearRing array. Note: We do not currently support polygons with holes, multipolygons, polygons that are wound clockwise, or that cross the antimeridian.");
+  }
+
+  var verticesCount = polygon.reduce(function (prev, linearRing) {
+    return prev + linearRing.length;
+  }, 0);
+
+  if (verticesCount > 1000) {
+    throw new Error(errorPrefix + "Polygon has more than the maximum 1000 vertices.");
+  }
+
+  polygon.forEach(function (linearRing) {
+    validateLinearRing(linearRing, geofenceId);
+  });
+}
+function validateGeofencesInput(geofences) {
+  var geofenceIds = {};
+  geofences.forEach(function (geofence) {
+    // verify all required properties are present
+    // Validate geofenceId exists
+    if (!geofence.geofenceId) {
+      throw new Error("Geofence '" + geofence + "' is missing geofenceId");
+    }
+
+    var geofenceId = geofence.geofenceId;
+    validateGeofenceId(geofenceId); // Validate geofenceId is unique
+
+    if (geofenceIds[geofenceId]) {
+      throw new Error("Duplicate geofenceId: " + geofenceId);
+    } else {
+      geofenceIds[geofenceId] = true;
+    } // Validate geometry exists
+
+
+    if (!geofence.geometry) {
+      throw new Error("Geofence '" + geofenceId + "' is missing geometry");
+    }
+
+    var geometry = geofence.geometry; // Validate polygon exists
+
+    if (!geometry.polygon) {
+      throw new Error("Geofence '" + geofenceId + "' is missing geometry.polygon");
+    }
+
+    var polygon = geometry.polygon; // Validate polygon length and structure
+
+    try {
+      validatePolygon(polygon, geofenceId);
+    } catch (error) {
+      if (error.message.includes('Polygon has more than the maximum 1000 vertices.')) {
+        throw new Error("Geofence '" + geofenceId + "' has more than the maximum of 1000 vertices");
+      }
+    } // Validate LinearRing length, structure, and coordinates
+
+
+    var _a = __read(polygon, 1),
+        linearRing = _a[0];
+
+    validateLinearRing(linearRing, geofenceId);
+  });
+}
+
 /***/ }),
 
 /***/ "@aws-amplify/core":