/// import { Configuration } from "./configuration"; /** * * @export */ export declare const COLLECTION_FORMATS: { csv: string; ssv: string; tsv: string; pipes: string; }; /** * * @export * @interface FetchAPI */ export interface FetchAPI { (url: string, init?: any): Promise; } /** * * @export * @interface FetchArgs */ export interface FetchArgs { url: string; options: any; } /** * * @export * @class BaseAPI */ export declare class BaseAPI { protected basePath: string; protected fetch: FetchAPI; protected configuration: Configuration; constructor(configuration?: Configuration, basePath?: string, fetch?: FetchAPI); } /** * * @export * @class RequiredError * @extends {Error} */ export declare class RequiredError extends Error { field: string; name: "RequiredError"; constructor(field: string, msg?: string); } /** * * @export * @interface Aggregation */ export interface Aggregation { /** * * @type {string} * @memberof Aggregation */ type?: Aggregation.TypeEnum; /** * * @type {string} * @memberof Aggregation */ field?: string; /** * * @type {Interval} * @memberof Aggregation */ interval?: Interval; /** * * @type {string} * @memberof Aggregation */ format?: string; /** * * @type {Array} * @memberof Aggregation */ metrics?: Array; /** * * @type {string} * @memberof Aggregation */ order?: Aggregation.OrderEnum; /** * * @type {string} * @memberof Aggregation */ on?: Aggregation.OnEnum; /** * * @type {string} * @memberof Aggregation */ size?: string; /** * * @type {string} * @memberof Aggregation */ include?: string; /** * * @type {Array} * @memberof Aggregation */ raw_geometries?: Array; /** * * @type {Array} * @memberof Aggregation */ aggregated_geometries?: Array; /** * * @type {HitsFetcher} * @memberof Aggregation */ fetch_hits?: HitsFetcher; } /** * @export * @namespace Aggregation */ export declare namespace Aggregation { /** * @export * @enum {string} */ enum TypeEnum { Datehistogram, Geohash, Geotile, Histogram, Term, Geohex, } /** * @export * @enum {string} */ enum OrderEnum { Asc, Desc, } /** * @export * @enum {string} */ enum OnEnum { Field, Count, Result, } /** * @export * @enum {string} */ enum AggregatedGeometriesEnum { BBOX, CENTROID, CELL, CELLCENTER, GEOHASH, GEOHASHCENTER, } } /** * * @export * @interface AggregationMetric */ export interface AggregationMetric { /** * * @type {string} * @memberof AggregationMetric */ type?: string; /** * * @type {string} * @memberof AggregationMetric */ field?: string; /** * * @type {any} * @memberof AggregationMetric */ value?: any; } /** * * @export * @interface AggregationResponse */ export interface AggregationResponse { /** * * @type {number} * @memberof AggregationResponse */ query_time?: number; /** * * @type {number} * @memberof AggregationResponse */ total_time?: number; /** * * @type {number} * @memberof AggregationResponse */ totalnb?: number; /** * * @type {string} * @memberof AggregationResponse */ name?: string; /** * * @type {number} * @memberof AggregationResponse */ count?: number; /** * * @type {number} * @memberof AggregationResponse */ sumotherdoccounts?: number; /** * * @type {any} * @memberof AggregationResponse */ key?: any; /** * * @type {any} * @memberof AggregationResponse */ key_as_string?: any; /** * * @type {Array} * @memberof AggregationResponse */ elements?: Array; /** * * @type {Array} * @memberof AggregationResponse */ metrics?: Array; /** * * @type {Array} * @memberof AggregationResponse */ hits?: Array; /** * * @type {Array} * @memberof AggregationResponse */ geometries?: Array; /** * * @type {{ [key: string]: any; }} * @memberof AggregationResponse */ flattened_elements?: { [key: string]: any; }; } /** * * @export * @interface AggregationsRequest */ export interface AggregationsRequest { /** * * @type {Array} * @memberof AggregationsRequest */ partition_filter?: Array; /** * * @type {Filter} * @memberof AggregationsRequest */ filter?: Filter; /** * * @type {Form} * @memberof AggregationsRequest */ form?: Form; /** * * @type {Array} * @memberof AggregationsRequest */ aggregations?: Array; } /** * * @export * @interface ArlasHit */ export interface ArlasHit { /** * * @type {MD} * @memberof ArlasHit */ md?: MD; /** * * @type {any} * @memberof ArlasHit */ data?: any; } /** * * @export * @interface Bbox */ export interface Bbox { /** * * @type {number} * @memberof Bbox */ north: number; /** * * @type {number} * @memberof Bbox */ south: number; /** * * @type {number} * @memberof Bbox */ east: number; /** * * @type {number} * @memberof Bbox */ west: number; } /** * * @export * @interface CollectionDisplayNames */ export interface CollectionDisplayNames { /** * * @type {string} * @memberof CollectionDisplayNames */ collection?: string; /** * * @type {{ [key: string]: string; }} * @memberof CollectionDisplayNames */ fields?: { [key: string]: string; }; /** * * @type {{ [key: string]: string; }} * @memberof CollectionDisplayNames */ shape_columns?: { [key: string]: string; }; } /** * * @export * @interface CollectionOrganisations */ export interface CollectionOrganisations { /** * * @type {string} * @memberof CollectionOrganisations */ owner?: string; /** * * @type {Array} * @memberof CollectionOrganisations */ shared?: Array; /** * * @type {boolean} * @memberof CollectionOrganisations */ _public?: boolean; } /** * * @export * @interface CollectionReference */ export interface CollectionReference { /** * * @type {string} * @memberof CollectionReference */ collection_name: string; /** * * @type {CollectionReferenceParameters} * @memberof CollectionReference */ params: CollectionReferenceParameters; } /** * * @export * @interface CollectionReferenceDescription */ export interface CollectionReferenceDescription { /** * * @type {{ [key: string]: CollectionReferenceDescriptionProperty; }} * @memberof CollectionReferenceDescription */ properties?: { [key: string]: CollectionReferenceDescriptionProperty; }; /** * * @type {string} * @memberof CollectionReferenceDescription */ collection_name: string; /** * * @type {CollectionReferenceParameters} * @memberof CollectionReferenceDescription */ params: CollectionReferenceParameters; } /** * * @export * @interface CollectionReferenceDescriptionProperty */ export interface CollectionReferenceDescriptionProperty { /** * * @type {string} * @memberof CollectionReferenceDescriptionProperty */ type?: CollectionReferenceDescriptionProperty.TypeEnum; /** * * @type {string} * @memberof CollectionReferenceDescriptionProperty */ format?: string; /** * * @type {string} * @memberof CollectionReferenceDescriptionProperty */ hash_field?: string; /** * * @type {{ [key: string]: CollectionReferenceDescriptionProperty; }} * @memberof CollectionReferenceDescriptionProperty */ properties?: { [key: string]: CollectionReferenceDescriptionProperty; }; /** * * @type {boolean} * @memberof CollectionReferenceDescriptionProperty */ taggable?: boolean; /** * * @type {boolean} * @memberof CollectionReferenceDescriptionProperty */ indexed?: boolean; } /** * @export * @namespace CollectionReferenceDescriptionProperty */ export declare namespace CollectionReferenceDescriptionProperty { /** * @export * @enum {string} */ enum TypeEnum { TEXT, KEYWORD, LONG, INTEGER, SHORT, BYTE, DOUBLE, FLOAT, DATE, BOOLEAN, BINARY, INTRANGE, FLOATRANGE, LONGRANGE, DOUBLERANGE, DATERANGE, OBJECT, NESTED, GEOPOINT, GEOSHAPE, IP, COMPLETION, TOKENCOUNT, MAPPERMURMUR3, UNKNOWN, VARCHAR, CHAR, CHARACTER, BIT, TINYINT, SMALLINT, INT, BIGINT, DECIMAL, NUMERIC, REAL, DOUBLEPRECISION, TIMESTAMP, TIME, INTERVAL, GEOMETRY, GEOGRAPHY, POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION, MURMUR3, } } /** * * @export * @interface CollectionReferenceParameters */ export interface CollectionReferenceParameters { /** * * @type {string} * @memberof CollectionReferenceParameters */ index_name: string; /** * * @type {string} * @memberof CollectionReferenceParameters */ id_path: string; /** * * @type {string} * @memberof CollectionReferenceParameters */ geometry_path: string; /** * * @type {string} * @memberof CollectionReferenceParameters */ centroid_path: string; /** * * @type {string} * @memberof CollectionReferenceParameters */ timestamp_path: string; /** * * @type {string} * @memberof CollectionReferenceParameters */ exclude_fields?: string; /** * * @type {number} * @memberof CollectionReferenceParameters */ update_max_hits?: number; /** * * @type {string} * @memberof CollectionReferenceParameters */ taggable_fields?: string; /** * * @type {string} * @memberof CollectionReferenceParameters */ exclude_wfs_fields?: string; /** * * @type {{ [key: string]: string; }} * @memberof CollectionReferenceParameters */ custom_params?: { [key: string]: string; }; /** * * @type {CollectionDisplayNames} * @memberof CollectionReferenceParameters */ display_names?: CollectionDisplayNames; /** * * @type {CollectionOrganisations} * @memberof CollectionReferenceParameters */ organisations?: CollectionOrganisations; /** * * @type {Feed} * @memberof CollectionReferenceParameters */ atom_feed?: Feed; /** * * @type {OpenSearch} * @memberof CollectionReferenceParameters */ open_search?: OpenSearch; /** * * @type {Inspire} * @memberof CollectionReferenceParameters */ inspire?: Inspire; /** * * @type {DublinCoreElementName} * @memberof CollectionReferenceParameters */ dublin_core_element_name?: DublinCoreElementName; /** * * @type {RasterTileURL} * @memberof CollectionReferenceParameters */ raster_tile_url?: RasterTileURL; /** * * @type {number} * @memberof CollectionReferenceParameters */ raster_tile_width?: number; /** * * @type {number} * @memberof CollectionReferenceParameters */ raster_tile_height?: number; /** * * @type {Filter} * @memberof CollectionReferenceParameters */ filter?: Filter; /** * * @type {string} * @memberof CollectionReferenceParameters */ license_name?: string; /** * * @type {Array} * @memberof CollectionReferenceParameters */ license_urls?: Array; } /** * * @export * @interface CollectionReferenceUpdateOrg */ export interface CollectionReferenceUpdateOrg { /** * * @type {boolean} * @memberof CollectionReferenceUpdateOrg */ _public?: boolean; /** * * @type {Array} * @memberof CollectionReferenceUpdateOrg */ shared?: Array; } /** * * @export * @interface CollectionsImportBody */ export interface CollectionsImportBody { /** * * @type {FormDataContentDisposition} * @memberof CollectionsImportBody */ file?: FormDataContentDisposition; } /** * * @export * @interface ComputationRequest */ export interface ComputationRequest { /** * * @type {Array} * @memberof ComputationRequest */ partition_filter?: Array; /** * * @type {Filter} * @memberof ComputationRequest */ filter?: Filter; /** * * @type {Form} * @memberof ComputationRequest */ form?: Form; /** * * @type {string} * @memberof ComputationRequest */ field?: string; /** * * @type {string} * @memberof ComputationRequest */ metric?: ComputationRequest.MetricEnum; } /** * @export * @namespace ComputationRequest */ export declare namespace ComputationRequest { /** * @export * @enum {string} */ enum MetricEnum { AVG, MAX, MIN, SUM, CARDINALITY, SPANNING, GEOBBOX, GEOCENTROID, } } /** * * @export * @interface ComputationResponse */ export interface ComputationResponse { /** * * @type {number} * @memberof ComputationResponse */ query_time?: number; /** * * @type {number} * @memberof ComputationResponse */ total_time?: number; /** * * @type {number} * @memberof ComputationResponse */ totalnb?: number; /** * * @type {string} * @memberof ComputationResponse */ field?: string; /** * * @type {string} * @memberof ComputationResponse */ metric?: ComputationResponse.MetricEnum; /** * * @type {number} * @memberof ComputationResponse */ value?: number; /** * * @type {GeoJsonObject} * @memberof ComputationResponse */ geometry?: GeoJsonObject; } /** * @export * @namespace ComputationResponse */ export declare namespace ComputationResponse { /** * @export * @enum {string} */ enum MetricEnum { AVG, MAX, MIN, SUM, CARDINALITY, SPANNING, GEOBBOX, GEOCENTROID, } } /** * * @export * @interface Count */ export interface Count { /** * * @type {Array} * @memberof Count */ partition_filter?: Array; /** * * @type {Filter} * @memberof Count */ filter?: Filter; /** * * @type {Form} * @memberof Count */ form?: Form; } /** * * @export * @interface Crs */ export interface Crs { /** * * @type {string} * @memberof Crs */ type?: Crs.TypeEnum; /** * * @type {{ [key: string]: any; }} * @memberof Crs */ properties?: { [key: string]: any; }; } /** * @export * @namespace Crs */ export declare namespace Crs { /** * @export * @enum {string} */ enum TypeEnum { Name, Link, } } /** * * @export * @interface DublinCoreElementName */ export interface DublinCoreElementName { /** * * @type {string} * @memberof DublinCoreElementName */ title?: string; /** * * @type {string} * @memberof DublinCoreElementName */ creator?: string; /** * * @type {string} * @memberof DublinCoreElementName */ subject?: string; /** * * @type {string} * @memberof DublinCoreElementName */ description?: string; /** * * @type {string} * @memberof DublinCoreElementName */ publisher?: string; /** * * @type {string} * @memberof DublinCoreElementName */ contributor?: string; /** * * @type {string} * @memberof DublinCoreElementName */ type?: string; /** * * @type {string} * @memberof DublinCoreElementName */ format?: string; /** * * @type {string} * @memberof DublinCoreElementName */ identifier?: string; /** * * @type {string} * @memberof DublinCoreElementName */ source?: string; /** * * @type {string} * @memberof DublinCoreElementName */ language?: string; /** * * @type {Bbox} * @memberof DublinCoreElementName */ bbox?: Bbox; /** * * @type {string} * @memberof DublinCoreElementName */ date?: string; /** * * @type {any} * @memberof DublinCoreElementName */ coverage?: any; /** * * @type {string} * @memberof DublinCoreElementName */ coverage_centroid?: string; } /** * * @export * @interface Expression */ export interface Expression { /** * * @type {string} * @memberof Expression */ field?: string; /** * * @type {string} * @memberof Expression */ op?: Expression.OpEnum; /** * * @type {string} * @memberof Expression */ value?: string; } /** * @export * @namespace Expression */ export declare namespace Expression { /** * @export * @enum {string} */ enum OpEnum { Eq, Gte, Gt, Lte, Lt, Like, Ne, Range, Within, Notwithin, Intersects, Notintersects, } } /** * * @export * @interface Feature */ export interface Feature extends GeoJsonObject { /** * * @type {{ [key: string]: any; }} * @memberof Feature */ properties?: { [key: string]: any; }; /** * * @type {GeoJsonObject} * @memberof Feature */ geometry?: GeoJsonObject; /** * * @type {string} * @memberof Feature */ id?: string; } /** * * @export * @interface FeatureCollection */ export interface FeatureCollection extends GeoJsonObject { /** * * @type {Array} * @memberof FeatureCollection */ features?: Array; } /** * * @export * @interface Feed */ export interface Feed { /** * * @type {Person} * @memberof Feed */ author?: Person; /** * * @type {Person} * @memberof Feed */ contributor?: Person; /** * * @type {string} * @memberof Feed */ icon?: string; /** * * @type {string} * @memberof Feed */ logo?: string; /** * * @type {string} * @memberof Feed */ rights?: string; /** * * @type {string} * @memberof Feed */ subtitle?: string; /** * * @type {Generator} * @memberof Feed */ generator?: Generator; } /** * * @export * @interface Filter */ export interface Filter { /** * * @type {Array>} * @memberof Filter */ f?: Array>; /** * * @type {Array>} * @memberof Filter */ q?: Array>; /** * * @type {string} * @memberof Filter */ dateformat?: string; /** * * @type {boolean} * @memberof Filter */ righthand?: boolean; } /** * * @export * @interface Form */ export interface Form { /** * * @type {boolean} * @memberof Form */ pretty?: boolean; /** * * @type {boolean} * @memberof Form */ flat?: boolean; } /** * * @export * @interface FormDataContentDisposition */ export interface FormDataContentDisposition { /** * * @type {string} * @memberof FormDataContentDisposition */ type?: string; /** * * @type {{ [key: string]: string; }} * @memberof FormDataContentDisposition */ parameters?: { [key: string]: string; }; /** * * @type {string} * @memberof FormDataContentDisposition */ file_name?: string; /** * * @type {Date} * @memberof FormDataContentDisposition */ creation_date?: Date; /** * * @type {Date} * @memberof FormDataContentDisposition */ modification_date?: Date; /** * * @type {Date} * @memberof FormDataContentDisposition */ read_date?: Date; /** * * @type {number} * @memberof FormDataContentDisposition */ size?: number; /** * * @type {string} * @memberof FormDataContentDisposition */ name?: string; } /** * * @export * @interface Generator */ export interface Generator { /** * * @type {string} * @memberof Generator */ name?: string; /** * * @type {string} * @memberof Generator */ version?: string; /** * * @type {string} * @memberof Generator */ uri?: string; } /** * * @export * @interface Geo */ export interface Geo { /** * * @type {string} * @memberof Geo */ path?: string; /** * * @type {GeoJsonObject} * @memberof Geo */ geometry?: GeoJsonObject; } /** * * @export * @interface GeoJsonObject */ export interface GeoJsonObject { /** * * @type {Crs} * @memberof GeoJsonObject */ crs?: Crs; /** * * @type {Array} * @memberof GeoJsonObject */ bbox?: Array; /** * * @type {string} * @memberof GeoJsonObject */ type: string; } /** * * @export * @interface GeometryCollection */ export interface GeometryCollection extends GeoJsonObject { /** * * @type {Array} * @memberof GeometryCollection */ geometries?: Array; } /** * * @export * @interface Hits */ export interface Hits { /** * * @type {string} * @memberof Hits */ collection?: string; /** * * @type {Array} * @memberof Hits */ hits?: Array; /** * * @type {number} * @memberof Hits */ nbhits?: number; /** * * @type {number} * @memberof Hits */ totalnb?: number; /** * * @type {{ [key: string]: Link; }} * @memberof Hits */ links?: { [key: string]: Link; }; } /** * * @export * @interface HitsFetcher */ export interface HitsFetcher { /** * * @type {number} * @memberof HitsFetcher */ size?: number; /** * * @type {Array} * @memberof HitsFetcher */ include?: Array; } /** * * @export * @interface Inspire */ export interface Inspire { /** * * @type {Array} * @memberof Inspire */ keywords?: Array; /** * * @type {Array} * @memberof Inspire */ topic_categories?: Array; /** * * @type {string} * @memberof Inspire */ lineage?: string; /** * * @type {Array} * @memberof Inspire */ languages?: Array; /** * * @type {InspireSpatialResolution} * @memberof Inspire */ spatial_resolution?: InspireSpatialResolution; /** * * @type {InspireURI} * @memberof Inspire */ inspire_uri?: InspireURI; /** * * @type {InspireLimitationAccess} * @memberof Inspire */ inspire_limitation_access?: InspireLimitationAccess; /** * * @type {string} * @memberof Inspire */ inspire_use_conditions?: string; } /** * * @export * @interface InspireLimitationAccess */ export interface InspireLimitationAccess { /** * * @type {string} * @memberof InspireLimitationAccess */ access_constraints?: string; /** * * @type {string} * @memberof InspireLimitationAccess */ other_constraints?: string; /** * * @type {string} * @memberof InspireLimitationAccess */ classification?: string; } /** * * @export * @interface InspireSpatialResolution */ export interface InspireSpatialResolution { /** * * @type {number} * @memberof InspireSpatialResolution */ value?: number; /** * * @type {string} * @memberof InspireSpatialResolution */ unit_of_measure?: string; } /** * * @export * @interface InspireURI */ export interface InspireURI { /** * * @type {string} * @memberof InspireURI */ code?: string; /** * * @type {string} * @memberof InspireURI */ namespace?: string; } /** * * @export * @interface Interval */ export interface Interval { /** * * @type {number} * @memberof Interval */ value?: number; /** * * @type {string} * @memberof Interval */ unit?: Interval.UnitEnum; } /** * @export * @namespace Interval */ export declare namespace Interval { /** * @export * @enum {string} */ enum UnitEnum { Year, Quarter, Month, Week, Day, Hour, Minute, Second, } } /** * * @export * @interface JSONObject */ export interface JSONObject { } /** * * @export * @interface Keyword */ export interface Keyword { /** * * @type {string} * @memberof Keyword */ value?: string; /** * * @type {string} * @memberof Keyword */ vocabulary?: string; /** * * @type {string} * @memberof Keyword */ date_of_publication?: string; } /** * * @export * @interface LineString */ export interface LineString extends GeoJsonObject { /** * * @type {Array} * @memberof LineString */ coordinates?: Array; } /** * * @export * @interface Link */ export interface Link { /** * * @type {string} * @memberof Link */ href: string; /** * * @type {string} * @memberof Link */ method: string; /** * * @type {any} * @memberof Link */ body?: any; } /** * * @export * @interface LngLatAlt */ export interface LngLatAlt { /** * * @type {number} * @memberof LngLatAlt */ longitude?: number; /** * * @type {number} * @memberof LngLatAlt */ latitude?: number; /** * * @type {number} * @memberof LngLatAlt */ altitude?: number; /** * * @type {Array} * @memberof LngLatAlt */ additional_elements?: Array; } /** * * @export * @interface MD */ export interface MD { /** * * @type {string} * @memberof MD */ id?: string; /** * * @type {number} * @memberof MD */ timestamp?: number; /** * * @type {GeoJsonObject} * @memberof MD */ geometry?: GeoJsonObject; /** * * @type {GeoJsonObject} * @memberof MD */ centroid?: GeoJsonObject; /** * * @type {Array} * @memberof MD */ returned_geometries?: Array; } /** * * @export * @interface Metric */ export interface Metric { /** * * @type {string} * @memberof Metric */ collect_field?: string; /** * * @type {string} * @memberof Metric */ collect_fct?: Metric.CollectFctEnum; } /** * @export * @namespace Metric */ export declare namespace Metric { /** * @export * @enum {string} */ enum CollectFctEnum { AVG, CARDINALITY, MAX, MIN, SUM, GEOCENTROID, GEOBBOX, } } /** * * @export * @interface ModelError */ export interface ModelError { /** * * @type {number} * @memberof ModelError */ status?: number; /** * * @type {string} * @memberof ModelError */ message?: string; /** * * @type {string} * @memberof ModelError */ error?: string; } /** * * @export * @interface MultiLineString */ export interface MultiLineString extends GeoJsonObject { /** * * @type {Array>} * @memberof MultiLineString */ coordinates?: Array>; } /** * * @export * @interface MultiPoint */ export interface MultiPoint extends GeoJsonObject { /** * * @type {Array} * @memberof MultiPoint */ coordinates?: Array; } /** * * @export * @interface MultiPolygon */ export interface MultiPolygon extends GeoJsonObject { /** * * @type {Array>>} * @memberof MultiPolygon */ coordinates?: Array>>; } /** * * @export */ export declare type MultiValueFilterExpression = Array; /** * * @export */ export declare type MultiValueFilterString = Array; /** * * @export * @interface OpenSearch */ export interface OpenSearch { /** * * @type {string} * @memberof OpenSearch */ short_name?: string; /** * * @type {string} * @memberof OpenSearch */ description?: string; /** * * @type {string} * @memberof OpenSearch */ contact?: string; /** * * @type {string} * @memberof OpenSearch */ tags?: string; /** * * @type {string} * @memberof OpenSearch */ long_name?: string; /** * * @type {string} * @memberof OpenSearch */ image_height?: string; /** * * @type {string} * @memberof OpenSearch */ image_width?: string; /** * * @type {string} * @memberof OpenSearch */ image_type?: string; /** * * @type {string} * @memberof OpenSearch */ image_url?: string; /** * * @type {string} * @memberof OpenSearch */ developer?: string; /** * * @type {string} * @memberof OpenSearch */ attribution?: string; /** * * @type {string} * @memberof OpenSearch */ syndication_right?: string; /** * * @type {string} * @memberof OpenSearch */ adult_content?: string; /** * * @type {string} * @memberof OpenSearch */ language?: string; /** * * @type {string} * @memberof OpenSearch */ input_encoding?: string; /** * * @type {string} * @memberof OpenSearch */ output_encoding?: string; } /** * * @export * @interface Page */ export interface Page { /** * * @type {number} * @memberof Page */ size?: number; /** * * @type {number} * @memberof Page */ from?: number; /** * * @type {string} * @memberof Page */ sort?: string; /** * * @type {string} * @memberof Page */ after?: string; /** * * @type {string} * @memberof Page */ before?: string; } /** * * @export * @interface Person */ export interface Person { /** * * @type {string} * @memberof Person */ name?: string; /** * * @type {string} * @memberof Person */ email?: string; /** * * @type {string} * @memberof Person */ uri?: string; } /** * * @export * @interface Point */ export interface Point extends GeoJsonObject { /** * * @type {LngLatAlt} * @memberof Point */ coordinates?: LngLatAlt; } /** * * @export * @interface Polygon */ export interface Polygon extends GeoJsonObject { /** * * @type {Array>} * @memberof Polygon */ coordinates?: Array>; } /** * * @export * @interface Projection */ export interface Projection { /** * * @type {string} * @memberof Projection */ includes?: string; /** * * @type {string} * @memberof Projection */ excludes?: string; } /** * * @export * @interface RasterTileURL */ export interface RasterTileURL { /** * * @type {string} * @memberof RasterTileURL */ url: string; /** * * @type {string} * @memberof RasterTileURL */ id_path: string; /** * * @type {number} * @memberof RasterTileURL */ min_z?: number; /** * * @type {number} * @memberof RasterTileURL */ max_z?: number; /** * * @type {boolean} * @memberof RasterTileURL */ check_geometry?: boolean; } /** * * @export * @interface RawGeometry */ export interface RawGeometry { /** * * @type {string} * @memberof RawGeometry */ geometry?: string; /** * * @type {string} * @memberof RawGeometry */ sort?: string; /** * * @type {string} * @memberof RawGeometry */ signed_sort?: string; /** * * @type {Array} * @memberof RawGeometry */ include?: Array; } /** * * @export * @interface ReturnedGeometry */ export interface ReturnedGeometry { /** * * @type {string} * @memberof ReturnedGeometry */ reference?: string; /** * * @type {GeoJsonObject} * @memberof ReturnedGeometry */ geometry?: GeoJsonObject; /** * * @type {string} * @memberof ReturnedGeometry */ sort?: string; /** * * @type {boolean} * @memberof ReturnedGeometry */ is_raw?: boolean; } /** * * @export * @interface Search */ export interface Search { /** * * @type {Array} * @memberof Search */ partition_filter?: Array; /** * * @type {Filter} * @memberof Search */ filter?: Filter; /** * * @type {Form} * @memberof Search */ form?: Form; /** * * @type {Page} * @memberof Search */ page?: Page; /** * * @type {Projection} * @memberof Search */ projection?: Projection; /** * * @type {string} * @memberof Search */ returned_geometries?: string; } /** * * @export * @interface Success */ export interface Success { /** * * @type {number} * @memberof Success */ status?: number; /** * * @type {string} * @memberof Success */ message?: string; } /** * CollectionsApi - fetch parameter creator * @export */ export declare const CollectionsApiFetchParamCreator: (configuration?: Configuration) => { _delete(collection: string, pretty?: boolean, options?: any): FetchArgs; exportCollections(options?: any): FetchArgs; get(collection: string, pretty?: boolean, options?: any): FetchArgs; getAll(pretty?: boolean, options?: any): FetchArgs; importCollections(file?: FormDataContentDisposition, options?: any): FetchArgs; patch(body: CollectionReferenceUpdateOrg, collection: string, pretty?: boolean, options?: any): FetchArgs; patchCollectionDisplayName(body: string, collection: string, pretty?: boolean, options?: any): FetchArgs; patchFieldsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): FetchArgs; patchShapeColumnsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): FetchArgs; put(body: CollectionReferenceParameters, collection: string, pretty?: boolean, checkfields?: boolean, options?: any): FetchArgs; }; /** * CollectionsApi - functional programming interface * @export */ export declare const CollectionsApiFp: (configuration?: Configuration) => { _delete(collection: string, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; exportCollections(options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; get(collection: string, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; getAll(pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; importCollections(file?: FormDataContentDisposition, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; patch(body: CollectionReferenceUpdateOrg, collection: string, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; patchCollectionDisplayName(body: string, collection: string, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; patchFieldsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; patchShapeColumnsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; put(body: CollectionReferenceParameters, collection: string, pretty?: boolean, checkfields?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; }; /** * CollectionsApi - factory interface * @export */ export declare const CollectionsApiFactory: (configuration?: Configuration, fetch?: FetchAPI, basePath?: string) => { _delete(collection: string, pretty?: boolean, options?: any): Promise; exportCollections(options?: any): Promise; get(collection: string, pretty?: boolean, options?: any): Promise; getAll(pretty?: boolean, options?: any): Promise; importCollections(file?: FormDataContentDisposition, options?: any): Promise; patch(body: CollectionReferenceUpdateOrg, collection: string, pretty?: boolean, options?: any): Promise; patchCollectionDisplayName(body: string, collection: string, pretty?: boolean, options?: any): Promise; patchFieldsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): Promise; patchShapeColumnsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): Promise; put(body: CollectionReferenceParameters, collection: string, pretty?: boolean, checkfields?: boolean, options?: any): Promise; }; /** * CollectionsApi - object-oriented interface * @export * @class CollectionsApi * @extends {BaseAPI} */ export declare class CollectionsApi extends BaseAPI { /** * Delete a collection reference in ARLAS * @summary Delete a collection reference * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ _delete(collection: string, pretty?: boolean, options?: any): Promise; /** * Get all collection references in ARLAS as json file * @summary Get all collection references as a json file * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ exportCollections(options?: any): Promise; /** * Get a collection reference in ARLAS * @summary Get a collection reference * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ get(collection: string, pretty?: boolean, options?: any): Promise; /** * Get all collection references in ARLAS * @summary Get all collection references * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ getAll(pretty?: boolean, options?: any): Promise; /** * Add collection references in ARLAS from a json file * @summary Add collection references from a json file * @param {FormDataContentDisposition} [file] * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ importCollections(file?: FormDataContentDisposition, options?: any): Promise; /** * Update a collection reference's organisations attribute. * @summary Update a collection reference's organisations attribute. * @param {CollectionReferenceUpdateOrg} body organisationsParamsUpdate * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ patch(body: CollectionReferenceUpdateOrg, collection: string, pretty?: boolean, options?: any): Promise; /** * Update a collection reference's display collection name attribute. * @summary Update a collection reference's display collection name attribute. * @param {string} body collectionDisplayName * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ patchCollectionDisplayName(body: string, collection: string, pretty?: boolean, options?: any): Promise; /** * Update a collection reference's display fields name attribute. * @summary Update a collection reference's display fields name attribute. * @param {{ [key: string]: string; }} body fieldsDisplayNames * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ patchFieldsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): Promise; /** * Update a collection reference's display shape columns name attribute. * @summary Update a collection reference's display shape columns name attribute. * @param {{ [key: string]: string; }} body shapeColumnsDisplayNames * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ patchShapeColumnsDisplayNames(body: { [key: string]: string; }, collection: string, pretty?: boolean, options?: any): Promise; /** * Add a collection reference in ARLAS * @summary Add a collection reference * @param {CollectionReferenceParameters} body collectionParams * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {boolean} [checkfields] * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof CollectionsApi */ put(body: CollectionReferenceParameters, collection: string, pretty?: boolean, checkfields?: boolean, options?: any): Promise; } /** * ExploreApi - fetch parameter creator * @export */ export declare const ExploreApiFetchParamCreator: (configuration?: Configuration) => { aggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): FetchArgs; aggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; compute(collection: string, field: string, metric: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; computePost(collection: string, body?: ComputationRequest, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; count(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; countPost(collection: string, body?: Count, pretty?: boolean, options?: any): FetchArgs; describe(collection: string, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; geoaggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): FetchArgs; geoaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; geohashgeoaggregate(collection: string, geohash: string, agg?: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): FetchArgs; geosearch(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): FetchArgs; geosearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; geotilegeoaggregate(collection: string, z: number, x: number, y: number, agg?: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): FetchArgs; getArlasHit(collection: string, identifier: string, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): FetchArgs; list(pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; search(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): FetchArgs; searchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; shapeaggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; shapeaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; shapesearch(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): FetchArgs; shapesearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): FetchArgs; suggest(collections: string, f?: string[], q?: string, pretty?: boolean, size?: number, from?: number, field?: string, max_age_cache?: number, options?: any): FetchArgs; tiledgeosearch(collection: string, x: number, y: number, z: number, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): FetchArgs; tiledgeosearch1(collection: string, x: number, y: number, z: number, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, size?: number, from?: number, sort?: string, after?: string, before?: string, sampling?: number, coverage?: number, max_age_cache?: number, options?: any): FetchArgs; }; /** * ExploreApi - functional programming interface * @export */ export declare const ExploreApiFp: (configuration?: Configuration) => { aggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; aggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; compute(collection: string, field: string, metric: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; computePost(collection: string, body?: ComputationRequest, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; count(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; countPost(collection: string, body?: Count, pretty?: boolean, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; describe(collection: string, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; geoaggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; geoaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; geohashgeoaggregate(collection: string, geohash: string, agg?: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; geosearch(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; geosearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; geotilegeoaggregate(collection: string, z: number, x: number, y: number, agg?: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; getArlasHit(collection: string, identifier: string, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; list(pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; search(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; searchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; shapeaggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; shapeaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; shapesearch(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; shapesearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; suggest(collections: string, f?: string[], q?: string, pretty?: boolean, size?: number, from?: number, field?: string, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; tiledgeosearch(collection: string, x: number, y: number, z: number, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; tiledgeosearch1(collection: string, x: number, y: number, z: number, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, size?: number, from?: number, sort?: string, after?: string, before?: string, sampling?: number, coverage?: number, max_age_cache?: number, options?: any): (fetch?: FetchAPI, basePath?: string) => Promise; }; /** * ExploreApi - factory interface * @export */ export declare const ExploreApiFactory: (configuration?: Configuration, fetch?: FetchAPI, basePath?: string) => { aggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; aggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; compute(collection: string, field: string, metric: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): Promise; computePost(collection: string, body?: ComputationRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; count(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): Promise; countPost(collection: string, body?: Count, pretty?: boolean, options?: any): Promise; describe(collection: string, pretty?: boolean, max_age_cache?: number, options?: any): Promise; geoaggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; geoaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; geohashgeoaggregate(collection: string, geohash: string, agg?: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; geosearch(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; geosearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): Promise; geotilegeoaggregate(collection: string, z: number, x: number, y: number, agg?: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; getArlasHit(collection: string, identifier: string, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; list(pretty?: boolean, max_age_cache?: number, options?: any): Promise; search(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; searchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): Promise; shapeaggregate(collection: string, agg: string[], f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): Promise; shapeaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; shapesearch(collection: string, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; shapesearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): Promise; suggest(collections: string, f?: string[], q?: string, pretty?: boolean, size?: number, from?: number, field?: string, max_age_cache?: number, options?: any): Promise; tiledgeosearch(collection: string, x: number, y: number, z: number, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; tiledgeosearch1(collection: string, x: number, y: number, z: number, f?: string[], q?: string[], dateformat?: string, righthand?: boolean, size?: number, from?: number, sort?: string, after?: string, before?: string, sampling?: number, coverage?: number, max_age_cache?: number, options?: any): Promise; }; /** * ExploreApi - object-oriented interface * @export * @class ExploreApi * @extends {BaseAPI} */ export declare class ExploreApi extends BaseAPI { /** * Aggregate the elements in the collection(s), given the filters and the aggregation parameters * @summary Aggregate * @param {string} collection collection * @param {Array} agg - The agg parameter should be given in the following formats: {type}:{field}:interval-{interval}:format-{format}:collect_field-{collect_field}:collect_fct-{function}:order-{order}:on-{on}:size-{size}:fetch_hits-{fetch_hits values} Where : - **{type}:{field}** part is mandatory. - **interval** must be specified only when aggregation type is datehistogram, histogram, geotile and geohash. - **format** is optional for datehistogram, and must not be specified for the other types. - (**collect_field**,**collect_fct**) couple is optional for all aggregation types. - It's possible to apply multiple metric aggregations by defining multiple (**collect_field**,**collect_fct**) couples. - (**collect_field**,**collect_fct**) couples should be unique in that case. - (**order**,**on**) couple is optional for all aggregation types. - **size** is optional for term and geohash/geotile, and must not be specified for the other types. - **include** is optional for term, and must not be specified for the other types. - {type} possible values are : datehistogram, histogram, geohash, geotile and term. - {interval} possible values depends on {type}. If {type} = datehistogram, then {interval} = {size}(year,quarter,month,week,day,hour,minute,second). Size value must be equal to 1 for year,quarter,month and week unities. If {type} = histogram, then {interval} = {size}. If {type} = geohash, then {interval} = {size}. It's an integer between 1 and 12. Lower the length, greater is the surface of aggregation. If {type} = geotile, then {interval} = {size}. It's an integer corresponding to zoom level of the aggregation, that should be larger than or equal to {z} in the path param, and no bigger than {z}+6. If {type} = term, then interval-{interval} is not needed. - format-{format} is the date format for key aggregation. The default value is yyyy-MM-dd-hh:mm:ss. - {collect_fct} is the aggregation function to apply to collections on the specified {collect_field}. {collect_fct} possible values are : avg,cardinality,max,min,sum - {order} is set to sort the aggregation buckets on the field name, on the count of the buckets or on the the result of a metric sub-aggregation. Its values are 'asc' or 'desc'. - {on} is set to specify whether the {order} is on the field name, on the count of the aggregation or on the result of a metric sub-aggregation. Its values are 'field', 'count' or 'result'. - If {on} is equal to `result` and two or more (**collect_field**,**collect_fct**) couples are specified, then the order is applied on the first `collect_fct` that is different from geobbox and geocentroid - {size} Defines how many buckets should be returned. - {include} Specifies the values for which buckets will be created. This values are comma separated. If one value is specified then regular expressions can be used (only in this case) and buckets matching them will be created. If more than one value are specified then only buckets matching the exact values will be created. - **aggregated_geometries** > **What it does**: Allows to specify a list of aggregated forms of geometries that represent the bucket. > __**Syntax**__: `aggregated_geometries-{COMMA_SEPARATED_AGGREGATED_GEOMETRIES}`. > __**Available aggregated geometries**__: `centroid, bbox, cell, cell_center`. - **centroid**: returns the centroid of data inside the bucket. - **bbox**: returns the data extent (bbox) in each bucket. - **cell**: returns the cell extent (zxy or geohash) of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. - **cell_center**: returns the cell center of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. > __**Response**__: the aggregated geometries are returned in `geometries` list in the json response. Each object inside this list has : the reference to the aggregated form, the geojson geometry and an attribute `is_raw` set to false > __**Example**__: `aggregated_geometries-bbox,cell` - **raw_geometries** > **What it does**: Allows to specify a list of raw geometries provided by hits that represent the bucket and that are elected by a sort > __**Syntax**__: `raw_geometries-{GEOMETRY_FIELD}({COMMA_SEPERATED_SORT_FIELDS});{GEOMETRY_FIELD2}({COMMA_SEPERATED_SORT_FIELDS2})`. > __**Available raw geometries**__: any field of the collection whose type is **geo-point** or **geo-shape**. - sort fields are optional. If no sort is specified, an ascending sort on `collection.params.timestamp_path` is applied - a sort field can be preceded by '-' for descending sort. Otherwise the sort is ascending > __**Response**__: the aggregated geometries are returned in `geometries` list in the json response. Each object inside this list has : the reference to the geometry path, the used sort, the geojson geometry and an attribute `is_raw` set to true > __**Example**__: `raw_geometries-geo_field1,geo_field2 || raw_geometries-geo_field(-field1,field2)` || raw_geometries-geo_field1(field1);geo_field2(field2,field3) - **fetch_hits** > **What it does**: Specifies the number of hits to retrieve inside each aggregation bucket and which fields to include in the hits. > __**Syntax**__: `fetch_hits-{sizeOfHitsToFetch}(+{field1}, {field2}, -{field3}, ...)`. > **Note 1**: `{sizeOfHitsToFetch}` is optional, if not specified, 1 is considered as default. > **Note 2**: `{field}` can be preceded by **+** or **-** for **ascending** or **descending** sort of the hits. Order matters. > __**Example**__: `fetch_hits-3(-timestamp, geometry)`. Fetches the 3 last positions for each bucket. **agg** parameter is multiple. Every agg parameter specified is a subaggregation of the previous one : order matters. For more details, check https://gitlab.com/GISAIA.ARLAS/ARLAS-server/blob/master/doc/api/API-definition.md. * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ aggregate(collection: string, agg: Array, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s), given the filters and the aggregation parameters * @summary Aggregate * @param {string} collection collection * @param {AggregationsRequest} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ aggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Computes the given metric on a field in the collection, given the filters * @summary Compute * @param {string} collection collection * @param {string} field The field on which the metric is calculated. * @param {string} metric The metric to compute : `max, min, avg, sum, cardinality, spanning, geobbox, geocentroid`. * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ compute(collection: string, field: string, metric: string, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Computes the given metric on a field in the collection, given the filters * @summary Compute * @param {string} collection collection * @param {ComputationRequest} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ computePost(collection: string, body?: ComputationRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Count the number of elements found in the collection(s), given the filters * @summary Count * @param {string} collection collections * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ count(collection: string, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Count the number of elements found in the collection(s), given the filters * @summary Count * @param {string} collection collections * @param {Count} [body] * @param {boolean} [pretty] Pretty print * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ countPost(collection: string, body?: Count, pretty?: boolean, options?: any): Promise; /** * Describe the structure and the content of the given collection. * @summary Describe * @param {string} collection collection * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ describe(collection: string, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s) as features, given the filters and the aggregation parameters. * @summary GeoAggregate * @param {string} collection collection * @param {Array} agg - The agg parameter should be given in the following formats: {type}:{field}:interval-{interval}:format-{format}:collect_field-{collect_field}:collect_fct-{function}:order-{order}:on-{on}:size-{size}:raw_geometries-{raw_geometries values}:aggregated_geometries-{aggregated_geometries values}:fetch_hits-{fetch_hits values} Where : - **{type}:{field}** part is mandatory. - **interval** must be specified only when aggregation type is datehistogram, histogram, geotile and geohash. - **format** is optional for datehistogram, and must not be specified for the other types. - (**collect_field**,**collect_fct**) couple is optional for all aggregation types. - (**order**,**on**) couple is optional for all aggregation types. - **size** is optional for term and geohash/geotile, and must not be specified for the other types. - **include** is optional for term, and must not be specified for the other types. - {type} possible values are : geohash, geotile, datehistogram, histogram and term. geohash or geotile must be the main aggregation. - {interval} possible values depends on {type}. If {type} = datehistogram, then {interval} = {size}(year,quarter,month,week,day,hour,minute,second). Size value must be equal to 1 for year,quarter,month and week unities. If {type} = histogram, then {interval} = {size}. If {type} = geohash, then {interval} = {size}. It's an integer between 1 and 12. Lower the length, greater is the surface of aggregation. If {type} = geotile, then {interval} = {size}. It's an integer corresponding to zoom level of the aggregation, that should be larger than or equal to {z} in the path param, and no bigger than {z}+6 (max 29). If {type} = term, then interval-{interval} is not needed. - format-{format} is the date format for key aggregation. The default value is yyyy-MM-dd-hh:mm:ss. - {collect_fct} is the aggregation function to apply to collections on the specified {collect_field}. {collect_fct} possible values are : avg,cardinality,max,min,sum,geobbox,geocentroid - (collect_field,collect_fct) should both be specified, except when collect_fct = `geobbox` or `geocentroid`, it could be specified alone. The metrics `geobbox` and `geocentroid` are returned as features collections. - {order} is set to sort the aggregation buckets on the field name, on the count of the buckets or on the the result of a metric sub-aggregation. Its values are 'asc' or 'desc'. - {on} is set to specify whether the {order} is on the field name, on the count of the aggregation or on the result of a metric sub-aggregation. Its values are 'field', 'count' or 'result'. - When {on} = `result`, then (collect_field,collect_fct) should be specified. Except when {collect_fct} = `geobbox` or `geocentroid`, then {on}=`result` is prohibited - {size} Defines how many buckets should be returned. - {include} Specifies the values for which buckets will be created. This values are comma separated. If one value is specified then regular expressions can be used (only in this case) and buckets matching them will be created. If more than one value are specified then only buckets matching the exact values will be created. - **aggregated_geometries** > **What it does**: Allows to specify a list of aggregated forms of geometries that represent the bucket. > __**Syntax**__: `aggregated_geometries-{COMMA_SEPARATED_AGGREGATED_GEOMETRIES}`. > __**Available aggregated geometries**__: `centroid, bbox, cell, cell_center`. - **centroid**: returns the centroid of data inside the bucket. - **bbox**: returns the data extent (bbox) in each bucket. - **cell**: returns the cell (zxy or geohash) extent of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. - **cell_center**: returns the cell center of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. > __**Response**__: Each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified aggregated geometries. The properties of each feature has : - **geometry_ref** attribute that informs which aggregated form is returned - **geometry_type** attribute set to *aggregated* > __**Example**__: `aggregated_geometries-bbox,geohash` - **raw_geometries** > **What it does**: Allows to specify a list of raw geometries provided by hits that represent the bucket and that are elected by a sort > __**Syntax**__: `raw_geometries-{GEOMETRY_FIELD}({COMMA_SEPERATED_SORT_FIELDS});{GEOMETRY_FIELD2}({COMMA_SEPERATED_SORT_FIELDS2})`. > __**Available raw geometries**__: any field of the collection whose type is **geo-point** or **geo-shape**. - sort fields are optional. If no sort is specified, an ascending sort on `collection.params.timestamp_path` is applied - a sort field can be preceded by '-' for descending sort. Otherwise the sort is ascending > __**Response**__: each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified raw geometries. The properties of each feature has : - **geometry_ref** attribute that informs which geometry path is returned - **geometry_type** attribute set to *raw* - **geometry_sort** attribute that informs how the geometry path is fetched (with what sort) > __**Example**__: `raw_geometries-geo_field1,geo_field2 || raw_geometries-geo_field(-field1,field2)` || raw_geometries-geo_field1(field1);geo_field2(field2,field3) - **fetch_hits** > **What it does**: Specifies the number of hits to retrieve inside each aggregation bucket and which fields to include in the hits. > __**Syntax**__: `fetch_hits-{sizeOfHitsToFetch}(+{field1}, {field2}, -{field3}, ...)`. > **Note 1**: `{sizeOfHitsToFetch}` is optional, if not specified, 1 is considered as default. > **Note 2**: `{field}` can be preceded by **+** or **-** for **ascending** or **descending** sort of the hits. Order matters. > __**Example**__: `fetch_hits-3(-timestamp, geometry)`. Fetches the 3 last positions for each bucket. **agg** parameter is multiple. The first (main) aggregation must be geohash or geotile. Every agg parameter specified is a subaggregation of the previous one : order matters. For more details, check https://github.com/gisaia/ARLAS-server/blob/master/docs/arlas-api-exploration.md * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ geoaggregate(collection: string, agg: Array, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s) as features, given the filters and the aggregation parameters. * @summary GeoAggregate * @param {string} collection collection * @param {AggregationsRequest} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ geoaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s) and localized in the given geohash as features, given the filters and the aggregation parameters. * @summary GeoAggregate on a geohash * @param {string} collection collection * @param {string} geohash geohash * @param {Array} [agg] - The agg parameter should be given in the following formats: {type}:{field}:interval-{interval}:format-{format}:collect_field-{collect_field}:collect_fct-{function}:order-{order}:on-{on}:size-{size}:raw_geometries-{raw_geometries values}:aggregated_geometries-{aggregated_geometries values}:fetch_hits-{fetch_hits values} Where : - **{type}:{field}** part is mandatory. - **interval** must be specified only when aggregation type is datehistogram, histogram, geotile and geohash. - **format** is optional for datehistogram, and must not be specified for the other types. - (**collect_field**,**collect_fct**) couple is optional for all aggregation types. - (**order**,**on**) couple is optional for all aggregation types. - **size** is optional for term and geohash/geotile, and must not be specified for the other types. - **include** is optional for term, and must not be specified for the other types. - {type} possible values are : geohash, geotile, datehistogram, histogram and term. geohash or geotile must be the main aggregation. - {interval} possible values depends on {type}. If {type} = datehistogram, then {interval} = {size}(year,quarter,month,week,day,hour,minute,second). Size value must be equal to 1 for year,quarter,month and week unities. If {type} = histogram, then {interval} = {size}. If {type} = geohash, then {interval} = {size}. It's an integer between 1 and 12. Lower the length, greater is the surface of aggregation. If {type} = geotile, then {interval} = {size}. It's an integer corresponding to zoom level of the aggregation, that should be larger than or equal to {z} in the path param, and no bigger than {z}+6 (max 29). If {type} = term, then interval-{interval} is not needed. - format-{format} is the date format for key aggregation. The default value is yyyy-MM-dd-hh:mm:ss. - {collect_fct} is the aggregation function to apply to collections on the specified {collect_field}. {collect_fct} possible values are : avg,cardinality,max,min,sum,geobbox,geocentroid - (collect_field,collect_fct) should both be specified, except when collect_fct = `geobbox` or `geocentroid`, it could be specified alone. The metrics `geobbox` and `geocentroid` are returned as features collections. - {order} is set to sort the aggregation buckets on the field name, on the count of the buckets or on the the result of a metric sub-aggregation. Its values are 'asc' or 'desc'. - {on} is set to specify whether the {order} is on the field name, on the count of the aggregation or on the result of a metric sub-aggregation. Its values are 'field', 'count' or 'result'. - When {on} = `result`, then (collect_field,collect_fct) should be specified. Except when {collect_fct} = `geobbox` or `geocentroid`, then {on}=`result` is prohibited - {size} Defines how many buckets should be returned. - {include} Specifies the values for which buckets will be created. This values are comma separated. If one value is specified then regular expressions can be used (only in this case) and buckets matching them will be created. If more than one value are specified then only buckets matching the exact values will be created. - **aggregated_geometries** > **What it does**: Allows to specify a list of aggregated forms of geometries that represent the bucket. > __**Syntax**__: `aggregated_geometries-{COMMA_SEPARATED_AGGREGATED_GEOMETRIES}`. > __**Available aggregated geometries**__: `centroid, bbox, cell, cell_center`. - **centroid**: returns the centroid of data inside the bucket. - **bbox**: returns the data extent (bbox) in each bucket. - **cell**: returns the cell (zxy or geohash) extent of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. - **cell_center**: returns the cell center of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. > __**Response**__: Each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified aggregated geometries. The properties of each feature has : - **geometry_ref** attribute that informs which aggregated form is returned - **geometry_type** attribute set to *aggregated* > __**Example**__: `aggregated_geometries-bbox,geohash` - **raw_geometries** > **What it does**: Allows to specify a list of raw geometries provided by hits that represent the bucket and that are elected by a sort > __**Syntax**__: `raw_geometries-{GEOMETRY_FIELD}({COMMA_SEPERATED_SORT_FIELDS});{GEOMETRY_FIELD2}({COMMA_SEPERATED_SORT_FIELDS2})`. > __**Available raw geometries**__: any field of the collection whose type is **geo-point** or **geo-shape**. - sort fields are optional. If no sort is specified, an ascending sort on `collection.params.timestamp_path` is applied - a sort field can be preceded by '-' for descending sort. Otherwise the sort is ascending > __**Response**__: each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified raw geometries. The properties of each feature has : - **geometry_ref** attribute that informs which geometry path is returned - **geometry_type** attribute set to *raw* - **geometry_sort** attribute that informs how the geometry path is fetched (with what sort) > __**Example**__: `raw_geometries-geo_field1,geo_field2 || raw_geometries-geo_field(-field1,field2)` || raw_geometries-geo_field1(field1);geo_field2(field2,field3) - **fetch_hits** > **What it does**: Specifies the number of hits to retrieve inside each aggregation bucket and which fields to include in the hits. > __**Syntax**__: `fetch_hits-{sizeOfHitsToFetch}(+{field1}, {field2}, -{field3}, ...)`. > **Note 1**: `{sizeOfHitsToFetch}` is optional, if not specified, 1 is considered as default. > **Note 2**: `{field}` can be preceded by **+** or **-** for **ascending** or **descending** sort of the hits. Order matters. > __**Example**__: `fetch_hits-3(-timestamp, geometry)`. Fetches the 3 last positions for each bucket. **agg** parameter is multiple. The first (main) aggregation must be geohash or geotile. Every agg parameter specified is a subaggregation of the previous one : order matters. For more details, check https://github.com/gisaia/ARLAS-server/blob/master/docs/arlas-api-exploration.md * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ geohashgeoaggregate(collection: string, geohash: string, agg?: Array, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection(s) as features, given the filters * @summary GeoSearch * @param {string} collection collection * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {string} [include] List the name patterns of the field to be included in the result. Separate patterns with a comma. * @param {string} [exclude] List the name patterns of the field to be excluded in the result. Separate patterns with a comma. * @param {string} [returned_geometries] Comma separated geometry field_paths to be included in the result. If not specified, only geometry_path is returned. If geometry_path is null, then centroid_path is returned * @param {number} [size] The maximum number of entries or sub-entries to be returned. The default value is 10 * @param {number} [from] From index to start the search from. Defaults to 0. * @param {string} [sort] Sorts the resulted hits on the given fields and/or by distance to a given point: > __**Syntax**__: `{field1},{field2},-{field3},geodistance:{lat} {lon},{field4} ...`. > **Note 1**: `{field}` can be preceded by **'-'** for **descending** sort. By default, sort is ascending. > **Note 2**: The order of fields matters. > **Note 3** ***geodistance sort***: Sorts the hits centroids by distance to the given **{lat} {lon}** (ascending distance sort). It can be specified at most 1 time. > __**Example 1**__: sort=`age,-timestamp`. Resulted hits are sorted by age. For same age hits, they are decreasingly sorted in time. > __**Example 2**__: sort=`age,geodistance:89 179`. Resulted hits are sorted by age. For same age hits, they are sorted by closest distance to the point(89°,179°) * @param {string} [after] List of values of fields present in sort param that are used to search after. > **What it does**: Retrieve the data placed after the pointed element, given the provided order (sort). > __**Restriction 1**__: **after** param works only combined with **sort** param. > __**Syntax**__: `after={value1},{value2},...,{valueN} & sort={field1},{field2},...,{fieldN}`. > **Note 1**: *{value1}` and `{value2}` are the values of `{field1}` and `{field2}` in the last hit returned in the previous search > **Note 2**: The order of fields and values matters. *{value1},{value2}* must be in the same order of *{field1},{field2}* in **sort** param > **Note 3**: The last field `{fieldN}` must be the id field specified in the collection **collection.params.idPath** (returned as **md.id**) and `{valueN}` its corresponding value. > __**Example**__: *sort=`-date,id` & **after**=`01/02/2019,abcd1234`*. Gets the following hits of the previous search that stopped at date *01/02/2019* and id *abcd1234*. > __**Restriction 2**__: **from** param must be set to 0 or kept unset * @param {string} [before] Same idea that after param, but to retrieve the data placed before the pointed element, given the provided order (sort). * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ geosearch(collection: string, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection(s) as features, given the filters * @summary GeoSearch * @param {string} collection collection * @param {Search} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ geosearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s) and localized in the given tile as features, given the filters and the aggregation parameters. * @summary GeoAggregate on a geotile * @param {string} collection collection * @param {number} z z * @param {number} x x * @param {number} y y * @param {Array} [agg] - The agg parameter should be given in the following formats: {type}:{field}:interval-{interval}:format-{format}:collect_field-{collect_field}:collect_fct-{function}:order-{order}:on-{on}:size-{size}:raw_geometries-{raw_geometries values}:aggregated_geometries-{aggregated_geometries values}:fetch_hits-{fetch_hits values} Where : - **{type}:{field}** part is mandatory. - **interval** must be specified only when aggregation type is datehistogram, histogram, geotile and geohash. - **format** is optional for datehistogram, and must not be specified for the other types. - (**collect_field**,**collect_fct**) couple is optional for all aggregation types. - (**order**,**on**) couple is optional for all aggregation types. - **size** is optional for term and geohash/geotile, and must not be specified for the other types. - **include** is optional for term, and must not be specified for the other types. - {type} possible values are : geohash, geotile, datehistogram, histogram and term. geohash or geotile must be the main aggregation. - {interval} possible values depends on {type}. If {type} = datehistogram, then {interval} = {size}(year,quarter,month,week,day,hour,minute,second). Size value must be equal to 1 for year,quarter,month and week unities. If {type} = histogram, then {interval} = {size}. If {type} = geohash, then {interval} = {size}. It's an integer between 1 and 12. Lower the length, greater is the surface of aggregation. If {type} = geotile, then {interval} = {size}. It's an integer corresponding to zoom level of the aggregation, that should be larger than or equal to {z} in the path param, and no bigger than {z}+6 (max 29). If {type} = term, then interval-{interval} is not needed. - format-{format} is the date format for key aggregation. The default value is yyyy-MM-dd-hh:mm:ss. - {collect_fct} is the aggregation function to apply to collections on the specified {collect_field}. {collect_fct} possible values are : avg,cardinality,max,min,sum,geobbox,geocentroid - (collect_field,collect_fct) should both be specified, except when collect_fct = `geobbox` or `geocentroid`, it could be specified alone. The metrics `geobbox` and `geocentroid` are returned as features collections. - {order} is set to sort the aggregation buckets on the field name, on the count of the buckets or on the the result of a metric sub-aggregation. Its values are 'asc' or 'desc'. - {on} is set to specify whether the {order} is on the field name, on the count of the aggregation or on the result of a metric sub-aggregation. Its values are 'field', 'count' or 'result'. - When {on} = `result`, then (collect_field,collect_fct) should be specified. Except when {collect_fct} = `geobbox` or `geocentroid`, then {on}=`result` is prohibited - {size} Defines how many buckets should be returned. - {include} Specifies the values for which buckets will be created. This values are comma separated. If one value is specified then regular expressions can be used (only in this case) and buckets matching them will be created. If more than one value are specified then only buckets matching the exact values will be created. - **aggregated_geometries** > **What it does**: Allows to specify a list of aggregated forms of geometries that represent the bucket. > __**Syntax**__: `aggregated_geometries-{COMMA_SEPARATED_AGGREGATED_GEOMETRIES}`. > __**Available aggregated geometries**__: `centroid, bbox, cell, cell_center`. - **centroid**: returns the centroid of data inside the bucket. - **bbox**: returns the data extent (bbox) in each bucket. - **cell**: returns the cell (zxy or geohash) extent of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. - **cell_center**: returns the cell center of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. > __**Response**__: Each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified aggregated geometries. The properties of each feature has : - **geometry_ref** attribute that informs which aggregated form is returned - **geometry_type** attribute set to *aggregated* > __**Example**__: `aggregated_geometries-bbox,geohash` - **raw_geometries** > **What it does**: Allows to specify a list of raw geometries provided by hits that represent the bucket and that are elected by a sort > __**Syntax**__: `raw_geometries-{GEOMETRY_FIELD}({COMMA_SEPERATED_SORT_FIELDS});{GEOMETRY_FIELD2}({COMMA_SEPERATED_SORT_FIELDS2})`. > __**Available raw geometries**__: any field of the collection whose type is **geo-point** or **geo-shape**. - sort fields are optional. If no sort is specified, an ascending sort on `collection.params.timestamp_path` is applied - a sort field can be preceded by '-' for descending sort. Otherwise the sort is ascending > __**Response**__: each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified raw geometries. The properties of each feature has : - **geometry_ref** attribute that informs which geometry path is returned - **geometry_type** attribute set to *raw* - **geometry_sort** attribute that informs how the geometry path is fetched (with what sort) > __**Example**__: `raw_geometries-geo_field1,geo_field2 || raw_geometries-geo_field(-field1,field2)` || raw_geometries-geo_field1(field1);geo_field2(field2,field3) - **fetch_hits** > **What it does**: Specifies the number of hits to retrieve inside each aggregation bucket and which fields to include in the hits. > __**Syntax**__: `fetch_hits-{sizeOfHitsToFetch}(+{field1}, {field2}, -{field3}, ...)`. > **Note 1**: `{sizeOfHitsToFetch}` is optional, if not specified, 1 is considered as default. > **Note 2**: `{field}` can be preceded by **+** or **-** for **ascending** or **descending** sort of the hits. Order matters. > __**Example**__: `fetch_hits-3(-timestamp, geometry)`. Fetches the 3 last positions for each bucket. **agg** parameter is multiple. The first (main) aggregation must be geohash or geotile. Every agg parameter specified is a subaggregation of the previous one : order matters. For more details, check https://github.com/gisaia/ARLAS-server/blob/master/docs/arlas-api-exploration.md * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ geotilegeoaggregate(collection: string, z: number, x: number, y: number, agg?: Array, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; /** * Returns a raw indexed document. * @summary Get an Arlas document * @param {string} collection collection * @param {string} identifier identifier * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ getArlasHit(collection: string, identifier: string, pretty?: boolean, flat?: boolean, max_age_cache?: number, options?: any): Promise; /** * List the collections configured in ARLAS. * @summary List * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ list(pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection, given the filters * @summary Search * @param {string} collection collection * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {string} [include] List the name patterns of the field to be included in the result. Separate patterns with a comma. * @param {string} [exclude] List the name patterns of the field to be excluded in the result. Separate patterns with a comma. * @param {string} [returned_geometries] Comma separated geometry field_paths to be included in the result. If not specified, only geometry_path is returned. If geometry_path is null, then centroid_path is returned * @param {number} [size] The maximum number of entries or sub-entries to be returned. The default value is 10 * @param {number} [from] From index to start the search from. Defaults to 0. * @param {string} [sort] Sorts the resulted hits on the given fields and/or by distance to a given point: > __**Syntax**__: `{field1},{field2},-{field3},geodistance:{lat} {lon},{field4} ...`. > **Note 1**: `{field}` can be preceded by **'-'** for **descending** sort. By default, sort is ascending. > **Note 2**: The order of fields matters. > **Note 3** ***geodistance sort***: Sorts the hits centroids by distance to the given **{lat} {lon}** (ascending distance sort). It can be specified at most 1 time. > __**Example 1**__: sort=`age,-timestamp`. Resulted hits are sorted by age. For same age hits, they are decreasingly sorted in time. > __**Example 2**__: sort=`age,geodistance:89 179`. Resulted hits are sorted by age. For same age hits, they are sorted by closest distance to the point(89°,179°) * @param {string} [after] List of values of fields present in sort param that are used to search after. > **What it does**: Retrieve the data placed after the pointed element, given the provided order (sort). > __**Restriction 1**__: **after** param works only combined with **sort** param. > __**Syntax**__: `after={value1},{value2},...,{valueN} & sort={field1},{field2},...,{fieldN}`. > **Note 1**: *{value1}` and `{value2}` are the values of `{field1}` and `{field2}` in the last hit returned in the previous search > **Note 2**: The order of fields and values matters. *{value1},{value2}* must be in the same order of *{field1},{field2}* in **sort** param > **Note 3**: The last field `{fieldN}` must be the id field specified in the collection **collection.params.idPath** (returned as **md.id**) and `{valueN}` its corresponding value. > __**Example**__: *sort=`-date,id` & **after**=`01/02/2019,abcd1234`*. Gets the following hits of the previous search that stopped at date *01/02/2019* and id *abcd1234*. > __**Restriction 2**__: **from** param must be set to 0 or kept unset * @param {string} [before] Same idea that after param, but to retrieve the data placed before the pointed element, given the provided order (sort). * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ search(collection: string, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection, given the filters * @summary Search * @param {string} collection collection * @param {Search} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ searchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s) as features, given the filters and the aggregation parameters, and returns a shapefile of it. * @summary ShapeAggregate * @param {string} collection collection * @param {Array} agg - The agg parameter should be given in the following formats: {type}:{field}:interval-{interval}:format-{format}:collect_field-{collect_field}:collect_fct-{function}:order-{order}:on-{on}:size-{size}:raw_geometries-{raw_geometries values}:aggregated_geometries-{aggregated_geometries values}:fetch_hits-{fetch_hits values} Where : - **{type}:{field}** part is mandatory. - **interval** must be specified only when aggregation type is datehistogram, histogram, geotile and geohash. - **format** is optional for datehistogram, and must not be specified for the other types. - (**collect_field**,**collect_fct**) couple is optional for all aggregation types. - (**order**,**on**) couple is optional for all aggregation types. - **size** is optional for term and geohash/geotile, and must not be specified for the other types. - **include** is optional for term, and must not be specified for the other types. - {type} possible values are : geohash, geotile, datehistogram, histogram and term. geohash or geotile must be the main aggregation. - {interval} possible values depends on {type}. If {type} = datehistogram, then {interval} = {size}(year,quarter,month,week,day,hour,minute,second). Size value must be equal to 1 for year,quarter,month and week unities. If {type} = histogram, then {interval} = {size}. If {type} = geohash, then {interval} = {size}. It's an integer between 1 and 12. Lower the length, greater is the surface of aggregation. If {type} = geotile, then {interval} = {size}. It's an integer corresponding to zoom level of the aggregation, that should be larger than or equal to {z} in the path param, and no bigger than {z}+6 (max 29). If {type} = term, then interval-{interval} is not needed. - format-{format} is the date format for key aggregation. The default value is yyyy-MM-dd-hh:mm:ss. - {collect_fct} is the aggregation function to apply to collections on the specified {collect_field}. {collect_fct} possible values are : avg,cardinality,max,min,sum,geobbox,geocentroid - (collect_field,collect_fct) should both be specified, except when collect_fct = `geobbox` or `geocentroid`, it could be specified alone. The metrics `geobbox` and `geocentroid` are returned as features collections. - {order} is set to sort the aggregation buckets on the field name, on the count of the buckets or on the the result of a metric sub-aggregation. Its values are 'asc' or 'desc'. - {on} is set to specify whether the {order} is on the field name, on the count of the aggregation or on the result of a metric sub-aggregation. Its values are 'field', 'count' or 'result'. - When {on} = `result`, then (collect_field,collect_fct) should be specified. Except when {collect_fct} = `geobbox` or `geocentroid`, then {on}=`result` is prohibited - {size} Defines how many buckets should be returned. - {include} Specifies the values for which buckets will be created. This values are comma separated. If one value is specified then regular expressions can be used (only in this case) and buckets matching them will be created. If more than one value are specified then only buckets matching the exact values will be created. - **aggregated_geometries** > **What it does**: Allows to specify a list of aggregated forms of geometries that represent the bucket. > __**Syntax**__: `aggregated_geometries-{COMMA_SEPARATED_AGGREGATED_GEOMETRIES}`. > __**Available aggregated geometries**__: `centroid, bbox, cell, cell_center`. - **centroid**: returns the centroid of data inside the bucket. - **bbox**: returns the data extent (bbox) in each bucket. - **cell**: returns the cell (zxy or geohash) extent of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. - **cell_center**: returns the cell center of each bucket. This form is supported for **geohash** and **geotile** aggregation type only. > __**Response**__: Each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified aggregated geometries. The properties of each feature has : - **geometry_ref** attribute that informs which aggregated form is returned - **geometry_type** attribute set to *aggregated* > __**Example**__: `aggregated_geometries-bbox,geohash` - **raw_geometries** > **What it does**: Allows to specify a list of raw geometries provided by hits that represent the bucket and that are elected by a sort > __**Syntax**__: `raw_geometries-{GEOMETRY_FIELD}({COMMA_SEPERATED_SORT_FIELDS});{GEOMETRY_FIELD2}({COMMA_SEPERATED_SORT_FIELDS2})`. > __**Available raw geometries**__: any field of the collection whose type is **geo-point** or **geo-shape**. - sort fields are optional. If no sort is specified, an ascending sort on `collection.params.timestamp_path` is applied - a sort field can be preceded by '-' for descending sort. Otherwise the sort is ascending > __**Response**__: each bucket of the aggregation will be represented with as many features (in a feature collection) as there are specified raw geometries. The properties of each feature has : - **geometry_ref** attribute that informs which geometry path is returned - **geometry_type** attribute set to *raw* - **geometry_sort** attribute that informs how the geometry path is fetched (with what sort) > __**Example**__: `raw_geometries-geo_field1,geo_field2 || raw_geometries-geo_field(-field1,field2)` || raw_geometries-geo_field1(field1);geo_field2(field2,field3) - **fetch_hits** > **What it does**: Specifies the number of hits to retrieve inside each aggregation bucket and which fields to include in the hits. > __**Syntax**__: `fetch_hits-{sizeOfHitsToFetch}(+{field1}, {field2}, -{field3}, ...)`. > **Note 1**: `{sizeOfHitsToFetch}` is optional, if not specified, 1 is considered as default. > **Note 2**: `{field}` can be preceded by **+** or **-** for **ascending** or **descending** sort of the hits. Order matters. > __**Example**__: `fetch_hits-3(-timestamp, geometry)`. Fetches the 3 last positions for each bucket. **agg** parameter is multiple. The first (main) aggregation must be geohash or geotile. Every agg parameter specified is a subaggregation of the previous one : order matters. For more details, check https://github.com/gisaia/ARLAS-server/blob/master/docs/arlas-api-exploration.md * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ shapeaggregate(collection: string, agg: Array, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Aggregate the elements in the collection(s) as features, given the filters and the aggregation parameters, and returns a shapefile of it. * @summary ShapeAggregate * @param {string} collection collection * @param {AggregationsRequest} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ shapeaggregatePost(collection: string, body?: AggregationsRequest, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection(s) as features, given the filters, exported as a Shapefile * @summary ShapeSearch * @param {string} collection collection * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {string} [include] List the name patterns of the field to be included in the result. Separate patterns with a comma. * @param {string} [exclude] List the name patterns of the field to be excluded in the result. Separate patterns with a comma. * @param {string} [returned_geometries] Comma separated geometry field_paths to be included in the result. If not specified, only geometry_path is returned. If geometry_path is null, then centroid_path is returned * @param {number} [size] The maximum number of entries or sub-entries to be returned. The default value is 10 * @param {number} [from] From index to start the search from. Defaults to 0. * @param {string} [sort] Sorts the resulted hits on the given fields and/or by distance to a given point: > __**Syntax**__: `{field1},{field2},-{field3},geodistance:{lat} {lon},{field4} ...`. > **Note 1**: `{field}` can be preceded by **'-'** for **descending** sort. By default, sort is ascending. > **Note 2**: The order of fields matters. > **Note 3** ***geodistance sort***: Sorts the hits centroids by distance to the given **{lat} {lon}** (ascending distance sort). It can be specified at most 1 time. > __**Example 1**__: sort=`age,-timestamp`. Resulted hits are sorted by age. For same age hits, they are decreasingly sorted in time. > __**Example 2**__: sort=`age,geodistance:89 179`. Resulted hits are sorted by age. For same age hits, they are sorted by closest distance to the point(89°,179°) * @param {string} [after] List of values of fields present in sort param that are used to search after. > **What it does**: Retrieve the data placed after the pointed element, given the provided order (sort). > __**Restriction 1**__: **after** param works only combined with **sort** param. > __**Syntax**__: `after={value1},{value2},...,{valueN} & sort={field1},{field2},...,{fieldN}`. > **Note 1**: *{value1}` and `{value2}` are the values of `{field1}` and `{field2}` in the last hit returned in the previous search > **Note 2**: The order of fields and values matters. *{value1},{value2}* must be in the same order of *{field1},{field2}* in **sort** param > **Note 3**: The last field `{fieldN}` must be the id field specified in the collection **collection.params.idPath** (returned as **md.id**) and `{valueN}` its corresponding value. > __**Example**__: *sort=`-date,id` & **after**=`01/02/2019,abcd1234`*. Gets the following hits of the previous search that stopped at date *01/02/2019* and id *abcd1234*. > __**Restriction 2**__: **from** param must be set to 0 or kept unset * @param {string} [before] Same idea that after param, but to retrieve the data placed before the pointed element, given the provided order (sort). * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ shapesearch(collection: string, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection(s) as features, given the filters, exported as a Shapefile * @summary ShapeSearch * @param {string} collection collection * @param {Search} [body] * @param {boolean} [pretty] Pretty print * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ shapesearchPost(collection: string, body?: Search, pretty?: boolean, max_age_cache?: number, options?: any): Promise; /** * Suggest the the n (n=size) most relevant terms given the filters * @summary Suggest * @param {string} collections collections, comma separated * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided. The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator | Description | value type : | {fieldName} equals {value} | numeric or strings :gte: | {fieldName} is greater than or equal to {value} | numeric :gt: | {fieldName} is greater than {value} | numeric :lte: | {fieldName} is less than or equal to {value} | numeric :lt: | {fieldName} is less than {value} | numeric - The AND operator is applied between filters having different fieldNames. - The OR operator is applied on filters having the same fieldName. - If the fieldName starts with - then a must not filter is used - If the fieldName starts with - then a must not filter is used For more details, check https://gitlab.com/GISAIA.ARLAS/ARLAS-server/blob/master/doc/api/API-definition.md * @param {string} [q] A full text search * @param {boolean} [pretty] Pretty print * @param {number} [size] The maximum number of entries or sub-entries to be returned. The default value is 10 * @param {number} [from] From index to start the search from. Defaults to 0. * @param {string} [field] Name of the field to be used for retrieving the most relevant terms * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ suggest(collections: string, f?: Array, q?: string, pretty?: boolean, size?: number, from?: number, field?: string, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection(s) and localized in the given tile(x,y,z) as features, given the filters * @summary Tiled GeoSearch * @param {string} collection collection * @param {number} x x * @param {number} y y * @param {number} z z * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {boolean} [pretty] Pretty print * @param {boolean} [flat] Flats the property map: only key/value on one level * @param {string} [include] List the name patterns of the field to be included in the result. Separate patterns with a comma. * @param {string} [exclude] List the name patterns of the field to be excluded in the result. Separate patterns with a comma. * @param {string} [returned_geometries] Comma separated geometry field_paths to be included in the result. If not specified, only geometry_path is returned. If geometry_path is null, then centroid_path is returned * @param {number} [size] The maximum number of entries or sub-entries to be returned. The default value is 10 * @param {number} [from] From index to start the search from. Defaults to 0. * @param {string} [sort] Sorts the resulted hits on the given fields and/or by distance to a given point: > __**Syntax**__: `{field1},{field2},-{field3},geodistance:{lat} {lon},{field4} ...`. > **Note 1**: `{field}` can be preceded by **'-'** for **descending** sort. By default, sort is ascending. > **Note 2**: The order of fields matters. > **Note 3** ***geodistance sort***: Sorts the hits centroids by distance to the given **{lat} {lon}** (ascending distance sort). It can be specified at most 1 time. > __**Example 1**__: sort=`age,-timestamp`. Resulted hits are sorted by age. For same age hits, they are decreasingly sorted in time. > __**Example 2**__: sort=`age,geodistance:89 179`. Resulted hits are sorted by age. For same age hits, they are sorted by closest distance to the point(89°,179°) * @param {string} [after] List of values of fields present in sort param that are used to search after. > **What it does**: Retrieve the data placed after the pointed element, given the provided order (sort). > __**Restriction 1**__: **after** param works only combined with **sort** param. > __**Syntax**__: `after={value1},{value2},...,{valueN} & sort={field1},{field2},...,{fieldN}`. > **Note 1**: *{value1}` and `{value2}` are the values of `{field1}` and `{field2}` in the last hit returned in the previous search > **Note 2**: The order of fields and values matters. *{value1},{value2}* must be in the same order of *{field1},{field2}* in **sort** param > **Note 3**: The last field `{fieldN}` must be the id field specified in the collection **collection.params.idPath** (returned as **md.id**) and `{valueN}` its corresponding value. > __**Example**__: *sort=`-date,id` & **after**=`01/02/2019,abcd1234`*. Gets the following hits of the previous search that stopped at date *01/02/2019* and id *abcd1234*. > __**Restriction 2**__: **from** param must be set to 0 or kept unset * @param {string} [before] Same idea that after param, but to retrieve the data placed before the pointed element, given the provided order (sort). * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ tiledgeosearch(collection: string, x: number, y: number, z: number, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, pretty?: boolean, flat?: boolean, include?: string, exclude?: string, returned_geometries?: string, size?: number, from?: number, sort?: string, after?: string, before?: string, max_age_cache?: number, options?: any): Promise; /** * Search and return the elements found in the collection(s) and localized in the given tile(x,y,z) as features, given the filters * @summary Tiled GeoSearch * @param {string} collection collection * @param {number} x x * @param {number} y y * @param {number} z z * @param {Array} [f] - A triplet for filtering the result. Multiple filter can be provided in distinct parameters (AND operator is applied) or in the same parameter separated by semi-colons (OR operator is applied). The order does not matter. - A triplet is composed of a field name, a comparison operator and a value. The possible values of the comparison operator are : Operator -- Description -- value type :eq: -- {fieldName} equals {comma separated values}. **OR** operation is applied for the specified values -- numeric or strings :ne: -- {fieldName} must not equal {comma separated values }. **AND** operation is applied for the specified values -- numeric or strings :like: -- {fieldName} is like {value} -- numeric or strings :gte: -- {fieldName} is greater than or equal to {value} -- numeric :gt: -- {fieldName} is greater than {value} -- numeric :lte: -- {fieldName} is less than or equal to {value} -- numeric :lt: -- {fieldName} is less than {value} -- numeric :range: -- {fieldName} is between `{comma separated [min<max] values}`. **OR** operation is applied for the specified ranges -- numeric or strings. If the field's type is date, then min & max should be timestamps in millisecond or a Date expression :within: -- {GeofieldName}` is within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :notwithin: -- {GeofieldName} is not within the `{given WKT string or the given BBOX }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` :intersects: -- {GeofieldName} intersects the `{given WKT string or the given BBOX }` | a WKT string or the BBOX string : `\"west, south, east, north\"` :notintersects: -- {GeofieldName} does not intersect the `{given WKT string or the given }` -- a WKT string or the BBOX string : `\"west, south, east, north\"` * @param {Array} [q] A full text search. Optionally, it's possible to search on a field using this syntax: {fieldname}:{text} * @param {string} [dateformat] The format of dates. This parameter should be set only if a date field is queried in `f` param; when using `gt`, `lt`, `gte`, `lte` and `range` operations * @param {boolean} [righthand] If righthand = true, the passed WKT should be counter clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. Inversely, If righthand = false, the passed WKT should be clock-wise; otherwise, ARLAS-server will attempt to parse it as the \"Complementary\" Polygon on the other facet of the planet. * @param {number} [size] The maximum number of entries or sub-entries to be returned. The default value is 10 * @param {number} [from] From index to start the search from. Defaults to 0. * @param {string} [sort] Sorts the resulted hits on the given fields and/or by distance to a given point: > __**Syntax**__: `{field1},{field2},-{field3},geodistance:{lat} {lon},{field4} ...`. > **Note 1**: `{field}` can be preceded by **'-'** for **descending** sort. By default, sort is ascending. > **Note 2**: The order of fields matters. > **Note 3** ***geodistance sort***: Sorts the hits centroids by distance to the given **{lat} {lon}** (ascending distance sort). It can be specified at most 1 time. > __**Example 1**__: sort=`age,-timestamp`. Resulted hits are sorted by age. For same age hits, they are decreasingly sorted in time. > __**Example 2**__: sort=`age,geodistance:89 179`. Resulted hits are sorted by age. For same age hits, they are sorted by closest distance to the point(89°,179°) * @param {string} [after] List of values of fields present in sort param that are used to search after. > **What it does**: Retrieve the data placed after the pointed element, given the provided order (sort). > __**Restriction 1**__: **after** param works only combined with **sort** param. > __**Syntax**__: `after={value1},{value2},...,{valueN} & sort={field1},{field2},...,{fieldN}`. > **Note 1**: *{value1}` and `{value2}` are the values of `{field1}` and `{field2}` in the last hit returned in the previous search > **Note 2**: The order of fields and values matters. *{value1},{value2}* must be in the same order of *{field1},{field2}* in **sort** param > **Note 3**: The last field `{fieldN}` must be the id field specified in the collection **collection.params.idPath** (returned as **md.id**) and `{valueN}` its corresponding value. > __**Example**__: *sort=`-date,id` & **after**=`01/02/2019,abcd1234`*. Gets the following hits of the previous search that stopped at date *01/02/2019* and id *abcd1234*. > __**Restriction 2**__: **from** param must be set to 0 or kept unset * @param {string} [before] Same idea that after param, but to retrieve the data placed before the pointed element, given the provided order (sort). * @param {number} [sampling] Size of the sampling for testing transparency: 1: test every pixel, 10: test 1 pixel every 10 pixels, etc. * @param {number} [coverage] Percentage (]0-100]) of acceptable transparent pixels. Higher the percentage, more tiles could be used for filling the tile * @param {number} [max_age_cache] max-age-cache * @param {*} [options] Override http request option. * @throws {RequiredError} * @memberof ExploreApi */ tiledgeosearch1(collection: string, x: number, y: number, z: number, f?: Array, q?: Array, dateformat?: string, righthand?: boolean, size?: number, from?: number, sort?: string, after?: string, before?: string, sampling?: number, coverage?: number, max_age_cache?: number, options?: any): Promise; }