@nextgis/ngw-connector/lib/index.d.ts

A lightweight HTTP client optimized for use with NextGIS Web API

import { Routes } from '@nextgisweb/pyramid/type/route';
import { CompositeRead, ResourceRead } from '@nextgisweb/resource/type/api';
import Cache from '@nextgis/cache';
import { EventEmitter } from 'events';
import { FeatureProperties, DeepPartial } from '@nextgis/utils';
import { LegendSymbol } from '@nextgisweb/render/type/api';
import { GeoJsonObject, Geometry } from 'geojson';
import { LegendSymbolsEnum } from '@nextgisweb/webmap/type/api';

declare class LunkwillParam {
    static VALUES: (string | null)[];
    private value;
    constructor();
    update(value: string | null, cond?: boolean): void;
    suggest(cond?: boolean): void;
    require(cond?: boolean): void;
    toHeaders(headers: Record<string, string>): void;
}

type RouteParameters = {
    [K in keyof Routes]: Routes[K]['pathArr'] | [Routes[K]['pathObj']];
};
type RouteName = keyof Routes;
type GetRouteParam<R extends RouteName> = (RouteParameters[R] & [
    object
])[0];
type RequestMethod = keyof RouteMethods<RouteName>;
type Method = RequestMethod | Uppercase<RequestMethod>;
type CompositeFor<K extends keyof CompositeRead> = CompositeRead & Required<Pick<CompositeRead, K>>;
type ResponseType = 'blob' | 'json';
interface RouteRequestOptions<RT extends ResponseType = 'json', ReturnUrl extends boolean = false, Q = any, B = string | null | boolean | Record<string, any> | any[]> extends Omit<RequestInit, 'cache'> {
    headers?: Record<string, string>;
    cache?: boolean;
    query?: Q;
    json?: B;
    /** Has lower priority than the json */
    body?: string;
    /**
     * The type of data that the server will respond with.
     * Can be either 'json' or 'blob'.
     */
    responseType?: RT;
    /**
     * @deprecated use {@link RequestInit.credential}
     * Indicates whether to include credentials such as cookies, authentication headers,
     * or TLS client certificates in cross-site Access-Control requests.
     */
    withCredentials?: boolean;
    /**
     * Name to use for caching the request.
     */
    cacheName?: string;
    /**
     * Properties to override default cache behavior.
     */
    cacheProps?: Record<string, unknown>;
    lunkwill?: LunkwillParam;
    lunkwillReturnUrl?: ReturnUrl;
}
interface GetRequestOptions<Q = any, RT extends ResponseType = 'json', ReturnUrl extends boolean = false> extends Omit<RouteRequestOptions<RT, ReturnUrl, Q>, 'json' | 'body'> {
    method?: 'GET';
}
interface RequestOptionsJSON<Q = any, B = string | null | boolean | Record<string, any> | any[], RT extends ResponseType = 'json', M extends Method = Method> extends Omit<RouteRequestOptions<RT, false, Q, B>, 'json' | 'body'> {
    json: B;
    method?: M;
}
interface RequestOptionsBody<Q = any, RT extends ResponseType = 'json', M extends Method = Method> extends Omit<RouteRequestOptions<RT, false, Q>, 'json' | 'body'> {
    body: string;
    method?: M;
}
type PutRequestOptions<Q = any, B = any, RT extends ResponseType = 'json'> = RequestOptionsJSON<Q, B, RT, 'PUT'> | RequestOptionsBody<Q, RT, 'PUT'>;
type PostRequestOptions<Q = any, B = any, RT extends ResponseType = 'json'> = RequestOptionsJSON<Q, B, RT, 'POST'> | RequestOptionsBody<Q, RT, 'POST'>;
type PatchRequestOptions<Q = any, B = any, RT extends ResponseType = 'json'> = RequestOptionsJSON<Q, B, RT, 'PATCH'> | RequestOptionsBody<Q, RT, 'PATCH'>;
type DeleteRequestOptions<Q = any, RT extends ResponseType = 'json'> = RouteRequestOptions<RT, false, Q>;
interface MethodRequestOptions<Q = any, B = any, RT extends ResponseType = 'json', ReturnUrl extends boolean = false> {
    get: GetRequestOptions<Q, RT, ReturnUrl>;
    post: PostRequestOptions<Q, B, RT>;
    put: PutRequestOptions<Q, B, RT>;
    patch: PatchRequestOptions<Q, RT>;
    delete: DeleteRequestOptions<Q, RT>;
}
type RequestOptionsByMethod<M extends RequestMethod, Q = any, B = any, RT extends ResponseType = 'json', ReturnUrl extends boolean = false> = M extends keyof MethodRequestOptions ? MethodRequestOptions<Q, B, RT, ReturnUrl>[M] : never;
type ApiRouteParams = Record<string, string>;
interface LunkwillData {
    status?: string;
    delay_ms?: number;
}
type RouteResp<N extends RouteName, M extends RequestMethod> = N extends keyof Routes ? M extends keyof Routes[N] ? 'response' extends keyof Routes[N][M] ? Routes[N][M]['response'] : never : never : never;
type RouteQuery<N extends RouteName, M extends RequestMethod> = N extends keyof Routes ? M extends keyof Routes[N] ? 'query' extends keyof Routes[N][M] ? Routes[N][M]['query'] : any : never : never;
type RouteBody<N extends RouteName, M extends RequestMethod> = N extends keyof Routes ? M extends keyof Routes[N] ? 'body' extends keyof Routes[N][M] ? Routes[N][M]['body'] : any : never : never;
type ToReturn<T = unknown, RT extends ResponseType = 'json', ReturnUrl extends boolean = false> = ReturnUrl extends true ? string : RT extends 'blob' ? Blob : T;
type HasRequiredKeys<T> = {
    [P in keyof T]-?: object extends Pick<T, P> ? never : P;
}[keyof T] extends never ? false : true;
interface RouteMethods<N extends RouteName> {
    url: HasRequiredKeys<RouteQuery<N, 'get'>> extends true ? (options: Pick<RequestOptionsByMethod<'get', RouteQuery<N, 'get'>>, 'query'>) => Promise<string> : (options?: Pick<RequestOptionsByMethod<'get', RouteQuery<N, 'get'>>, 'query'>) => Promise<string>;
    get: HasRequiredKeys<RouteQuery<N, 'get'>> extends true ? <T = RouteResp<N, 'get'>, RT extends ResponseType = 'json', B extends boolean = false>(options: RequestOptionsByMethod<'get', RouteQuery<N, 'get'>, any, RT, B>) => Promise<ToReturn<T, RT, B>> : <T = RouteResp<N, 'get'>, B extends boolean = false, RT extends ResponseType = 'json'>(options?: RequestOptionsByMethod<'get', RouteQuery<N, 'get'>, any, RT, B>) => Promise<ToReturn<T, RT, B>>;
    post: <T = RouteResp<N, 'post'>, RT extends ResponseType = 'json'>(options: RequestOptionsByMethod<'post', RouteQuery<N, 'post'>, RouteBody<N, 'post'>, RT>) => Promise<ToReturn<T, RT>>;
    put: <T = RouteResp<N, 'put'>, RT extends ResponseType = 'json'>(options: RequestOptionsByMethod<'put', RouteQuery<N, 'put'>, RouteBody<N, 'put'>, RT>) => Promise<ToReturn<T, RT>>;
    patch: <T = RouteResp<N, 'patch'>, RT extends ResponseType = 'json'>(options: RequestOptionsByMethod<'patch', RouteQuery<N, 'patch'>, RouteBody<N, 'patch'>, RT>) => Promise<ToReturn<T, RT>>;
    delete: HasRequiredKeys<RouteQuery<N, 'delete'>> extends true ? <T = RouteResp<N, 'delete'>>(options: RequestOptionsByMethod<'delete', RouteQuery<N, 'delete'>>) => Promise<ToReturn<T>> : <T = RouteResp<N, 'delete'>>(options?: RequestOptionsByMethod<'delete', RouteQuery<N, 'delete'>>) => Promise<ToReturn<T>>;
}
type MethodAvailable<N extends RouteName, M extends RequestMethod> = M extends 'url' ? RouteMethods<N>['url'] : M extends keyof Routes[N] ? RouteMethods<N>[M] : never;
type RouteResults<N extends RouteName> = {
    [M in keyof RouteMethods<any>]: MethodAvailable<N, M>;
};
type KeysWithMethods<Methods extends RequestMethod[]> = {
    [K in keyof Routes]: Methods extends (keyof Routes[K])[] ? K : never;
}[keyof Routes];
type PathKeys = any;
type KeysWithPaths<P extends PathKeys> = {
    [K in keyof Routes]: P extends Array<keyof Routes[K]['pathObj']> ? K : never;
}[keyof Routes];
type KeysWithMethodAndPath<M extends RequestMethod[], P extends PathKeys> = {
    [K in keyof Routes]: K extends KeysWithMethods<M> ? K extends KeysWithPaths<P> ? K : never : never;
}[keyof Routes];

