@loaders.gl/gis 4.3.4 → 4.4.0-alpha.10

package/dist/lib/geo/geoparquet-metadata-schema.d.ts

@@ -1,79 +0,0 @@
-/**
- * Geoparquet JSON schema for geo metadata
- * @see https://github.com/geoarrow/geoarrow/blob/main/metadata.md
- * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
- */
-export declare const GEOPARQUET_METADATA_JSON_SCHEMA: {
-    $schema: string;
-    title: string;
-    description: string;
-    type: string;
-    required: string[];
-    properties: {
-        version: {
-            type: string;
-            const: string;
-        };
-        primary_column: {
-            type: string;
-            minLength: number;
-        };
-        columns: {
-            type: string;
-            minProperties: number;
-            patternProperties: {
-                '.+': {
-                    type: string;
-                    required: string[];
-                    properties: {
-                        encoding: {
-                            type: string;
-                            const: string;
-                        };
-                        geometry_types: {
-                            type: string;
-                            uniqueItems: boolean;
-                            items: {
-                                type: string;
-                                pattern: string;
-                            };
-                        };
-                        crs: {
-                            oneOf: ({
-                                $ref: string;
-                                type?: undefined;
-                            } | {
-                                type: string;
-                                $ref?: undefined;
-                            })[];
-                        };
-                        edges: {
-                            type: string;
-                            enum: string[];
-                        };
-                        orientation: {
-                            type: string;
-                            const: string;
-                        };
-                        bbox: {
-                            type: string;
-                            items: {
-                                type: string;
-                            };
-                            oneOf: {
-                                description: string;
-                                minItems: number;
-                                maxItems: number;
-                            }[];
-                        };
-                        epoch: {
-                            type: string;
-                        };
-                    };
-                };
-            };
-            additionalProperties: boolean;
-        };
-    };
-};
-//# sourceMappingURL=geoparquet-metadata-schema.d.ts.map

package/dist/lib/geo/geoparquet-metadata-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geoparquet-metadata-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/geoparquet-metadata-schema.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2D3C,CAAC"}

package/dist/lib/geo/geoparquet-metadata-schema.js

@@ -1,69 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
-/**
- * Geoparquet JSON schema for geo metadata
- * @see https://github.com/geoarrow/geoarrow/blob/main/metadata.md
- * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
- */
-export const GEOPARQUET_METADATA_JSON_SCHEMA = {
-    $schema: 'http://json-schema.org/draft-07/schema#',
-    title: 'GeoParquet',
-    description: 'Parquet metadata included in the geo field.',
-    type: 'object',
-    required: ['version', 'primary_column', 'columns'],
-    properties: {
-        version: { type: 'string', const: '1.0.0-beta.1' },
-        primary_column: { type: 'string', minLength: 1 },
-        columns: {
-            type: 'object',
-            minProperties: 1,
-            patternProperties: {
-                '.+': {
-                    type: 'object',
-                    required: ['encoding', 'geometry_types'],
-                    properties: {
-                        encoding: { type: 'string', const: 'WKB' },
-                        geometry_types: {
-                            type: 'array',
-                            uniqueItems: true,
-                            items: {
-                                type: 'string',
-                                pattern: '^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$'
-                            }
-                        },
-                        crs: {
-                            oneOf: [
-                                {
-                                    $ref: 'https://proj.org/schemas/v0.5/projjson.schema.json'
-                                },
-                                { type: 'null' }
-                            ]
-                        },
-                        edges: { type: 'string', enum: ['planar', 'spherical'] },
-                        orientation: { type: 'string', const: 'counterclockwise' },
-                        bbox: {
-                            type: 'array',
-                            items: { type: 'number' },
-                            oneOf: [
-                                {
-                                    description: '2D bbox consisting of (xmin, ymin, xmax, ymax)',
-                                    minItems: 4,
-                                    maxItems: 4
-                                },
-                                {
-                                    description: '3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)',
-                                    minItems: 6,
-                                    maxItems: 6
-                                }
-                            ]
-                        },
-                        epoch: { type: 'number' }
-                    }
-                }
-            },
-            additionalProperties: false
-        }
-    }
-};

