@konfirm/geojson 1.0.0

package/.editorconfig

@@ -0,0 +1,16 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = tab
+indent_size = 4
+end_of_line = crlf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.yml]
+indent_style = space
+indent_size = 2

package/.github/workflows/release.yml

@@ -0,0 +1,21 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "**"
+
+jobs:
+  package:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm install
+      - run: npm run test:pretty
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}

package/.github/workflows/tests.yml

@@ -0,0 +1,56 @@
+# This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Tests
+
+on:
+  push:
+    branches:
+      - "main"
+      - "fix/*"
+      - "feature/*"
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    types: [opened, synchronize, closed]
+    paths-ignore:
+      - "**.md"
+
+jobs:
+  test-typescript:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+        node-version:
+          - 14.x
+          - 16.x
+          - 18.x
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use Node ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm install
+      - run: npm run test:pretty
+
+  build:
+    needs: test-typescript
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm install
+      - run: npm run build
+      - uses: actions/upload-artifact@v3
+        with:
+          name: bundle
+          path: dist/

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased] -
+
+### Added
+### Changed
+### Deprecated
+### Removed
+### Fixed
+### Security
+
+## [1.0.0] - 2023-02-05
+
+_Initial release_
+
+[unreleased]: https://github.com/konfirm/geojson/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/konfirm/geojson/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+MIT License Copyright (c) 2021-2023 Rogier Spieker (Konfirm)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,260 @@
+[![Release](https://github.com/konfirm/geojson/actions/workflows/release.yml/badge.svg)](https://github.com/konfirm/geojson/actions/workflows/release.yml)
+[![Tests](https://github.com/konfirm/geojson/actions/workflows/tests.yml/badge.svg)](https://github.com/konfirm/geojson/actions/workflows/tests.yml)
+
+# @konfirm/geojson
+
+GeoJSON validation, iteration, intersection and distance calculation.
+
+## API
+
+### Types
+
+All [GeoJSON types](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1) are available as export
+
+| type               | descriptions                                                                                | note                                                                                                                                                                                                    |
+| ------------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Position           | A [GeoJSON Position](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.1)           | `[Longitude, Latitude, Altitude?]`                                                                                                                                                                      |
+| Point              | A [GeoJSON Point](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.2)              | The `coordinates` property is a `Position`                                                                                                                                                              |
+| MultiPoint         | A [GeoJSON MultiPoint](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.3)         | The `coordinates` property is an array of `Position`                                                                                                                                                    |
+| LineString         | A [GeoJSON LineString](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.4)         | The `coordinates` property is an array of two or more `Position`                                                                                                                                        |
+| MultiLineString    | A [GeoJSON MultiLineString](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.5)    | The `coordinates` property is an array of`LineString` coordinates                                                                                                                                       |
+| Polygon            | A [GeoJSON Polygon](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6)            | The `coordinates` property is an array of "LinearRings" (closed `LineString` coordinates, where the first and last `Position` are identical)                                                            |
+| MultiPolygon       | A [GeoJSON MultiPolygon](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.7)       | The `coordinates` property is an array of `Polygon` coordinate arrays                                                                                                                                   |
+| GeometryCollection | A [GeoJSON GeometryCollection](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.8) | geometries is an array of Geometries (`Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`)                                                                                |
+| Feature            | A [GeoJSON Feature](https://datatracker.ietf.org/doc/html/rfc7946#section-3.2)              | A spatially bounded 'Thing', consisting of a `geometry` property (`Point`, `MultiPoint`, `LineString`, `MultiLineString`, `Polygon`, `MultiPolygon`, `GeometryCollection`) with additional `properties` |
+| FeatureCollection  | A [GeoJSON Collection](https://datatracker.ietf.org/doc/html/rfc7946#section-3.3)           | The `features` property is an array of `Feature` objects                                                                                                                                                |
+
+
+### Type Guards
+
+Most of the exported functionality is based on validation of GeoJSON objects, validating required and optional (if provided) properties. 
+The `isStrict*` variants of the type guards also validate the following:
+ - `Longitude` is a number in the range (inclusive) `-180..180`
+ - `Latitude` is a number in the range (inclusive) `-90..90`
+ - `Altitude` is a number in the range (inclusive) `-6371008.7714..20180000` (Earth center(-ish) up to the GPS satelite distance)
+ - `Polygon` "LinearRing" are closed (first and last `Position` are identical)
+ - `Polygon` "LinearRing" have the correct winding (counterclockwise for exterior rings (outline), clockwise for interior rings (holes))
+
+
+| type               | guard                  | strict guard                 | description                                                                                                        |
+| ------------------ | ---------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| Position           | `isPosition`           | `isStrictPosition`           | validate whether the input is valid GeoJSON Position                                                               |
+| Point              | `isPoint`              | `isStrictPoint`              | validate whether the input is valid GeoJSON Point                                                                  |
+| MultiPoint         | `isMultiPoint`         | `isStrictMultiPoint`         | validate whether the input is valid GeoJSON MultiPoint                                                             |
+| LineString         | `isLineString`         | `isStrictLineString`         | validate whether the input is valid GeoJSON LineString                                                             |
+| MultiLineString    | `isMultiLineString`    | `isStrictMultiLineString`    | validate whether the input is valid GeoJSON MultiLineString                                                        |
+| Polygon            | `isPolygon`            | `isStrictPolygon`            | validate whether the input is valid GeoJSON Polygon                                                                |
+| MultiPolygon       | `isMultiPolygon`       | `isStrictMultiPolygon`       | validate whether the input is valid GeoJSON MultiPolygon                                                           |
+| GeometryCollection | `isGeometryCollection` | `isStrictGeometryCollection` | validate whether the input is valid GeoJSON GeometryCollection                                                     |
+| Geometry           | `isGeometry`           | `isStrictGeometry`           | validate whether the input is valid GeoJSON Geometry (`Point`, `LineString`, `Polygon` or their `Multi*` variants) |
+| Feature            | `isFeature`            | `isStrictFeature`            | validate whether the input is valid GeoJSON Feature                                                                |
+| FeatureCollection  | `isFeatureCollection`  | `isStrictFeatureCollection`  | validate whether the input is valid GeoJSON FeatureCollection                                                      |
+| GeoJSON            | `isGeoJSON`            | `isStrictGeoJSON`            | validate the input to be valid GeoJSON                                                                             |
+
+```ts
+import { isPoint, isStrictPoint } from '@konfirm/geojson';
+
+const point: Point = {
+    type: 'Point',
+    coordinates: [181, 91],
+};
+
+console.log('the point is a GeoJSON Point', isPoint(point)); // true, as the structure is up to specification
+console.log('the point is a strict GeoJSON Point', isStrictPoint(point)); // false, as the coordinates are not within the specified ranges
+```
+
+### intersect
+
+Verify whether the provided GeoJSON objects intersect.
+
+Usage: `intersect(<Geometry(Collection)|Feature(Collection)>, <Geometry(Collection)|Feature(Collection)>): boolean`
+
+```ts
+import { intersect, Point, Feature } from '@konfirm/geojson';
+
+const point: Point = {
+    type: 'Point',
+    coordinates: [1, 1],
+};
+const feature: Feature = {
+    type: 'Feature',
+    properties: {
+        name: 'triangle'
+    },
+    geometry: {
+        type: 'Polygon',
+        coordinates: [[[0, 0], [0, 2], [2, 1], [0, 0]]],
+    },
+}
+
+console.log('point intersects feature', intersect(point, feature)); // true
+console.log('feature intersects point', intersect(feature, point)); // true
+```
+
+### distance
+
+Obtain the (shortest) distance in meters between two GeoJSON objects. There are three formulas which can be used:
+
+ - `cartesian` (default), calculates the distance between coordinates using the Pythagorean equation, this is the fastest formula at the cost of (huge amount of) accuracy
+ - `haversine`, calculates the distance between coordinates using the [haversine formula](https://en.wikipedia.org/wiki/Haversine_formula), improves the accuracy to a level which is probably suitable for most needs with a decent performance
+ - `vincenty`, calculates the distance between coordinates using the [Vincenty's formula](https://en.wikipedia.org/wiki/Vincenty%27s_formulae), the most accurate but the least performant algorithm.
+
+Usage: `distance(<Geometry(Collection)|Feature(Collection)>, <Geometry(Collection)|Feature(Collection)> [, <'cartesian'|'haversine'|'vincenty'>]): number`
+
+```ts
+import { distance, Feature } from '@konfirm/geojson';
+
+    const a: Feature = {
+        type: 'Feature',
+        properties: {
+            name: 'Schiphol Airpoirt, Amsterdam',
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [4.763889, 52.308333],
+        },
+    };
+    const b: Feature = {
+        type: 'Feature',
+        properties: {
+            name: 'John F. Kennedy International Airport, New York',
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [-73.778889, 40.639722],
+        },
+    };
+
+    console.log(distance(a, b));             // 8829424.604594177
+    console.log(distance(a, b, 'direct');    // 8829424.604594177 ('direct' is the default)
+    console.log(distance(a, b, 'haversine'); // 5847546.425707642
+    console.log(distance(a, b, 'vincenty');  // 5863355.371234315
+```
+
+### SimpleGeometryIterator
+
+The SimpleGeometryIterator class is a convenience helper utility which yeilds all simple Geometric shapes (`Point`, `LineString`, `Polygon`) from any GeoJSON object. Using a SimpleGeometryIterator allows you to focus on just implementing logic for the simple Geometric shapes whilst supporting any compbination of GeoJSON objects as input.
+
+| input type           | yields type(s)                     | description                                                                              |
+| -------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------- |
+| `Point`              | `Point`                            | yields the `Point` geometry as is                                                        |
+| `MultiPoint`         | `Point`                            | yields every `Point` of the `MultiPoint`                                                 |
+| `LineString`         | `LineString`                       | yields the `LineString` geometry as is                                                   |
+| `MultiLineString`    | `LineString`                       | yields every `LineString` of the `MultiLineString`                                       |
+| `Polygon`            | `Polygon`                          | yields the `Polygon` geometry as is                                                      |
+| `MultiPolygon`       | `Polygon`                          | yields every `Polygon` of the `MultiPolygon`                                             |
+| `GeometryCollection` | `Point`, `LineString` or `Polygon` | yields every geometry contained within the collection (see the corresponing types above) |
+| `Feature`            | `Point`, `LineString` or `Polygon` | yields the geometry of a feature (see the corresponding types above)                     |
+| `FeatureCollection`  | `Point`, `LineString` or `Polygon` | yields every `Feature` (see `Feature`)                                                   |
+
+```ts
+import type { Point, MultiPoint, LineString, MultiLineString, GeometryCollection, Feature, FeatureCollection } from '@konfirm/geojson';
+import { SimpleGeometryIterator } from '@konfirm/geojson';
+
+const point: Point = {
+    type: 'Point',
+    coordinates: [5.903949737548828, 51.991936460056515],
+};
+const multipoint: MultiPoint = {
+    type: 'MultiPoint',
+    coordinates: [
+        [5.896482467651367, 52.00039200820837],
+        [5.888843536376953, 51.99912377779024],
+    ],
+};
+const linestring: LineString = {
+    type: 'LineString',
+    coordinates: [
+        [5.9077370166778564, 51.9944435645134],
+        [5.90764045715332, 51.994209045542206],
+        [5.907415151596069, 51.99408683094357],
+    ],
+};
+const multilinestring: MultiLineString = {
+    type: 'MultiLineString',
+    coordinates: [
+        [
+            [5.905205011367797, 51.99430813821511],
+            [5.905086994171143, 51.994261894995034],
+            [5.905033349990845, 51.99414958983319],
+            [5.9051138162612915, 51.994116558849626]
+        ],
+        [
+            [5.904818773269653, 51.993825885143515],
+            [5.905521512031555, 51.993551725259614],
+            [5.905789732933044, 51.99358805979856],
+        ],
+    ],
+};
+const geometrycollection: GeometryCollection = {
+    type: 'GeometryCollection',
+    geometries: [point],
+};
+const featurecollection: FeatureCollection = {
+    type: 'FeatureCollection',
+    features: [
+        {
+            type: 'Feature',
+            properties: {},
+            geometry: linestring,
+        },
+        {
+            type: 'Feature',
+            properties: {},
+            geometry: multilinestring,
+        },
+    ]
+};
+
+const simplified = [...new SimpleGeometryIterator(multipoint, geometrycollection, featurecollection)];
+/*
+    [
+        {
+            type: 'Point',
+            coordinates: ...multipoint[0]
+        },
+        {
+            type: 'Point',
+            coordinates: ...multipoint[1]
+        },
+        {
+            type: 'Point',
+            coordinates: ...point
+        },
+        {
+            type: 'LineString',
+            coordinates: ...linestring
+        },
+        {
+            type: 'LineString',
+            coordinates: ...multilinestring[0]
+        },
+        {
+            type: 'LineString',
+            coordinates: ...multilinestring[1]
+        },
+    ]
+*/
+```
+
+## License
+
+MIT License Copyright (c) 2021-2023 Rogier Spieker (Konfirm)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/Domain/Constants.d.ts

@@ -0,0 +1,5 @@
+export declare const EARTH_RADIUS = 6371008.7714;
+export declare const EARTH_RADIUS_MAJOR = 6378137;
+export declare const EARTH_RADIUS_MINOR = 6356752.314245;
+export declare const EARTH_FLATTENING = 298.257223563;
+export declare const GPS_SATELLITE_ORBIT = 20180000;

package/dist/Domain/GeoJSON/Concept/Altitude.d.ts

@@ -0,0 +1,3 @@
+export type Altitude = number;
+export declare function isAltitude(value: any): value is Altitude;
+export declare const isStrictAltitude: import("../../Guards/Utility").Guard<number>;

package/dist/Domain/GeoJSON/Concept/BoundingBox.d.ts

@@ -0,0 +1,6 @@
+import { Longitude } from "./Longitude";
+import { Latitude } from "./Latitude";
+import { Altitude } from "./Altitude";
+export type BoundingBox = [Longitude, Latitude, Altitude, Longitude, Latitude, Altitude] | [Longitude, Latitude, Longitude, Latitude];
+export declare const isBoundingBox: import("@konfirm/guard").Guard<BoundingBox>;
+export declare const isStrictBoundingBox: import("@konfirm/guard").Guard<BoundingBox>;

package/dist/Domain/GeoJSON/Concept/ExteriorRing.d.ts

@@ -0,0 +1,4 @@
+import { LinearRing } from "./LinearRing";
+export type ExteriorRing = LinearRing;
+export declare const isExteriorRing: import("@konfirm/guard").Guard<LinearRing>;
+export declare const isStrictExteriorRing: import("@konfirm/guard").Guard<LinearRing>;

package/dist/Domain/GeoJSON/Concept/GeoJSONObject.d.ts

@@ -0,0 +1,11 @@
+import { Guard } from "@konfirm/guard";
+import { BoundingBox } from "./BoundingBox";
+type GeoJSONBase = {
+    type: string;
+    bbox?: BoundingBox;
+    [key: string]: unknown;
+};
+export type GeoJSONObject<T extends GeoJSONBase = GeoJSONBase> = GeoJSONBase & T;
+export declare function isGeoJSONObject<T extends GeoJSONBase>(type: string): Guard<T>;
+export declare function isStrictGeoJSONObject<T extends GeoJSONBase>(type: string): Guard<T>;
+export {};

package/dist/Domain/GeoJSON/Concept/InteriorRing.d.ts

@@ -0,0 +1,4 @@
+import { LinearRing } from "./LinearRing";
+export type InteriorRing = LinearRing;
+export declare const isInteriorRing: import("@konfirm/guard").Guard<LinearRing>;
+export declare const isStrictInteriorRing: import("@konfirm/guard").Guard<LinearRing>;

package/dist/Domain/GeoJSON/Concept/Latitude.d.ts

@@ -0,0 +1,3 @@
+export type Latitude = number;
+export declare function isLatitude(value: any): value is Latitude;
+export declare const isStrictLatitude: import("../../Guards/Utility").Guard<number>;

package/dist/Domain/GeoJSON/Concept/LinearRing.d.ts

@@ -0,0 +1,4 @@
+import { Position } from "./Position";
+export type LinearRing = Array<Position>;
+export declare const isLinearRing: import("@konfirm/guard").Guard<LinearRing>;
+export declare const isStrictLinearRing: import("@konfirm/guard").Guard<LinearRing>;

package/dist/Domain/GeoJSON/Concept/Longitude.d.ts

@@ -0,0 +1,3 @@
+export type Longitude = number;
+export declare function isLongitude(value: any): value is Longitude;
+export declare const isStrictLongitude: import("../../Guards/Utility").Guard<number>;

package/dist/Domain/GeoJSON/Concept/Position.d.ts

@@ -0,0 +1,7 @@
+import { Altitude } from "./Altitude";
+import { Latitude } from "./Latitude";
+import { Longitude } from "./Longitude";
+export type Position = [Longitude, Latitude, Altitude?];
+export declare const isPosition: import("@konfirm/guard").Guard<Position>;
+export declare const isStrictPosition: import("@konfirm/guard").Guard<Position>;
+export declare function isEquivalentPosition(one: any, two: any): boolean;

package/dist/Domain/GeoJSON/Feature.d.ts

@@ -0,0 +1,12 @@
+import { GeoJSONObject } from "./Concept/GeoJSONObject";
+import { Geometry } from "./Geometry";
+import { GeometryCollection } from "./GeometryCollection";
+export type Feature = GeoJSONObject<{
+    type: 'Feature';
+    geometry: Geometry | GeometryCollection;
+    properties: {
+        [key: string]: unknown;
+    } | null;
+}>;
+export declare const isFeature: import("@konfirm/guard").Guard<Feature>;
+export declare const isStrictFeature: import("@konfirm/guard").Guard<Feature>;

package/dist/Domain/GeoJSON/FeatureCollection.d.ts

@@ -0,0 +1,8 @@
+import { Feature } from "./Feature";
+import { GeoJSONObject } from "./Concept/GeoJSONObject";
+export type FeatureCollection = GeoJSONObject<{
+    type: 'FeatureCollection';
+    features: Array<Feature>;
+}>;
+export declare const isFeatureCollection: import("@konfirm/guard").Guard<FeatureCollection>;
+export declare const isStrictFeatureCollection: import("@konfirm/guard").Guard<FeatureCollection>;

package/dist/Domain/GeoJSON/GeoJSON.d.ts

@@ -0,0 +1,7 @@
+import { Feature } from "./Feature";
+import { FeatureCollection } from "./FeatureCollection";
+import { GeometryCollection } from "./GeometryCollection";
+import { Geometry } from "./Geometry";
+export type GeoJSON = Geometry | GeometryCollection | Feature | FeatureCollection;
+export declare const isGeoJSON: import("@konfirm/guard").Guard<GeoJSON>;
+export declare const isStrictGeoJSON: import("@konfirm/guard").Guard<GeoJSON>;

package/dist/Domain/GeoJSON/Geometry/LineString.d.ts

@@ -0,0 +1,11 @@
+import { Guard } from "../../Guards/Utility";
+import { GeometryObject } from "../GeometryObject";
+import { MultiPoint } from "./MultiPoint";
+export type LineString = GeometryObject<{
+    type: 'LineString';
+    coordinates: MultiPoint['coordinates'];
+}>;
+export declare const isLineStringCoordinates: Guard<import("../Concept/Position").Position[]>;
+export declare const isLineString: Guard<LineString>;
+export declare const isStrictLineStringCoordinates: Guard<import("../Concept/Position").Position[]>;
+export declare const isStrictLineString: Guard<LineString>;

package/dist/Domain/GeoJSON/Geometry/MultiLineString.d.ts

@@ -0,0 +1,7 @@
+import { MultiGeometryObject } from "../GeometryObject";
+import { LineString } from "./LineString";
+export type MultiLineString = MultiGeometryObject<LineString>;
+export declare const isMultiLineStringCoordinates: import("@konfirm/guard").Guard<unknown>;
+export declare const isMultiLineString: import("@konfirm/guard").Guard<MultiLineString>;
+export declare const isStrictMultiLineStringCoordinates: import("@konfirm/guard").Guard<unknown>;
+export declare const isStrictMultiLineString: import("@konfirm/guard").Guard<MultiLineString>;

package/dist/Domain/GeoJSON/Geometry/MultiPoint.d.ts

@@ -0,0 +1,8 @@
+import { Guard } from "../../Guards/Utility";
+import { MultiGeometryObject } from "../GeometryObject";
+import { Point } from "./Point";
+export type MultiPoint = MultiGeometryObject<Point>;
+export declare const isMultiPointCoordinates: Guard<MultiPoint['coordinates']>;
+export declare const isMultiPoint: import("@konfirm/guard").Guard<MultiPoint>;
+export declare const isStrictMultiPointCoordinates: Guard<MultiPoint['coordinates']>;
+export declare const isStrictMultiPoint: import("@konfirm/guard").Guard<MultiPoint>;

package/dist/Domain/GeoJSON/Geometry/MultiPolygon.d.ts

@@ -0,0 +1,7 @@
+import { MultiGeometryObject } from "../GeometryObject";
+import { Polygon } from "./Polygon";
+export type MultiPolygon = MultiGeometryObject<Polygon>;
+export declare const isMultiPolygonCoordinates: import("@konfirm/guard").Guard<unknown>;
+export declare const isMultiPolygon: import("@konfirm/guard").Guard<MultiPolygon>;
+export declare const isStrictMultiPolygonCoordinates: import("@konfirm/guard").Guard<unknown>;
+export declare const isStrictMultiPolygon: import("@konfirm/guard").Guard<MultiPolygon>;

package/dist/Domain/GeoJSON/Geometry/Point.d.ts

@@ -0,0 +1,11 @@
+import { GeometryObject } from "../GeometryObject";
+import { Position } from "../Concept/Position";
+import { Guard } from "../../Guards/Utility";
+export type Point = GeometryObject<{
+    type: 'Point';
+    coordinates: Position;
+}>;
+export declare const isPointCoordinates: Guard<Point['coordinates']>;
+export declare const isPoint: Guard<Point>;
+export declare const isStrictPointCoordinates: Guard<Point['coordinates']>;
+export declare const isStrictPoint: Guard<Point>;

package/dist/Domain/GeoJSON/Geometry/Polygon.d.ts

@@ -0,0 +1,11 @@
+import { GeometryObject } from "../GeometryObject";
+import { ExteriorRing } from "../Concept/ExteriorRing";
+import { InteriorRing } from "../Concept/InteriorRing";
+export type Polygon = GeometryObject<{
+    type: 'Polygon';
+    coordinates: [ExteriorRing, ...Array<InteriorRing>];
+}>;
+export declare const isPolygonCoordinates: import("@konfirm/guard").Guard<unknown>;
+export declare const isPolygon: import("@konfirm/guard").Guard<Polygon>;
+export declare const isStrictPolygonCoordinates: import("@konfirm/guard").Guard<unknown>;
+export declare const isStrictPolygon: import("@konfirm/guard").Guard<Polygon>;

package/dist/Domain/GeoJSON/Geometry.d.ts

@@ -0,0 +1,9 @@
+import { LineString } from "./Geometry/LineString";
+import { MultiLineString } from "./Geometry/MultiLineString";
+import { MultiPoint } from "./Geometry/MultiPoint";
+import { MultiPolygon } from "./Geometry/MultiPolygon";
+import { Point } from "./Geometry/Point";
+import { Polygon } from "./Geometry/Polygon";
+export type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;
+export declare const isGeometry: import("@konfirm/guard").Guard<Geometry>;
+export declare const isStrictGeometry: import("@konfirm/guard").Guard<Geometry>;

package/dist/Domain/GeoJSON/GeometryCollection.d.ts

@@ -0,0 +1,8 @@
+import { GeoJSONObject } from "./Concept/GeoJSONObject";
+import { Geometry } from "./Geometry";
+export type GeometryCollection = GeoJSONObject<{
+    type: 'GeometryCollection';
+    geometries: Array<Geometry | GeometryCollection>;
+}>;
+export declare function isGeometryCollection(value: any): value is GeometryCollection;
+export declare function isStrictGeometryCollection(value: any): value is GeometryCollection;

package/dist/Domain/GeoJSON/GeometryObject.d.ts

@@ -0,0 +1,12 @@
+import { Guard, Validator } from "@konfirm/guard";
+import { GeoJSONObject } from "./Concept/GeoJSONObject";
+type GeometryBase = GeoJSONObject & {
+    coordinates: Array<unknown>;
+};
+export type GeometryObject<T extends GeometryBase> = Omit<GeometryBase, 'coordinates'> & T;
+export type MultiGeometryObject<T extends GeometryBase> = GeometryObject<{
+    type: `Multi${T['type']}`;
+    coordinates: Array<T['coordinates']>;
+}>;
+export declare function isGeometryObject<T extends GeometryBase>(type: string, isCoordinates: Validator): Guard<T>;
+export {};

package/dist/Domain/Guards/Number.d.ts

@@ -0,0 +1,3 @@
+import { Guard } from './Utility';
+export declare function isNumberValue<T extends number>(value: any): value is T;
+export declare function isNumberBetween<T extends number>(a: number, b?: number): Guard<T>;

package/dist/Domain/Guards/Tuple.d.ts

@@ -0,0 +1,3 @@
+import { Validator } from "@konfirm/guard";
+import { Guard } from './Utility';
+export declare function isTuple<T extends Array<unknown>>(...rules: Array<Validator>): Guard<T>;