declare class AbortError extends Error {
    constructor(message?: string);
}

interface NgwLayerIdentifyError {
    error: 'Not implemented';
}
interface LayerFeature {
    id: number;
    label: string;
    layerId: number;
    parent: string;
    fields: FeatureProperties;
    geom?: GeoJsonObject;
}
interface FeatureLayersIdentifyItems {
    featureCount: number;
    features: LayerFeature[];
}
interface FeatureLayersIdentify {
    [layerId: number]: FeatureLayersIdentifyItems | NgwLayerIdentifyError;
    featureCount: number;
}
interface FeatureItemAttachment {
    id: number;
    name: string;
    size: number;
    mime_type: string;
    description: null;
    is_image: boolean;
}
interface FeatureItemExtensions {
    description?: string;
    attachment?: FeatureItemAttachment[];
}
interface FeatureItem<F = FeatureProperties, G extends Geometry | string = Geometry> {
    id: number;
    geom: G;
    fields: F;
    extensions: FeatureItemExtensions;
}
type FeatureItemToNgw<F = FeatureProperties, G extends Geometry | string = Geometry> = FeatureItem<F, G>;

interface RequestItemsParamsMap {
    'pyramid.static': {
        skey: number;
    };
    'pyramid.openapi_json': null;
    'pyramid.openapi_json_test': null;
    'pyramid.swagger': null;
    'pyramid.control_panel': null;
    'pyramid.control_panel.sysinfo': null;
    'pyramid.control_panel.storage': null;
    'pyramid.control_panel.backup.browse': null;
    'pyramid.control_panel.backup.download': {
        filename: number;
    };
    'pyramid.control_panel.cors': null;
    'pyramid.control_panel.custom_css': null;
    'pyramid.control_panel.logo': null;
    'pyramid.control_panel.system_name': null;
    'pyramid.control_panel.home_path': null;
    'pyramid.locale': {
        locale: number;
    };
    'pyramid.test_request': null;
    'pyramid.test_exception_handled': null;
    'pyramid.test_exception_unhandled': null;
    'pyramid.test_exception_transaction': null;
    'pyramid.test_timeout': null;
    'pyramid.cors': null;
    'pyramid.system_name': null;
    'pyramid.settings': null;
    'pyramid.route': null;
    'pyramid.pkg_version': null;
    'pyramid.healthcheck': null;
    'pyramid.statistics': null;
    'pyramid.estimate_storage': null;
    'pyramid.storage_status': null;
    'pyramid.storage': null;
    'pyramid.kind_of_data': null;
    'pyramid.custom_css': null;
    'pyramid.logo': null;
    'pyramid.company_logo': null;
    'pyramid.home_path': null;
    'pyramid.uacompat': null;
    'lunkwill.summary': null;
    'lunkwill.response': null;
    'jsrealm.testentry': null;
    'auth.login': null;
    'auth.session_invite': null;
    'auth.alink': {
        token: number;
    };
    'auth.logout': null;
    'auth.oauth': null;
    'auth.settings': null;
    'auth.user.browse': null;
    'auth.user.create': null;
    'auth.user.edit': {
        id: number;
    };
    'auth.group.browse': null;
    'auth.group.create': null;
    'auth.group.edit': {
        id: number;
    };
    'auth.user.collection': null;
    'auth.user.item': {
        id: number;
    };
    'auth.profile': null;
    'auth.group.collection': null;
    'auth.group.item': {
        id: number;
    };
    'auth.current_user': null;
    'auth.register': null;
    'auth.login_cookies': null;
    'auth.logout_cookies': null;
    'resource.schema': null;
    'resource.root': null;
    'resource.show': {
        id: number;
    };
    'resource.json': {
        id: number;
    };
    'resource.effective_permissions': {
        id: number;
    };
    'resource.export.page': {
        id: number;
    };
    'resource.widget': null;
    'resource.create': {
        id: number;
    };
    'resource.update': {
        id: number;
    };
    'resource.delete': {
        id: number;
    };
    'resource.control_panel.resource_export': null;
    'resource.blueprint': null;
    'resource.item': {
        id: number;
    };
    'resource.collection': null;
    'resource.permission': {
        id: number;
    };
    'resource.permission.explain': {
        id: number;
    };
    'resource.volume': {
        id: number;
    };
    'resource.quota': null;
    'resource.search': null;
    'resource.quota_check': null;
    'resource.resource_export': null;
    'resource.export': {
        id: number;
    };
    'resource.file_download': {
        id: number;
        name: number;
    };
    'resource.preview': {
        id: number;
    };
    'srs.browse': null;
    'srs.create': null;
    'srs.edit': {
        id: number;
    };
    'srs.catalog': null;
    'srs.catalog.import': {
        id: number;
    };
    'spatial_ref_sys.collection': null;
    'spatial_ref_sys.convert': null;
    'spatial_ref_sys.geom_transform.batch': null;
    'spatial_ref_sys.geom_transform': {
        id: number;
    };
    'spatial_ref_sys.geom_length': {
        id: number;
    };
    'spatial_ref_sys.geom_area': {
        id: number;
    };
    'spatial_ref_sys.item': {
        id: number;
    };
    'spatial_ref_sys.catalog.collection': null;
    'spatial_ref_sys.catalog.item': {
        id: number;
    };
    'spatial_ref_sys.catalog.import': null;
    'layer.extent': {
        id: number;
    };
    'layer_preview.map': {
        id: number;
    };
    'feature_layer.export_multiple': null;
    'feature_layer.feature.browse': {
        id: number;
    };
    'feature_layer.feature.show': {
        id: number;
        feature_id: number;
    };
    'feature_layer.feature.update': {
        id: number;
        feature_id: number;
    };
    'feature_layer.field': {
        id: number;
    };
    'feature_layer.test_mvt': null;
    'feature_layer.geojson': {
        id: number;
    };
    'feature_layer.export': null;
    'feature_layer.mvt': null;
    'feature_layer.feature.item': {
        id: number;
        fid: number;
    };
    'feature_layer.feature.item_extent': {
        id: number;
        fid: number;
    };
    'feature_layer.feature.geometry_info': {
        id: number;
        fid: number;
    };
    'feature_layer.feature.collection': {
        id: number;
    };
    'feature_layer.feature.count': {
        id: number;
    };
    'feature_layer.feature.extent': {
        id: number;
    };
    'feature_layer.store': {
        id: number;
    };
    'feature_layer.identify': null;
    'feature_description.export': {
        id: number;
    };
    'feature_attachment.download': {
        id: number;
        fid: number;
        aid: number;
    };
    'feature_attachment.image': {
        id: number;
        fid: number;
        aid: number;
    };
    'feature_attachment.item': {
        id: number;
        fid: number;
        aid: number;
    };
    'feature_attachment.collection': {
        id: number;
        fid: number;
    };
    'feature_attachment.export': {
        id: number;
    };
    'feature_attachment.import': {
        id: number;
    };
    'feature_attachment.page': {
        id: number;
    };
    'render.tile': null;
    'render.image': null;
    'render.tile_cache.seed_status': {
        id: number;
    };
    'render.legend': {
        id: number;
    };
    'render.legend_symbols': {
        id: number;
    };
    'webmap.annotation.collection': {
        id: number;
    };
    'webmap.annotation.item': {
        id: number;
        annotation_id: number;
    };
    'webmap.print': null;
    'webmap.settings': null;
    'webmap.extent': {
        id: number;
    };
    'webmap.display': {
        id: number;
    };
    'webmap.display.tiny': {
        id: number;
    };
    'webmap.preview_embedded': null;
    'webmap.clone': {
        id: number;
    };
    'webmap.control_panel.settings': null;
    'vector_layer.dataset': null;
    'postgis.connection.inspect': {
        id: number;
    };
    'postgis.connection.inspect.table': {
        id: number;
        table_name: number;
    };
    'postgis.diagnostics': null;
    'postgis.diagnostics_page': {
        id: number;
    };
    'raster_layer.cog': {
        id: number;
    };
    'raster_layer.download': {
        id: number;
    };
    'wfsserver.wfs': {
        id: number;
    };
    'wmsserver.wms': {
        id: number;
    };
    'ogcfserver.landing_page': {
        id: number;
    };
    'ogcfserver.openapi': {
        id: number;
    };
    'ogcfserver.conformance': {
        id: number;
    };
    'ogcfserver.collections': {
        id: number;
    };
    'ogcfserver.collection': {
        id: number;
        collection_id: number;
    };
    'ogcfserver.items': {
        id: number;
        collection_id: number;
    };
    'ogcfserver.item': {
        id: number;
        collection_id: number;
        item_id: number;
    };
    'tmsclient.connection.layers': {
        id: number;
    };
    'file_upload.upload': null;
    'file_upload.collection': null;
    'file_upload.item': {
        id: number;
    };
    'cadaster.settings': null;
    'cadaster.enabled': null;
    'cadaster.pkk_by_position': null;
    'cadaster.pkk_by_id': null;
    'pyramid.control_panel.cadaster': null;
    'collector.user.browse': null;
    'collector.user.create': null;
    'collector.user.edit': {
        id: number;
    };
    'collector.resource.users': {
        id: number;
    };
    'collector.resource.read': {
        id: number;
    };
    'collector.settings': null;
    'collector.user.collection': null;
    'collector.user.item': {
        user_id: number;
    };
    'collector.user.limit': null;
    'old.collector.user': {
        user_id: number;
    };
    'collector.settings.users': null;
    'demo.project': null;
    'demo.project.preview': {
        identity: number;
        lang: number;
    };
    'demo.select': null;
    'demo.redirect': {
        project: number;
    };
    'formbuilder.formbuilder_form_ngfp': {
        id: number;
    };
    'nimbo.config': null;
    'ngwcluster.schema': null;
    'ngwcluster.config': null;
    'ngwcluster.usage': null;
    'ngwcluster.qgis_banner': null;
    'ngwcluster.plan_and_features': null;
    'qgis.style_qml': {
        id: number;
    };
    'pyramid.control_panel.tracker': null;
    'tracker.reports': null;
    'tracker.reports.build': null;
    'tracker.settings': null;
    'tracker.receive_packet': {
        unique_id: number;
    };
    'tracker.get_trackers': null;
    'tracker.get_tracker_points': null;
    'tracker.get_short_tracks': null;
    'tracker.get_full_tracks': null;
    'tracker.get_tracker_last_points': null;
    'tracker.get_tracker_lines': null;
    'tracker.get_last_activity_tracker': null;
    'tracker.get_stops': null;
    'tracker.get_device_types': null;
    'tracker.export_to_gpx': null;
}