package/dist/lib/geo/geoparquet-metadata.d.ts

@@ -1,45 +0,0 @@
-import { Schema } from '@loaders.gl/schema';
-/**
- * A geoarrow / geoparquet geo metadata object
- * (stored in stringified form in the top level metadata 'geo' key)
- * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
- * @see https://github.com/geoarrow/geoarrow
- * */
-export type GeoMetadata = {
-    version?: string;
-    primary_column?: string;
-    columns: Record<string, GeoColumnMetadata>;
-    [key: string]: unknown;
-};
-/** A geoarrow / geoparquet geo metadata for one geometry column  */
-export type GeoColumnMetadata = {
-    encoding: 'wkb' | 'wkt';
-    geometry_types: GeoParquetGeometryType[];
-    crs?: object | null;
-    orientation?: 'counterclockwise';
-    bbox?: [number, number, number, number] | [number, number, number, number, number, number];
-    edges?: 'planar' | 'spherical';
-    epoch?: number;
-    [key: string]: unknown;
-};
-/** A GeoParquet metadata geometry type */
-export type GeoParquetGeometryType = 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon' | 'GeometryCollection' | 'Point Z' | 'LineString Z' | 'Polygon Z' | 'MultiPoint Z' | 'MultiLineString Z' | 'MultiPolygon Z' | 'GeometryCollection Z';
-/**
- * Reads the GeoMetadata object from the metadata
- * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata
- */
-export declare function getGeoMetadata(schema: Schema): GeoMetadata | null;
-/**
- * Stores a geoarrow / geoparquet geo metadata object in the schema
- * @note geoarrow / geoparquet geo metadata is a single stringified JSON field
- */
-export declare function setGeoMetadata(schema: Schema, geoMetadata: GeoMetadata): void;
-/**
- * Unpacks geo metadata into separate metadata fields (parses the long JSON string)
- * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata
- */
-export declare function unpackGeoMetadata(schema: Schema): void;
-/** Parse a key with stringified arrow metadata */
-export declare function parseJSONStringMetadata(schema: Schema, metadataKey: string): Record<string, unknown> | null;
-export declare function unpackJSONStringMetadata(schema: Schema, metadataKey: string): void;
-//# sourceMappingURL=geoparquet-metadata.d.ts.map

package/dist/lib/geo/geoparquet-metadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geoparquet-metadata.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/geoparquet-metadata.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,MAAM,EAAQ,MAAM,oBAAoB,CAAC;AAIjD;;;;;KAKK;AACL,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC3C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,KAAK,GAAG,KAAK,CAAC;IACxB,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3F,KAAK,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,0CAA0C;AAC1C,MAAM,MAAM,sBAAsB,GAC9B,OAAO,GACP,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,iBAAiB,GACjB,cAAc,GACd,oBAAoB,GACpB,SAAS,GACT,cAAc,GACd,WAAW,GACX,cAAc,GACd,mBAAmB,GACnB,gBAAgB,GAChB,sBAAsB,CAAC;AAI3B;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAWjE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAG7E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CA6BtD;AAqDD,kDAAkD;AAClD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAehC;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAMlF"}

package/dist/lib/geo/geoparquet-metadata.js

