import { LayerType } from '@opengeoweb/webmap';
import type { CoreAppStore } from '../../types';
import type { Dimension, ReduxLayer } from '../types';
import type { LayerState, Layer } from './types';
import { LayerStatus } from './types';
/**
 * Gets a layer from the layers part of the store by its Id
 *
 * Example: layer = getLayerById(store, 'layerId')
 * @param {object} store object from which the layer state will be extracted
 * @param {string} layerId Id of the layer
 * @returns {object} object containing layer information (service, name, style, enabled etc.)
 */
export declare const getLayerById: ((state: any, layerId: any) => ReduxLayer | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer | undefined;
    dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getFeatureSyncLayerMetadata: ((state: any, layerId: any) => import("./types").FeatureSyncLayerMetadata | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("./types").FeatureSyncLayerMetadata | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("./types").FeatureSyncLayerMetadata | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => import("./types").FeatureSyncLayerMetadata | undefined;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getIsFeatureSyncLayer: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: import("./types").FeatureSyncLayerMetadata | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: import("./types").FeatureSyncLayerMetadata | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => import("./types").FeatureSyncLayerMetadata | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("./types").FeatureSyncLayerMetadata | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("./types").FeatureSyncLayerMetadata | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => import("./types").FeatureSyncLayerMetadata | undefined;
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Determines if layer is present
 *
 * @param {object} store store: object - store object
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {boolean} returnType:boolean - true if layer is present
 */
export declare const getIsLayerPresent: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets a layer from the layers part of the store by its Id, but without the time dimension. (All other dimensions are still included)
 *
 * Example: layer = getLayerByIdWithoutTimeDimension(store, 'layerId')
 * @param {object} store object from which the layer state will be extracted
 * @param {string} layerId Id of the layer
 * @returns {object} object containing layer information (service, name, style, enabled etc.)
 */
export declare const getLayerByIdWithoutTimeDimension: ((state: any, layerId: any) => ReduxLayer | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer | undefined;
    dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all layers indexed by layerId
 *
 * Example: layers = getLayersById(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {object} returnType: object - an object of all layers containing layer information (service, name, style, enabled etc.) indexed by layerId
 */
export declare const getLayersById: ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Record<string, ReduxLayer> | null;
    dependencies: [(store: CoreAppStore) => LayerState | undefined];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all layerIds
 *
 * Example: layerIds = getLayersIds(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {array} returnType: array - an array of all layerIds
 */
export declare const getLayersIds: ((state: CoreAppStore) => string[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string[];
    dependencies: [(store: CoreAppStore) => LayerState | undefined];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all layers (including base layers and overlayers)
 *
 * Example: layers = getAllLayers(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {array} returnType: array - an array of all layers containing layer information (service, name, style, enabled etc.)
 */
export declare const getAllLayers: ((state: CoreAppStore) => ReduxLayer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[];
    memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer[];
    dependencies: [((state: CoreAppStore) => string[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string[];
        dependencies: [(store: CoreAppStore) => LayerState | undefined];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Record<string, ReduxLayer> | null;
        dependencies: [(store: CoreAppStore) => LayerState | undefined];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all layers (including base layers and overlayers) for the given mapId
 *
 * Example: layers = getLayersByMapId(store, mapId)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} mapId mapId: string - mapId
 * @returns {array} returnType: ReduxLayer[] - an array of all layers containing layer information (service, name, style, enabled etc.)
 */
export declare const getLayersByMapId: ((state: CoreAppStore, _mapId: string) => ReduxLayer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer[], resultFuncArgs_1: string) => ReduxLayer[];
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer[], resultFuncArgs_1: string) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer[];
    dependencies: [((state: CoreAppStore) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[];
        memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer[];
        dependencies: [((state: CoreAppStore) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => string[];
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, ReduxLayer> | null;
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, (_store: CoreAppStore, _mapId: string) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all layers that aren't base layers and aren't overlayers
 *
 * Example: layers = getLayers(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {array} returnType: array - an array of all non-baselayers containing layer information (service, name, style, enabled etc.)
 */
export declare const getLayers: ((state: CoreAppStore) => ReduxLayer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[];
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer[];
    dependencies: [((state: CoreAppStore) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[];
        memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer[];
        dependencies: [((state: CoreAppStore) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => string[];
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, ReduxLayer> | null;
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all baselayers
 *
 * Example: layers = getBaseLayers(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {array} returnType: array - an array of all baselayers containing layer information (service, name, style, enabled etc.)
 */
export declare const getBaseLayers: ((state: CoreAppStore) => ReduxLayer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[];
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer[];
    dependencies: [((state: CoreAppStore) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[];
        memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer[];
        dependencies: [((state: CoreAppStore) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => string[];
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, ReduxLayer> | null;
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all overLayers
 *
 * Example: layers = getOverLayers(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {array} returnType: array - an array of all overLayers containing layer information (service, name, style, enabled etc.)
 */
export declare const getOverLayers: ((state: CoreAppStore) => ReduxLayer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[];
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer[];
    dependencies: [((state: CoreAppStore) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[];
        memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer[];
        dependencies: [((state: CoreAppStore) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => string[];
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, ReduxLayer> | null;
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Retrieves all featureLayers
 *
 * Example: layers = getFeatureLayers(store)
 * @param {object} store store: object - object from which the layers state will be extracted
 * @returns {array} returnType: array - an array of all featureLayers
 */
export declare const getFeatureLayers: ((state: CoreAppStore) => ReduxLayer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[];
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer[]) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => ReduxLayer[];
    dependencies: [((state: CoreAppStore) => ReduxLayer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[];
        memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null) => ReduxLayer[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer[];
        dependencies: [((state: CoreAppStore) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => string[];
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, ReduxLayer> | null;
            dependencies: [(store: CoreAppStore) => LayerState | undefined];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets dimensions of the passed layer
 *
 * Example: layerDimensions = getLayerDimensions(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {array} returnType: Dimension[] - array containing layer dimensions
 */
export declare const getLayerDimensions: ((state: any, layerId: any) => Dimension[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Dimension[];
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets dimensions of the passed layer, excluding the time dimension
 *
 * Example: layerNonTimeDimensions = getLayerNonTimeDimensions(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {array} returnType: Dimension[] - array containing layer dimensions, excluding the time dimension
 */
export declare const getLayerNonTimeDimensions: ((state: any, layerId: any) => Dimension[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Dimension[]) => Dimension[];
    memoizedResultFunc: ((resultFuncArgs_0: Dimension[]) => Dimension[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Dimension[];
    dependencies: [((state: any, layerId: any) => Dimension[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Dimension[];
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets time dimension of the passed layer
 *
 * Example: timeDimension = getLayerTimeDimension(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {object} returnType: object - object of layer time dimension
 */
export declare const getLayerTimeDimension: ((state: any, layerId: any) => Dimension | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Dimension[]) => Dimension | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: Dimension[]) => Dimension | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Dimension | undefined;
    dependencies: [((state: any, layerId: any) => Dimension[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Dimension[];
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Returns a boolean indicating whether the layer has a time dimension
 *
 * Example: layerHasTimeDimension = getLayerHasTimeDimension(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {boolean} returnType: boolean - boolean indicating whether the layer has a time dimension
 */
export declare const getLayerHasTimeDimension: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Dimension | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: Dimension | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => Dimension | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Dimension[]) => Dimension | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: Dimension[]) => Dimension | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Dimension | undefined;
        dependencies: [((state: any, layerId: any) => Dimension[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
            memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Dimension[];
            dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
                memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => ReduxLayer | undefined;
                dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                argsMemoize: typeof import("reselect").weakMapMemoize;
                memoize: typeof import("reselect").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getLayerCurrentTime: ((state: any, layerId: any) => string | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Dimension | undefined) => string | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: Dimension | undefined) => string | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string | undefined;
    dependencies: [((state: any, layerId: any) => Dimension | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Dimension[]) => Dimension | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: Dimension[]) => Dimension | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Dimension | undefined;
        dependencies: [((state: any, layerId: any) => Dimension[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
            memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Dimension[];
            dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
                memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => ReduxLayer | undefined;
                dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                argsMemoize: typeof import("reselect").weakMapMemoize;
                memoize: typeof import("reselect").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets specified dimension of the passed layer
 *
 * Example: dimension = getLayerDimension(store, 'layerId_1', 'elevation')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @param {string} dimensionName dimensionName: string - name of dimension you want to retrieve the dimension data for
 * @returns {object} returnType: object - object of layer dimension
 */
export declare const getLayerDimension: ((state: any, _layerId: any, dimensionName: string) => Dimension) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Dimension[], resultFuncArgs_1: string) => Dimension;
    memoizedResultFunc: ((resultFuncArgs_0: Dimension[], resultFuncArgs_1: string) => Dimension) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Dimension;
    dependencies: [((state: any, layerId: any) => Dimension[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Dimension[];
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, (_store: CoreAppStore, _layerId: string, dimensionName: string) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets opacity of the passed layer
 *
 * Example: layerOpacity = getLayerOpacity(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {number} returnType: number - opacity as a number (between 0 and 1)
 */
export declare const getLayerOpacity: ((state: any, layerId: any) => number) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => number;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => number) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets whether a layer is enabled or disabled
 *
 * Example: isLayerEnabled = getLayerEnabled(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {boolean} returnType: boolean -  true if enabled, false if disabled
 */
export declare const getLayerEnabled: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets layer name
 *
 * Example: layerName = getLayerName(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: string -  layer name
 */
export declare const getLayerName: ((state: any, layerId: any) => string) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => string;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets layer service
 *
 * Example: layerService = getLayerService(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: string -  layer service
 */
export declare const getLayerService: ((state: any, layerId: any) => string) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => string;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets layer service name
 *
 * Example: layerService = getLayerServiceName(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: string -  layer service name
 */
export declare const getLayerServiceName: ((state: any, ...params: any[]) => string) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (...resultFuncArgs: readonly any[]) => string;
    memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string;
    dependencies: import("reselect").SelectorArray<any>;
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets selected style of the passed layer
 *
 * Example: layerStyle = getLayerStyle(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: string - style that is currently selected
 */
export declare const getLayerStyle: ((state: any, layerId: any) => string) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => string;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets layer status
 *
 * Example: layerService = getLayerStatus(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: LayerStatus
 */
export declare const getLayerStatus: ((state: any, layerId: any) => LayerStatus) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => LayerStatus;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => LayerStatus) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => LayerStatus;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets all available base layers for a map
 *
 * Example: availableBaseLayers = getAvailableBaseLayersForMap(store)
 * @param {object} store store: object - object from which the layer state will be extracted
 * @param {string} mapId mapId: string - Id of the map we want to retrieve the available baselayers for
 * @returns {array} returnType: array - array containing all available base layers
 */
export declare const getAvailableBaseLayersForMap: ((state: CoreAppStore, _mapId: string) => Layer[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => Layer[];
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => Layer[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Layer[];
    dependencies: [(store: CoreAppStore) => LayerState | undefined, (_store: CoreAppStore, _mapId: string) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Returns the selected geojson feature for the given layer
 *
 * Example const selectedFeature = getSelectedFeature(store, 'layerId1')
 * @param {object} store store: object - store object
 * @param {string} mapId layerId: string - Id of the layer
 * @returns {number} the index of the selected geojson feature
 */
export declare const getActiveFeatureIndex: ((state: any, layerId: any) => number | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => number | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => number | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number | undefined;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Returns the layer is in edit mode
 *
 * Example const isLayerInEditMode = getIsLayerInEditMode(store, 'layerId1')
 * @param {object} store store: object - store object
 * @param {string} mapId layerId: string - Id of the layer
 * @returns {number} isLayerInEditMode: boolean - isInEditMode
 */
export declare const getIsLayerInEditMode: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getFeatureLayerGeoJSON: ((state: any, layerId: any) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getHasFeatureLayerGeoJSON: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties> | undefined;
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getFeatureLayerGeoJSONProperties: ((state: any, layerId: any) => {
    [name: string]: any;
}) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined, resultFuncArgs_1: number | undefined) => {
        [name: string]: any;
    };
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined, resultFuncArgs_1: number | undefined) => {
        [name: string]: any;
    }) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => {
        [name: string]: any;
    };
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: any, layerId: any) => number | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => number | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => number | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => number | undefined;
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets layerIds that contain passed dimension
 *
 * Example: dimension = getDimensionLayerIds(store, 'elevation')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} dimensionName dimensionName: string - name of dimension you want to retrieve the dimension data for
 * @returns {string[]} returnType: string[] - layerIds
 */
export declare const getDimensionLayerIds: ((state: CoreAppStore, dimensionName: string) => string[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null, resultFuncArgs_2: string) => string[];
    memoizedResultFunc: ((resultFuncArgs_0: string[], resultFuncArgs_1: Record<string, ReduxLayer> | null, resultFuncArgs_2: string) => string[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string[];
    dependencies: [((state: CoreAppStore) => string[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined) => string[];
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => string[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string[];
        dependencies: [(store: CoreAppStore) => LayerState | undefined];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: CoreAppStore) => Record<string, ReduxLayer> | null) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => Record<string, ReduxLayer> | null) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Record<string, ReduxLayer> | null;
        dependencies: [(store: CoreAppStore) => LayerState | undefined];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, (_store: CoreAppStore, dimensionName: string) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getAcceptanceTimeInMinutes: ((state: any, layerId: any) => number | null | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => number | null | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => number | null | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number | null | undefined;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getLayerIsInsideAcceptanceTime: ((state: any, _layerId: any, mapId: string) => "inside" | "outside" | "equal") & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: number | null | undefined, resultFuncArgs_1: string | undefined, resultFuncArgs_2: string | undefined) => "inside" | "outside" | "equal";
    memoizedResultFunc: ((resultFuncArgs_0: number | null | undefined, resultFuncArgs_1: string | undefined, resultFuncArgs_2: string | undefined) => "inside" | "outside" | "equal") & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => "inside" | "outside" | "equal";
    dependencies: [((state: any, layerId: any) => number | null | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => number | null | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => number | null | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => number | null | undefined;
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: any, layerId: any) => string | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Dimension | undefined) => string | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: Dimension | undefined) => string | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string | undefined;
        dependencies: [((state: any, layerId: any) => Dimension | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: Dimension[]) => Dimension | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: Dimension[]) => Dimension | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Dimension | undefined;
            dependencies: [((state: any, layerId: any) => Dimension[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
                memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => Dimension[];
                dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                } & {
                    resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
                    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                        clearCache: () => void;
                        resultsCount: () => number;
                        resetResultsCount: () => void;
                    };
                    lastResult: () => ReduxLayer | undefined;
                    dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
                    recomputations: () => number;
                    resetRecomputations: () => void;
                    dependencyRecomputations: () => number;
                    resetDependencyRecomputations: () => void;
                } & {
                    argsMemoize: typeof import("reselect").weakMapMemoize;
                    memoize: typeof import("reselect").weakMapMemoize;
                }];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                argsMemoize: typeof import("reselect").weakMapMemoize;
                memoize: typeof import("reselect").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, (state: CoreAppStore, _layerId: string | undefined, mapId: string) => string | undefined];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getUseLatestReferenceTime: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Returns the timestep for this layerId in seconds, or undefined if it has no time dimension or timeinterval.
 */
export declare const getTimeStepForLayerId: ((state: any, layerId: any) => number | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Dimension | undefined) => number | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: Dimension | undefined) => number | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => number | undefined;
    dependencies: [((state: any, layerId: any) => Dimension | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Dimension[]) => Dimension | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: Dimension[]) => Dimension | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Dimension | undefined;
        dependencies: [((state: any, layerId: any) => Dimension[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => Dimension[];
            memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => Dimension[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Dimension[];
            dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
                memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => ReduxLayer | undefined;
                dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                argsMemoize: typeof import("reselect").weakMapMemoize;
                memoize: typeof import("reselect").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getActiveLayerInfo: ((state: CoreAppStore) => {
    layerName: string;
    serviceUrl: string;
    style?: string;
} | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined) => {
        layerName: string;
        serviceUrl: string;
        style?: string;
    } | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined) => {
        layerName: string;
        serviceUrl: string;
        style?: string;
    } | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => {
        layerName: string;
        serviceUrl: string;
        style?: string;
    } | undefined;
    dependencies: [(store: CoreAppStore) => LayerState | undefined];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getLayerType: ((state: any, layerId: any) => LayerType | "mapLayer") & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => LayerType | "mapLayer";
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => LayerType | "mapLayer") & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => LayerType | "mapLayer";
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getLayerOptions: ((state: any, layerId: any) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets all overlayers for a given mapId
 * Example: overlayers = getOverlayersForMapId(store, 'mapId123')
 * @param {CoreAppStore} store - The Redux store from which the layers state will be extracted.
 * @param {string} mapId - The ID of the map for which to retrieve the overlayers.
 * @returns {Array<{ id: string; name: string }>} - An array of overlayers containing layer information (id and name).
 */
export declare const getOverlayersForMapId: ((state: CoreAppStore, mapId: string) => {
    id: string;
    name: string;
}[]) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => {
        id: string;
        name: string;
    }[];
    memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => {
        id: string;
        name: string;
    }[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => {
        id: string;
        name: string;
    }[];
    dependencies: [(store: CoreAppStore) => LayerState | undefined, (_store: CoreAppStore, mapId: string) => string];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets the layer title from the service store using the layerId
 *
 * Example: layerTitle = getLayerTitleFromService(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: string - string containing layer title
 */
export declare const getLayerTitleFromService: ((state: any, ...params: any[]) => string | undefined) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (...resultFuncArgs: readonly any[]) => string | undefined;
    memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => string | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string | undefined;
    dependencies: import("reselect").SelectorArray<any>;
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets layer displayname. For EDR layers with multiple parameters, the collectionId is used as displayname. Otherwise the layer title from the service is used.
 *
 * Example: layerName = getLayerDisplayName(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {string} returnType: string -  layer displayname
 */
export declare const getLayerDisplayName: ((state: any, layerId: any) => string) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: LayerType | "mapLayer", resultFuncArgs_1: import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: string) => string;
    memoizedResultFunc: ((resultFuncArgs_0: LayerType | "mapLayer", resultFuncArgs_1: import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined, resultFuncArgs_2: string | undefined, resultFuncArgs_3: string) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => string;
    dependencies: [((state: any, layerId: any) => LayerType | "mapLayer") & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => LayerType | "mapLayer";
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => LayerType | "mapLayer") & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => LayerType | "mapLayer";
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: any, layerId: any) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => import("@opengeoweb/webmap").EDRFeatureLayerOptions | undefined;
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: any, ...params: any[]) => string | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (...resultFuncArgs: readonly any[]) => string | undefined;
        memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => string | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string | undefined;
        dependencies: import("reselect").SelectorArray<any>;
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }, ((state: any, layerId: any) => string) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => string;
        memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => string) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => string;
        dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
            memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => ReduxLayer | undefined;
            dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            argsMemoize: typeof import("reselect").weakMapMemoize;
            memoize: typeof import("reselect").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
/**
 * Gets the layer missing status. A layer is missing if it is not found in the service store or if its status is 'error'.
 *
 * Example: isLayerMissing = getIsLayerMissing(store, 'layerId_1')
 * @param {object} store store: object - object from which the layers state will be extracted
 * @param {string} layerId layerId: string - Id of the layer
 * @returns {boolean} returnType: boolean - true if layer is missing
 */
export declare const getIsLayerMissing: ((state: any, ...params: any[]) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (...resultFuncArgs: readonly any[]) => boolean;
    memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: import("reselect").SelectorArray<any>;
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};
export declare const getIsLayerSelectable: ((state: any, layerId: any) => boolean) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: ReduxLayer | undefined) => boolean;
    memoizedResultFunc: ((resultFuncArgs_0: ReduxLayer | undefined) => boolean) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => boolean;
    dependencies: [((state: any, layerId: any) => ReduxLayer | undefined) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined;
        memoizedResultFunc: ((resultFuncArgs_0: LayerState | undefined, resultFuncArgs_1: string) => ReduxLayer | undefined) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => ReduxLayer | undefined;
        dependencies: [(store: CoreAppStore) => LayerState | undefined, (layerStore: any, layerId: any) => string];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        argsMemoize: typeof import("reselect").weakMapMemoize;
        memoize: typeof import("reselect").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    argsMemoize: typeof import("reselect").weakMapMemoize;
    memoize: typeof import("reselect").weakMapMemoize;
};