interface TreeItem {
    item_type: 'root' | 'group' | 'layer';
    display_name?: string;
    id?: number;
    _layer?: any;
    _parent?: TreeGroup;
}
interface TreeGroup extends TreeItem {
    item_type: 'root' | 'group';
    group_expanded?: boolean;
    children: Array<TreeLayer | TreeGroup>;
}
interface TreeLayer extends TreeItem {
    item_type: 'layer';
    layer_adapter: string;
    layer_enabled: boolean;
    draw_order_position: number;
    layer_max_scale_denom?: number;
    layer_min_scale_denom?: number;
    layer_style_id: number;
    style_parent_id: number;
    layer_transparency: number;
    layer_identifiable: boolean;
}
interface Permission {
    action: string;
    principal: {
        id: number;
    };
    identity: string;
    scope: string;
    permission: string;
    propagate: boolean;
}
/** @deprecated use  ResourceCls from '@nextgisweb/resource/type/api' instead */
type ResourceCls = 'resource_group' | 'postgis_layer' | 'wmsserver_service' | 'basemap_layer' | 'postgis_connection' | 'webmap' | 'wfsserver_service' | 'vector_layer' | 'raster_layer' | 'mapserver_style' | 'qgis_vector_style' | 'qgis_raster_style' | 'raster_style' | 'file_bucket' | 'lookup_table' | 'wmsclient_layer' | 'wmsclient_connection' | 'formbuilder_form' | 'file_bucket' | 'svg_marker_library' | 'ogcfserver_service' | 'tmsclient_connection' | 'tileset' | 'collector_project' | 'demo_project' | 'trackers_group' | 'tracker' | 'terrain_provider' | 'model_3d' | 'tmsclient_layer';
interface ResourceHierarchy {
    id: number;
    parent: {
        id: any;
    };
}
/** @deprecated use  ResourceRead from '@nextgisweb/resource/type/api' instead */
interface Resource {
    cls: ResourceCls;
    id: number;
    parent: {
        id: number;
    };
    owner_user: {
        id: number;
    };
    permissions: Permission[];
    keyname?: string | null;
    display_name: string;
    description?: string | null;
    children: boolean;
    interfaces: any[];
    scopes: string[];
}
interface BookmarkProperties {
    name: string;
    place: string;
}
interface NgwDateFormat {
    year: number;
    month: number;
    day: number;
}
interface NgwTimeFormat {
    hour: number;
    minute: number;
    second: number;
}
type NgwDateTimeFormat = NgwDateFormat & NgwTimeFormat;
/** @deprecated use  WebMapRead from '@nextgisweb/resource/type/api' instead */
interface WebmapResource {
    extent_left: number;
    extent_right: number;
    extent_bottom: number;
    extent_top: number;
    extent_constrained: boolean;
    draw_order_enabled: boolean;
    bookmark_resource: ResourceHierarchy;
    root_item: TreeGroup;
}
interface BasemapResource {
    url: string;
    /**
     * Parse to qms-kit.BasemapQms
     */
    qms: string;
}
/** @deprecated use  BasemapWebMapItemRead from '@nextgisweb/resource/type/api' instead */
interface BasemapWebmapItem {
    resource_id: number;
    display_name: string;
    position?: number;
    enabled?: boolean;
    opacity?: number;
}
/** @deprecated use  BasemapWebMapRead from '@nextgisweb/resource/type/api' instead */
interface BasemapWebmap {
    basemaps: BasemapWebmapItem[];
}
interface LookupTableResource {
    items: Record<string, string>;
}
type VectorFieldDatatype = 'STRING' | 'REAL' | 'DATE' | 'TIME' | 'DATETIME' | 'BIGINT' | 'INTEGER' | 'BOOLEAN';
/** @deprecated - use {@link VectorFieldDatatype} instead */
type ResourceItemDatatype = VectorFieldDatatype;
interface FeatureLayerField {
    datatype: VectorFieldDatatype;
    display_name: string;
    grid_visibility: boolean;
    id: number;
    keyname: string;
    label_field: boolean;
    typemod?: unknown;
}
/** @deprecated use  FeatureLayerRead from '@nextgisweb/resource/type/api' instead */
interface FeatureResource {
    fields: FeatureLayerField[];
}
type GeometryType = 'POINT' | 'LINESTRING' | 'POLYGON' | 'MULTIPOINT' | 'MULTILINESTRING' | 'MULTIPOLYGON' | 'POINTZ' | 'LINESTRINGZ' | 'POLYGONZ' | 'MULTIPOINTZ' | 'MULTILINESTRINGZ' | 'MULTIPOLYGONZ';
/** @deprecated use  VectorLayerRead from '@nextgisweb/resource/type/api' instead */
interface VectorLayer {
    srs: {
        id: number;
    };
    geometry_type: GeometryType;
}
interface FileBucket {
    files: NgwFile[];
    tstamp?: any;
    main_tileset?: string;
}
interface WmsServerService {
    /**
     * Array or WMS service layers. keyname, display_name and resource_id are mandatory.
     */
    layers: WmsServerServiceLayer[];
}
interface WmsClientLayer {
    /** WMS connection. */
    connection: {
        id: number;
    };
    srs: {
        id: number;
    };
    /**
     *  Image format. Available values can fetched from WMS connection ('image/png').
     */
    imgformat: string;
    /**
     * String with layer identifiers separated with comma. Available layers can fetched from WMS connection.
     */
    wmslayers: string;
    /** Additional parameters added to each request. This is key and value list. */
    vendor_params: Record<string, string>;
}
interface WmsClientConnection {
    /** WMS service url */
    url: string;
    /** User name to connect to service */
    username?: string;
    /** Password to connect to service */
    password?: string;
    /** WMS version */
    version?: string;
    /** If equal query - query capabilities from service */
    capcache?: string;
}
interface WmsServerServiceLayer {
    /**
     * Key name for WMS service item. Name may be only ASCII symbols without spaces.
     * */
    keyname: string;
    /**
     * Service item name.
     * */
    display_name: string;
    /**
     * Resource identifier which will be WMS layer datasource. Supported types are: vector layer style, raster style, WMS layer.
     * */
    resource_id: number;
    /**
     * Minimum scale to show WMS layer. String in form of `1 : 100000`.
     */
    min_scale_denom?: string | null;
    /**
     *  Maximum scale to show WMS layer. String in form of `1 : 100000`.
     */
    max_scale_denom?: string | null;
}
interface NgwFile {
    name: string;
    mime_type: string;
    size: number;
}
interface Resmeta {
    items: Record<string, any>;
}
interface ResourceItemMain {
    resource: Resource;
    resmeta: Resmeta;
}
/** @deprecated use  CompositeRead from '@nextgisweb/resource/type/api' instead */
interface ResourceItem extends ResourceItemMain {
    [cls: string]: any;
    webmap?: WebmapResource;
    feature_layer?: FeatureResource;
    vector_layer?: VectorLayer;
    basemap_layer?: BasemapResource;
    basemap_webmap?: BasemapWebmap;
    lookup_table?: LookupTableResource;
    file_bucket?: FileBucket;
    wmsserver_service?: WmsServerService;
    wmsclient_layer?: WmsClientLayer;
    wmsclient_connection?: WmsClientConnection;
}
interface VectorLayerResourceItem extends ResourceItemMain {
    vector_layer: VectorLayer;
    feature_layer: FeatureResource;
}