@@ -1,117 +0,0 @@
-// GEO METADATA
-/**
- * Reads the GeoMetadata object from the metadata
- * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata
- */
-export function getGeoMetadata(schema) {
-    const geoMetadata = parseJSONStringMetadata(schema, 'geo');
-    if (!geoMetadata) {
-        return null;
-    }
-    for (const column of Object.values(geoMetadata.columns || {})) {
-        if (column.encoding) {
-            column.encoding = column.encoding.toLowerCase();
-        }
-    }
-    return geoMetadata;
-}
-/**
- * Stores a geoarrow / geoparquet geo metadata object in the schema
- * @note geoarrow / geoparquet geo metadata is a single stringified JSON field
- */
-export function setGeoMetadata(schema, geoMetadata) {
-    const stringifiedGeoMetadata = JSON.stringify(geoMetadata);
-    schema.metadata.geo = stringifiedGeoMetadata;
-}
-/**
- * Unpacks geo metadata into separate metadata fields (parses the long JSON string)
- * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata
- */
-export function unpackGeoMetadata(schema) {
-    const geoMetadata = getGeoMetadata(schema);
-    if (!geoMetadata) {
-        return;
-    }
-    // Store Parquet Schema Level Metadata
-    const { version, primary_column, columns } = geoMetadata;
-    if (version) {
-        schema.metadata['geo.version'] = version;
-    }
-    if (primary_column) {
-        schema.metadata['geo.primary_column'] = primary_column;
-    }
-    // store column names as comma separated list
-    schema.metadata['geo.columns'] = Object.keys(columns || {}).join('');
-    for (const [columnName, columnMetadata] of Object.entries(columns || {})) {
-        const field = schema.fields.find((field) => field.name === columnName);
-        if (field) {
-            if (field.name === primary_column) {
-                setFieldMetadata(field, 'geo.primary_field', 'true');
-            }
-            unpackGeoFieldMetadata(field, columnMetadata);
-        }
-    }
-}
-// eslint-disable-next-line complexity
-function unpackGeoFieldMetadata(field, columnMetadata) {
-    for (const [key, value] of Object.entries(columnMetadata || {})) {
-        switch (key) {
-            case 'geometry_types':
-                setFieldMetadata(field, `geo.${key}`, value.join(','));
-                break;
-            case 'bbox':
-                setFieldMetadata(field, `geo.crs.${key}`, JSON.stringify(value));
-                break;
-            case 'crs':
-                // @ts-ignore
-                for (const [crsKey, crsValue] of Object.entries(value || {})) {
-                    switch (crsKey) {
-                        case 'id':
-                            // prettier-ignore
-                            const crsId = typeof crsValue === 'object'
-                                ? // @ts-ignore
-                                    `${crsValue?.authority}:${crsValue?.code}`
-                                : JSON.stringify(crsValue);
-                            setFieldMetadata(field, `geo.crs.${crsKey}`, crsId);
-                            break;
-                        default:
-                            setFieldMetadata(field, `geo.crs.${crsKey}`, typeof crsValue === 'string' ? crsValue : JSON.stringify(crsValue));
-                            break;
-                    }
-                }
-                break;
-            case 'edges':
-            default:
-                setFieldMetadata(field, `geo.${key}`, typeof value === 'string' ? value : JSON.stringify(value));
-        }
-    }
-}
-function setFieldMetadata(field, key, value) {
-    field.metadata = field.metadata || {};
-    field.metadata[key] = value;
-}
-// HELPERS
-/** Parse a key with stringified arrow metadata */
-export function parseJSONStringMetadata(schema, metadataKey) {
-    const stringifiedMetadata = schema.metadata[metadataKey];
-    if (!stringifiedMetadata) {
-        return null;
-    }
-    try {
-        const metadata = JSON.parse(stringifiedMetadata);
-        if (!metadata || typeof metadata !== 'object') {
-            return null;
-        }
-        return metadata;
-    }
-    catch {
-        return null;
-    }
-}
-export function unpackJSONStringMetadata(schema, metadataKey) {
-    const json = parseJSONStringMetadata(schema, metadataKey);
-    for (const [key, value] of Object.entries(json || {})) {
-        schema.metadata[`${metadataKey}.${key}`] =
-            typeof value === 'string' ? value : JSON.stringify(value);
-    }
-}

package/dist/lib/tables/convert-table-to-geojson.d.ts