type ResourceStoreItemProperties = {
    [name: string]: any;
} | null;
type ResourceStoreItem<P extends ResourceStoreItemProperties = ResourceStoreItemProperties> = ResourceStoreItemDefault & {
    data?: string;
} & P;
interface ResourceStoreItemDefault {
    [field: string]: string | number | boolean | null | Date;
    id: number;
    label: string;
}

interface FileMeta {
    id: string;
    mime_type: string;
    name: string;
    size: number;
}
interface NgwExtent {
    extent: {
        minLon: number;
        minLat: number;
        maxLon: number;
        maxLat: number;
    };
}
interface SrsItem {
    auth_name: string;
    auth_srid: number;
    display_name: string;
    id: number;
    wkt: string;
}
interface FeatureLayerCount {
    total_count: number;
}
type ResourceIdKeynameDef = string | number;
type ResourceDefinition = ResourceIdKeynameDef | DeepPartial<ResourceRead>;
interface FileUploadResp {
    upload_meta: FileMeta[];
}
interface PyramidSettingsPyramidCompanyLogo {
    link?: 'string';
    enabled: boolean;
}
interface PyramidSettingsPyramid {
    support_url?: string;
    units: 'metric';
    degree_format: 'dd';
    measurement_srid: 4326;
    company_logo?: PyramidSettingsPyramidCompanyLogo;
}
type PyramidSettings = PyramidSettingsPyramid | Record<string, any>;
interface PyramidRoute {
    [requestItemName: string]: [url: string, ...params: string[]];
}
type Router = PyramidRoute;
type simple = string | number | boolean;
type cbParams = (params: Params) => simple;
interface Params {
    [name: string]: simple | cbParams;
}
type RequestItemKeys = {
    readonly [T in keyof RequestItemsParamsMap]?: any;
};
interface RequestItemsResponseMap {
    GET: GetRequestItemsResponseMap;
    POST: PostRequestItemsResponseMap;
}
interface GetRequestItemsResponseMap extends RequestItemKeys {
    'pyramid.route': PyramidRoute;
    'pyramid.settings': PyramidSettings;
    'resource.item': CompositeRead;
    'resource.search': CompositeRead[];
    'resource.child': any;
    'resource.collection': CompositeRead[];
    'file_upload.upload': FileUploadResp;
    'layer.extent': NgwExtent;
    'feature_layer.feature.item': FeatureItem;
    'feature_layer.feature.collection': FeatureItem[];
    'feature_layer.store': ResourceStoreItem[];
    'feature_layer.field': FeatureLayerField[];
    'feature_layer.feature.item_extent': NgwExtent;
    'feature_layer.feature.count': FeatureLayerCount;
    'pyramid.company_logo': string;
    'spatial_ref_sys.collection': SrsItem[];
    'render.legend_symbols': LegendSymbol[];
}
interface IdOnly {
    id: number;
}
interface CreatedResource extends IdOnly {
    parent: IdOnly;
}
interface PostRequestItemsResponseMap extends RequestItemKeys {
    'resource.collection': CreatedResource;
    'feature_layer.identify': FeatureLayersIdentify;
    'file_upload.upload': FileUploadResp;
    'feature_attachment.collection': IdOnly;
}
interface PatchRequestItemsResponseMap extends RequestItemKeys {
    'feature_layer.feature.collection': IdOnly[];
}
interface PutRequestItemsResponseMap extends RequestItemKeys {
    'feature_layer.feature.item': IdOnly;
}
interface DeleteRequestItemsResponseMap extends RequestItemKeys {
    'feature_layer.feature.item': any;
}
/**
 * User credentials for authorization.
 */
interface Credentials {
    /**
     * The login username for the user.
     */
    login: string;
    /**
     * The password for the user.
     */
    password: string;
}
type RequestTransformFunction = (url: string, options: RequestOptions) => [url: string, options: RequestOptions];
interface NgwConnectorOptions {
    /**
     * The base URL of the NextGIS Web (NGW) server.
     * Example: "https://demo.nextgis.com"
     */
    baseUrl?: string;
    /**
     * The API route path to use for requests.
     * If not specified, the default route "/api/component/pyramid/route" will be used.
     */
    route?: string;
    /**
     * User credentials for authorization in NGW.
     * These credentials will be used for authentication in NGW requests.
     */
    auth?: Credentials;
    /**
     * Indicates whether to include credentials such as cookies, authentication headers,
     * or TLS client certificates in cross-site Access-Control requests.
     * Setting this property ensures that cookies from another domain are used in the requests.
     * Note that setting this property has no effect on same-origin requests.
     */
    withCredentials?: boolean;
    /**
     * A function to transform the request before sending it.
     * This function can be used to modify the URL, headers, or other options.
     */
    requestTransform?: RequestTransformFunction;
    /**
     * Identifier for caching requests.
     * This can be used to segregate cached data for different connectors.
     */
    cacheId?: string;
}
interface RequestHeaders {
    [header: string]: string | undefined;
    Authorization?: string;
    Accept?: string;
    'Access-Control-Allow-Origin'?: string;
    'Access-Control-Allow-Headers'?: string;
}
type RequestMethods = 'POST' | 'GET' | 'PATCH' | 'DELETE' | 'PUT';
type NgwExceptions = 'nextgisweb.resource.exception.ResourceNotFound' | 'nextgisweb.core.exception.InsufficientPermissions';
interface BaseRequestOptions {
    cache?: boolean;
    signal?: AbortSignal | null;
}
/**
 * Options for configuring requests to NGW.
 */