@@ -1,5 +0,0 @@
-import type { LoaderWithParser } from '@loaders.gl/loader-utils';
-import type { ArrayRowTable, GeoJSONTable, ObjectRowTable, Schema } from '@loaders.gl/schema';
-/** TODO - move to loaders.gl/gis? */
-export declare function convertWKBTableToGeoJSON(table: ArrayRowTable | ObjectRowTable, schema: Schema, loaders: LoaderWithParser[]): GeoJSONTable;
-//# sourceMappingURL=convert-table-to-geojson.d.ts.map

package/dist/lib/tables/convert-table-to-geojson.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-table-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/tables/convert-table-to-geojson.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,MAAM,EAGP,MAAM,oBAAoB,CAAC;AAK5B,qCAAqC;AACrC,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,aAAa,GAAG,cAAc,EACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,EAAE,GAC1B,YAAY,CAoBd"}

package/src/lib/geo/geoarrow-metadata.ts

@@ -1,100 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {Schema, Field} from '@loaders.gl/schema';
-
-export type GeoArrowEncoding =
-  | 'geoarrow.multipolygon'
-  | 'geoarrow.polygon'
-  | 'geoarrow.multilinestring'
-  | 'geoarrow.linestring'
-  | 'geoarrow.multipoint'
-  | 'geoarrow.point'
-  | 'geoarrow.wkb'
-  | 'geoarrow.wkt';
-
-/** Array containing all encodings */
-const GEOARROW_ENCODINGS = [
-  'geoarrow.multipolygon',
-  'geoarrow.polygon',
-  'geoarrow.multilinestring',
-  'geoarrow.linestring',
-  'geoarrow.multipoint',
-  'geoarrow.point',
-  'geoarrow.wkb',
-  'geoarrow.wkt'
-];
-
-const GEOARROW_COLUMN_METADATA_ENCODING = 'ARROW:extension:name';
-const GEOARROW_COLUMN_METADATA_METADATA = 'ARROW:extension:metadata';
-
-/**
- * Geospatial metadata for one column, extracted from Apache Arrow metadata
- * @see https://github.com/geoarrow/geoarrow/blob/main/extension-types.md
- */
-export type GeoArrowMetadata = {
-  /** Encoding of geometry in this column */
-  encoding?: GeoArrowEncoding;
-  /** CRS in [PROJJSON](https://proj.org/specifications/projjson.html). Omitted if producer has no information about CRS */
-  crs?: Record<string, unknown>;
-  /** Edges are either spherical or omitted */
-  edges?: 'spherical';
-  [key: string]: unknown;
-};
-
-/**
- * get geometry columns from arrow table
- */
-export function getGeometryColumnsFromSchema(schema: Schema): Record<string, GeoArrowMetadata> {
-  const geometryColumns: Record<string, GeoArrowMetadata> = {};
-  for (const field of schema.fields) {
-    const metadata = getGeometryMetadataForField(field);
-    if (metadata) {
-      geometryColumns[field.name] = metadata;
-    }
-  }
-  return geometryColumns;
-}
-/**
- * Extracts GeoArrow metadata from a field
- * @param field
- * @returns
- * @see https://github.com/geoarrow/geoarrow/blob/d2f56704414d9ae71e8a5170a8671343ed15eefe/extension-types.md
- */
-export function getGeometryMetadataForField(field: Field): GeoArrowMetadata | null {
-  let metadata: GeoArrowMetadata | null = null;
-
-  // Check for GeoArrow column encoding
-  let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
-  if (geoEncoding) {
-    geoEncoding = geoEncoding.toLowerCase();
-    // at time of testing, ogr2ogr uses WKB/WKT for encoding.
-    if (geoEncoding === 'wkb') {
-      geoEncoding = 'geoarrow.wkb';
-    }
-    if (geoEncoding === 'wkt') {
-      geoEncoding = 'geoarrow.wkt';
-    }
-    if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
-      // eslint-disable-next-line no-console
-      console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
-    } else {
-      metadata = metadata || ({} as GeoArrowMetadata);
-      metadata.encoding = geoEncoding as GeoArrowEncoding;
-    }
-  }
-
-  // Check for GeoArrow metadata
-  const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];
-  if (columnMetadata) {
-    try {
-      metadata = JSON.parse(columnMetadata);
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.warn('Failed to parse GeoArrow metadata', error);
-    }
-  }
-
-  return metadata || null;
-}