interface RequestOptions<M extends RequestMethods = RequestMethods, K extends keyof RequestItemsParamsMap = keyof RequestItemsParamsMap> extends BaseRequestOptions {
    /**
     * Data to be sent as the request body.
     * Typically used with POST, PUT, or PATCH requests.
     */
    data?: any;
    /**
     * File to be sent in the request.
     */
    file?: File;
    /**
     * HTTP method to be used for the request.
     * Example: 'GET', 'POST', 'PUT', 'PATCH', 'DELETE'
     */
    method?: M;
    /**
     * HTTP headers to be included in the request.
     */
    headers?: RequestHeaders;
    /**
     * Indicates whether to include credentials such as cookies, authentication headers,
     * or TLS client certificates in cross-site Access-Control requests.
     */
    withCredentials?: boolean;
    /**
     * The type of data that the server will respond with.
     * Can be either 'json' or 'blob'.
     */
    responseType?: 'json' | 'blob';
    /**
     * Whether to cache the request.
     * When set to true, the response will be stored in the cache.
     */
    cache?: boolean;
    /**
     * Signal object that allows you to communicate with a DOM request (such as fetch) and abort it if desired via an AbortController.
     */
    signal?: AbortSignal | null;
    /**
     * Parameters to be included in the request URL.
     */
    params?: RequestItemsParams<K>;
    /**
     * A function to be called to monitor the progress of the request.
     * @param percentComplete - The percentage of the request that has been completed.
     * @param event - The progress event.
     */
    onProgress?: (percentComplete: number, event: ProgressEvent) => void;
    /**
     * Name to use for caching the request.
     */
    cacheName?: string;
    /**
     * Properties to override default cache behavior.
     */
    cacheProps?: Record<string, unknown>;
}
type RequestItemAdditionalParams = {
    [name: string]: any;
} & {
    paramList?: [string, any][];
};
type RequestItemsParams<K extends keyof RequestItemsParamsMap> = (RequestItemsParamsMap[K] | Record<string, unknown>) & RequestItemAdditionalParams;
interface LoadingQueue {
    name: string;
    waiting: Array<{
        resolve: (...args: any[]) => Promise<any>;
        reject: (...args: any[]) => Promise<Error>;
        timestamp: Date;
    }>;
}
interface UserInfo {
    display_name: string;
    id: number;
    /** @defaultValue 'guest' */
    keyname: 'guest' | string;
    clientId?: string;
}
interface GetChildrenOfOptions extends Pick<RequestOptions, 'cache'> {
    recursive?: boolean;
}

/**
 * Thrown when...
 */
declare class NgwError extends Error {
    name: string;
    title: string;
    message: string;
    detail: string;
    exception: NgwExceptions;
    status_code: number | 404 | 500;
    data?: Record<string, any>;
    guru_meditation: string;
    constructor(er?: Partial<NgwError>);
}

/**
 * Thrown when ...
 */
declare class NetworksResponseError extends NgwError {
    message: string;
    title: string;
    detail: string;
    constructor(obj?: Partial<NetworksResponseError>);
}

declare function extractError(error: unknown): NetworksResponseError | {
    title: any;
    message: any;
    detail: any;
    data: any;
} | {
    title: string;
    message: string;
    detail?: undefined;
    data?: undefined;
} | undefined;

/**
 * Thrown when ...
 */
declare class InsufficientPermissionsError extends NgwError {
    name: string;
    exception: NgwExceptions;
    constructor(obj: InsufficientPermissionsError);
}

declare function isError(error: unknown): error is Error;

/**
 * Thrown when...
 */
declare class NetworkError extends Error {
    name: string;
    constructor(url: string);
}

/**
 * Thrown when ...
 */
declare class ResourceNotFoundError extends NgwError {
    name: string;
    exception: NgwExceptions;
    constructor(obj?: ResourceNotFoundError);
}

type errors_AbortError = AbortError;
declare const errors_AbortError: typeof AbortError;
type errors_InsufficientPermissionsError = InsufficientPermissionsError;
declare const errors_InsufficientPermissionsError: typeof InsufficientPermissionsError;
type errors_NetworkError = NetworkError;
declare const errors_NetworkError: typeof NetworkError;
type errors_NetworksResponseError = NetworksResponseError;
declare const errors_NetworksResponseError: typeof NetworksResponseError;
type errors_NgwError = NgwError;
declare const errors_NgwError: typeof NgwError;
type errors_ResourceNotFoundError = ResourceNotFoundError;
declare const errors_ResourceNotFoundError: typeof ResourceNotFoundError;
declare const errors_extractError: typeof extractError;
declare const errors_isError: typeof isError;
declare namespace errors {
  export {
    errors_AbortError as AbortError,
    errors_InsufficientPermissionsError as InsufficientPermissionsError,
    errors_NetworkError as NetworkError,
    errors_NetworksResponseError as NetworksResponseError,
    errors_NgwError as NgwError,
    errors_ResourceNotFoundError as ResourceNotFoundError,
    errors_extractError as extractError,
    errors_isError as isError,
  };
}

declare class NgwConnector {
    options: NgwConnectorOptions;
    static errors: typeof errors;
    id: number;
    emitter: EventEmitter<[never]>;
    user?: UserInfo;
    cache: Cache;
    withCredentials?: boolean;
    private readonly routeCache;
    private client;
    private routeStr;
    private activeRequests;
    private requestTransform?;
    constructor(options: NgwConnectorOptions);
    /**
     * Clear the cache.
     */
    clearCache(): void;
    setRequestTransform(requestTransform: RequestTransformFunction | undefined | null): void;
    /**
     * Fast way to specify the connection address to NextGIS Web.
     * The current connection will be severed.
     * @param baseUrl - NGW url
     */
    setNgw(baseUrl: string): void;
    /**
     * Establishing a connection with NextGIS Web to fulfill all other requests.
     * @remarks
     * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
     * Can be used to check connection.
     * @example
     * ```javascript
     * const connector = new NgwConnector({ baseUrl: 'https://demo.nextgis.com' });
     * connector.connect()
     *   .then(() => console.log('Ok'))
     *   .catch((er) => console.log('Connection problem', er));
     * ```
     */
    connect({ signal, }?: Pick<RequestOptions, 'signal'>): Promise<PyramidRoute>;
    /**
     * Quick way to change NextGIS Web user.
     * @param credentials - New user credentials
     */
    login(credentials: Credentials, options?: RequestOptions): Promise<UserInfo>;
    /**
     * Disconnecting a user. Aborting all current requests
     */
    logout(): void;
    getUserInfo(credentials?: Credentials, options?: RequestOptions): Promise<UserInfo>;
    /**
     * Obtaining the required Headers for authentication of requests in the NGW.
     */
    getAuthorizationHeaders(credentials?: Credentials): RequestHeaders;
    makeClientId(credentials?: Credentials): string | undefined;
    /** Stop all api requests */
    abort(): void;
    getActiveApiRequests(): {
        [requestId: number]: AbortController;
    };
    route<N extends RouteName>(name: N, ...rest: RouteParameters[N]): RouteResults<N>;
    /**
     * Send request to NGW.
     * @param url - URL address to NGW
     * @param params - Query params
     * @param options - Request options
     */
    makeQuery<R = unknown>(url: string, params?: Params | null, options?: RequestOptions): Promise<R>;
    protected _loadData<R = unknown>(url: string, options: RequestOptions): Promise<R>;
    private _login;
    private _cleanActiveRequest;
    private _handleHttpError;
}