package/src/lib/geo/geoparquet-metadata-schema.json

@@ -1,60 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "GeoParquet",
-  "description": "Parquet metadata included in the geo field.",
-  "type": "object",
-  "required": ["version", "primary_column", "columns"],
-  "properties": {
-    "version": {"type": "string", "const": "1.0.0-beta.1"},
-    "primary_column": {"type": "string", "minLength": 1},
-    "columns": {
-      "type": "object",
-      "minProperties": 1,
-      "patternProperties": {
-        ".+": {
-          "type": "object",
-          "required": ["encoding", "geometry_types"],
-          "properties": {
-            "encoding": {"type": "string", "const": "WKB"},
-            "geometry_types": {
-              "type": "array",
-              "uniqueItems": true,
-              "items": {
-                "type": "string",
-                "pattern": "^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$"
-              }
-            },
-            "crs": {
-              "oneOf": [
-                {
-                  "$ref": "https://proj.org/schemas/v0.5/projjson.schema.json"
-                },
-                {"type": "null"}
-              ]
-            },
-            "edges": {"type": "string", "enum": ["planar", "spherical"]},
-            "orientation": {"type": "string", "const": "counterclockwise"},
-            "bbox": {
-              "type": "array",
-              "items": {"type": "number"},
-              "oneOf": [
-                {
-                  "description": "2D bbox consisting of (xmin, ymin, xmax, ymax)",
-                  "minItems": 4,
-                  "maxItems": 4
-                },
-                {
-                  "description": "3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)",
-                  "minItems": 6,
-                  "maxItems": 6
-                }
-              ]
-            },
-            "epoch": {"type": "number"}
-          }
-        }
-      },
-      "additionalProperties": false
-    }
-  }
-}

package/src/lib/geo/geoparquet-metadata-schema.ts

@@ -1,71 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/* eslint-disable camelcase */
-
-/**
- * Geoparquet JSON schema for geo metadata
- * @see https://github.com/geoarrow/geoarrow/blob/main/metadata.md
- * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
- */
-export const GEOPARQUET_METADATA_JSON_SCHEMA = {
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'GeoParquet',
-  description: 'Parquet metadata included in the geo field.',
-  type: 'object',
-  required: ['version', 'primary_column', 'columns'],
-  properties: {
-    version: {type: 'string', const: '1.0.0-beta.1'},
-    primary_column: {type: 'string', minLength: 1},
-    columns: {
-      type: 'object',
-      minProperties: 1,
-      patternProperties: {
-        '.+': {
-          type: 'object',
-          required: ['encoding', 'geometry_types'],
-          properties: {
-            encoding: {type: 'string', const: 'WKB'},
-            geometry_types: {
-              type: 'array',
-              uniqueItems: true,
-              items: {
-                type: 'string',
-                pattern: '^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$'
-              }
-            },
-            crs: {
-              oneOf: [
-                {
-                  $ref: 'https://proj.org/schemas/v0.5/projjson.schema.json'
-                },
-                {type: 'null'}
-              ]
-            },
-            edges: {type: 'string', enum: ['planar', 'spherical']},
-            orientation: {type: 'string', const: 'counterclockwise'},
-            bbox: {
-              type: 'array',
-              items: {type: 'number'},
-              oneOf: [
-                {
-                  description: '2D bbox consisting of (xmin, ymin, xmax, ymax)',
-                  minItems: 4,
-                  maxItems: 4
-                },
-                {
-                  description: '3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)',
-                  minItems: 6,
-                  maxItems: 6
-                }
-              ]
-            },
-            epoch: {type: 'number'}
-          }
-        }
-      },
-      additionalProperties: false
-    }
-  }
-};