declare class ResourcesControl {
    cache: Cache<Promise<CompositeRead | undefined>, {
        id?: number | string;
    }>;
    connector: NgwConnectorExtended;
    constructor({ connector, cacheId, }: {
        connector: NgwConnectorExtended;
        cacheId?: string;
    });
    /**
     * Receive resource from NGW by id, keyname or search-object parameter.
     * @param resource - Resource id, keyname or search-object
     *
     * @remarks
     * Fetching resource would be cached to speed up next call
     */
    getOne(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<CompositeRead | undefined>;
    getOneOrFail(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<CompositeRead>;
    /**
     * A fast way to retrieve resource ID for any resource definition.
     * @param resource - Any available resource definition
     *
     * @remarks
     * There are situations when exactly the resource id is needed
     * (for example, to compose the correct request to the api)
     * then this method will come in handy to facilitate the extraction of the identifier
     * if the resource is specified through a keyname or other parameters.
     */
    getId(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<number | undefined>;
    /**
     * A fast way to retrieve resource ID for any resource definition.
     * @param resource - Any available resource definition
     *
     * @remarks
     * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
     * To not make one more checks if the resource is definitely exists
     */
    getIdOrFail(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<number>;
    getMany(resource: DeepPartial<ResourceRead>, requestOptions?: GetRequestOptions): Promise<CompositeRead[]>;
    getParent(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<CompositeRead | undefined>;
    getChildrenOf(resource: ResourceDefinition, requestOptions?: GetChildrenOfOptions): Promise<CompositeRead[]>;
    update(resource: ResourceDefinition, data: DeepPartial<CompositeRead>): Promise<CompositeRead | undefined>;
    /**
     * Fast way to delete resource from NGW and clean cache.
     * @param resource - Resource definition
     */
    delete(resource: ResourceDefinition): Promise<void>;
    private _getChildrenOf;
    private _cleanResourceItemCache;
    private _fetchResourceById;
    private _fetchResourceBy;
    private _resourceCacheFilter;
}

declare class NgwConnectorExtended extends NgwConnector {
    resources: ResourcesControl;
    constructor(options: NgwConnectorOptions);
    static create(options: NgwConnectorOptions): NgwConnectorExtended;
    /**
     * Clear the cache.
     */
    clearCache(): void;
    /**
     * Send request to NGW api router.
     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
     * @param params - Request item params or query params
     * @param requestOptions - Request options
     *
     * @example
     * ```javascript
     *
     * // there is such an NGW route item
     * // "feature_layer.feature.item": [
     * //   "/api/resource/{0}/feature/{1}",
     * //   "id",
     * //   "fid"
     * // ],
     *
     * const connector = new NgwConnector({ baseUrl: 'https://example.nextgis.com' });
     * connector.apiRequest('feature_layer.feature.item', {
     *   // request params for {0} and {1}
     *   'id': 2011,
     *   'fid': 101,
     *   // query params
     *   'srs': 4326,
     *   'geom_format': 'geojson',
     * }, { method: 'GET' });
     * // send get-request to 'https://example.nextgis.com/api/resource/2011/feature/101?srs=4326&geom_format=geojson'
     *
     * ```
     */
    apiRequest<K extends keyof RequestItemsParamsMap, P extends RequestItemKeys = RequestItemKeys>(name: K, params_?: RequestItemsParams<K>, requestOptions?: RequestOptions): Promise<P[K]>;
    /**
     * Shortcut method for send POST request to NGW.
     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
     * @param options - Request options
     * @param params - Request item params or query params
     *
     * @example
     * ```javascript
     * connector.post('resource.collection', { data: POST_PAYLOAD })
     *   .then((newResource) => console.log(newResource))
     *   .catch((error) => console.warn(error));
     * ```
     */
    post<K extends keyof RequestItemsParamsMap>(name: K, options?: RequestOptions<'POST', K>, params?: RequestItemsParams<K>): Promise<PostRequestItemsResponseMap[K]>;
    /**
     * Shortcut method for send GET request to NGW.
     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
     * @param options - Request options
     * @param params - Request item params or query params
     */
    get<K extends keyof RequestItemsParamsMap>(name: K, options?: RequestOptions<'GET', K> | undefined | null, params?: RequestItemsParams<K>): Promise<GetRequestItemsResponseMap[K]>;
    /**
     * Shortcut method for send PATCH request to NGW.
     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
     * @param options - Request options
     * @param params - Request item params or query params
     */
    patch<K extends keyof RequestItemsParamsMap>(name: K, options?: RequestOptions<'PATCH', K>, params?: RequestItemsParams<K>): Promise<PatchRequestItemsResponseMap[K]>;
    /**
     * Shortcut method for send PUT request to NGW.
     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
     * @param options - Request options
     * @param params - Request item params or query params
     */
    put<K extends keyof RequestItemsParamsMap>(name: K, options?: RequestOptions<'PUT', K>, params?: RequestItemsParams<K>): Promise<PutRequestItemsResponseMap[K]>;
    /**
     * Shortcut method for send DELETE request to NGW.
     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
     * @param options - Request options
     * @param params - Request item params or query params
     */
    delete<K extends keyof RequestItemsParamsMap>(name: K, options?: RequestOptions<'DELETE', K> | undefined | null, params?: RequestItemsParams<K>): Promise<DeleteRequestItemsResponseMap[K]>;
    /**
     * {@link ResourcesControl.getOne}
     */
    getResource(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<CompositeRead | undefined>;
    /**
     * {@link ResourcesControl.getOneOrFail}
     */
    getResourceOrFail(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<CompositeRead>;
    /**
     * @deprecated - use {@link getResource}
     */
    getResourceBy(resource: DeepPartial<ResourceRead>): Promise<CompositeRead | undefined>;
    /**
     * @deprecated - use {@link getResource}
     */
    getResourceByKeyname(keyname: string): Promise<CompositeRead | undefined>;
    /**
     * @deprecated - use {@link getResource}
     */
    getResourceById(id: number): Promise<CompositeRead | undefined>;
    /**
     * {@link ResourcesControl.getId}
     */
    getResourceId(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<number | undefined>;
    /**
     * {@link ResourcesControl.getIdOrFail}
     */
    getResourceIdOrFail(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<number>;
    /**
     * {@link ResourcesControl.getMany}
     */
    getResourcesBy(resource: DeepPartial<ResourceRead>, requestOptions?: GetRequestOptions): Promise<CompositeRead[]>;
    /**
     * {@link ResourcesControl.getParent}
     */
    getResourceParent(resource: ResourceDefinition, requestOptions?: GetRequestOptions): Promise<CompositeRead | undefined>;
    /**
     * {@link ResourcesControl.getChildrenOf}
     */
    getResourceChildren(resource: ResourceDefinition, requestOptions?: GetChildrenOfOptions): Promise<CompositeRead[]>;
    /**
     * {@link ResourcesControl.update}
     */
    updateResource(resource: ResourceIdKeynameDef, data: DeepPartial<CompositeRead>): Promise<CompositeRead | undefined>;
    /**
     * {@link ResourcesControl.delete}
     */
    deleteResource(resource: ResourceIdKeynameDef): Promise<void>;
}

/**
 * Represents a legend for a specific layer.
 */
interface LayerLegend {
    layerId: string;
    legend?: LegendSymbol[];
    resourceId: number;
    setSymbolRender?: (symbolIndex: number, status: boolean) => void;
    legendSymbols?: LegendSymbolsEnum;
}

export { NgwConnectorExtended as default };
export type { ApiRouteParams, BaseRequestOptions, BasemapResource, BasemapWebmap, BasemapWebmapItem, BookmarkProperties, CompositeFor, CreatedResource, Credentials, DeleteRequestItemsResponseMap, DeleteRequestOptions, FeatureItem, FeatureItemAttachment, FeatureItemExtensions, FeatureItemToNgw, FeatureLayerCount, FeatureLayerField, FeatureLayersIdentify, FeatureLayersIdentifyItems, FeatureResource, FileBucket, FileMeta, FileUploadResp, GeometryType, GetChildrenOfOptions, GetRequestItemsResponseMap, GetRequestOptions, GetRouteParam, IdOnly, KeysWithMethodAndPath, KeysWithMethods, KeysWithPaths, LayerFeature, LayerLegend, LoadingQueue, LookupTableResource, LunkwillData, Method, MethodAvailable, MethodRequestOptions, NgwConnectorOptions, NgwDateFormat, NgwDateTimeFormat, NgwExceptions, NgwExtent, NgwFile, NgwLayerIdentifyError, NgwTimeFormat, Params, PatchRequestItemsResponseMap, PatchRequestOptions, Permission, PostRequestItemsResponseMap, PostRequestOptions, PutRequestItemsResponseMap, PutRequestOptions, PyramidRoute, PyramidSettings, PyramidSettingsPyramid, PyramidSettingsPyramidCompanyLogo, RequestHeaders, RequestItemAdditionalParams, RequestItemKeys, RequestItemsParams, RequestItemsParamsMap, RequestItemsResponseMap, RequestMethod, RequestMethods, RequestOptions, RequestOptionsBody, RequestOptionsByMethod, RequestOptionsJSON, RequestTransformFunction, Resmeta, Resource, ResourceCls, ResourceDefinition, ResourceHierarchy, ResourceIdKeynameDef, ResourceItem, ResourceItemDatatype, ResourceItemMain, ResourceStoreItem, ResourceStoreItemDefault, ResourceStoreItemProperties, ResponseType, RouteBody, RouteMethods, RouteName, RouteParameters, RouteQuery, RouteRequestOptions, RouteResp, RouteResults, Router, SrsItem, ToReturn, TreeGroup, TreeItem, TreeLayer, UserInfo, VectorFieldDatatype, VectorLayer, VectorLayerResourceItem, WebmapResource, WmsClientConnection, WmsClientLayer, WmsServerService, WmsServerServiceLayer };