import * as i0 from '@angular/core';
import { AfterViewInit, OnChanges, OnDestroy, ElementRef, EventEmitter, SimpleChanges, AfterContentInit, TemplateRef, OnInit, InjectionToken } from '@angular/core';
import { YMap, YMapProps, YMapEntity, YMapFeatureProps, YMapFeature, YMapFeatureDataSourceProps, YMapFeatureDataSource, YMapListenerProps, YMapListener, YMapMarkerProps, YMapMarker as YMapMarker$1, YMapControlButton, YMapControls, YMapControlsProps, YMapScaleControlProps, YMapScaleControl, YMapDefaultFeaturesLayerProps, YMapDefaultFeaturesLayer, YMapDefaultSchemeLayerProps, YMapDefaultSchemeLayer, YMapLayerProps, YMapLayer } from '@yandex/ymaps3-types';
import { BehaviorSubject, Observable } from 'rxjs';
import { LngLat } from '@yandex/ymaps3-types/common/types';
import { Feature, YMapClustererProps, YMapClusterer } from '@yandex/ymaps3-types/packages/clusterer';
import { YMapDefaultMarkerProps, YMapDefaultMarker } from '@yandex/ymaps3-types/packages/markers';
import { YMapHint } from '@yandex/ymaps3-types/packages/hint';
import { YMapFeature as YMapFeature$1, YMapMarker, YMapHotspot } from '@yandex/ymaps3-types/imperative';
import { YMapControlProps, YMapControl, YMapControlCommonButtonProps, YMapControlCommonButton } from '@yandex/ymaps3-types/imperative/YMapControl';
import { GenericRootEntity, GenericEntity } from '@yandex/ymaps3-types/imperative/Entities';
import { YMapGeolocationControlProps, YMapGeolocationControl, YMapZoomControlProps, YMapZoomControl } from '@yandex/ymaps3-types/packages/controls';
import { YMapOpenMapsButtonProps, YMapOpenMapsButton } from '@yandex/ymaps3-types/modules/controls-extra';

/**
 * A component `(ready)` output event.
 */
interface YReadyEvent<T = any> {
    /**
     * Instance of a created entity.
     * For example, the result of calling `new ymaps3.YMap()`.
     */
    entity: T;
    /**
     * The API global object.
     * It's already in `window.ymaps3`, but you can also access it from this event.
     */
    ymaps3: typeof ymaps3;
}

/**
 * This component wraps the [ymaps3.YMap](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymap) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 10,
 *     },
 *     theme: 'dark',
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 * </y-map>
 * ```
 */
declare class YMapComponent implements AfterViewInit, OnChanges, OnDestroy {
    private readonly yaApiLoaderService;
    private readonly ngZone;
    readonly container: ElementRef;
    private readonly destroy$;
    map$: BehaviorSubject<YMap | null>;
    /**
     * See the API entity documentation for detailed information. Supports updates.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapProps}
     */
    props: YMapProps;
    /**
     * See the API entity documentation for detailed information.
     */
    children?: YMapEntity<unknown, object>[];
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMap>>;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private createMap;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<YMapComponent, "y-map", never, { "props": { "alias": "props"; "required": true; }; "children": { "alias": "children"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * See https://github.com/piotrwitek/utility-types/blob/2491e464b9adfa88ff9f799e4fd151aa25b71249/src/mapped-types.ts#L567
 * @internal
 */
type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

/**
 * This component wraps the [ymaps3.YMapClusterer](https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/clusterer/#class-ymapclusterer) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 * This component is from the `@yandex/ymaps3-clusterer@0.0.1` package, which is asynchronously loaded when you use this component.
 *
 * The Yandex.Maps class is quite challenging, so I recommend checking the official documentation.
 * The component encapsulates some logic, making the class easier to use.
 * It remains fully customizable, and you can replicate the entire code from the official example.
 *
 * The Yandex.Maps class accepts `cluster` and `marker` callbacks that should return HTML for the elements.
 * You can achieve the same behavior using this component in two ways:
 *
 * 1. Pass cluster and marker to props and write completely custom logic. This is the same process that the library handles internally.
 * 2. Use `<ng-template #cluster let-context>` and `<ng-template #marker let-context>`, where the HTML from the templates is passed to `YMapMarker`.
 *
 * When using templates, you can access arguments from the callback through the `$implicit` variable.
 *
 * To define markers, you do not need to create the markers themselves; instead, you need to pass a `Feature[]`.
 * The official example creates an array of coordinates and maps it to the features array.
 *
 * The clustering method is `clusterByGrid({ gridSize: 64 })` by default, but you can override it and other options by passing them to `props`.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 10,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *   <y-map-default-features-layer />
 *
 *   <!-- Define your coordinates in the component and map them to Feature[] -->
 *   <y-map-clusterer
 *     [props]="{
 *       features: [
 *         {
 *           type: 'Feature',
 *           id: '0',
 *           geometry: {
 *             type: 'Point',
 *             coordinates: [-0.597696, 51.907351],
 *           },
 *         },
 *       ],
 *     }"
 *   >
 *     <ng-template #marker let-context>
 *       <!-- Your custom HTML for a point/marker -->
 *       <img src="./pin.svg" />
 *     </ng-template>
 *
 *     <ng-template #cluster let-context>
 *       <!-- Your custom HTML for a clusterer point/marker -->
 *       {{ context.features.length }}
 *     </ng-template>
 *   </y-map-clusterer>
 * </y-map>
 * ```
 */
declare class YMapClustererDirective implements AfterContentInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    markerTemplate?: TemplateRef<{
        $implicit: Feature;
    }>;
    clusterTemplate?: TemplateRef<{
        $implicit: {
            coordinates: LngLat;
            features: Feature[];
        };
    }>;
    private readonly destroy$;
    private clusterer?;
    /**
     * Read the component description and see the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/clusterer/#YMapClustererProps}
     */
    props: Optional<YMapClustererProps, 'marker' | 'cluster' | 'method'>;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapClusterer>>;
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private getTemplateElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapClustererDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapClustererDirective, "y-map-clusterer", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, ["markerTemplate", "clusterTemplate"], never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapDefaultMarker](https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/markers/#class-ymapdefaultmarker) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 * This component is from the `@yandex/ymaps3-markers@0.0.1` package, which is asynchronously loaded when you use this component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 10,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *   <y-map-default-features-layer />
 *
 *   <y-map-default-marker
 *     [props]="{
 *       coordinates: [-0.127696, 51.507351],
 *       title: 'Hello World!',
 *       subtitle: 'kind and bright',
 *       color: 'blue',
 *     }"
 *   />
 * </y-map>
 * ```
 */
declare class YMapDefaultMarkerDirective implements OnInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private marker?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/en/ref/packages/markers/#YMapDefaultMarkerProps}
     */
    props: YMapDefaultMarkerProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapDefaultMarker>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapDefaultMarkerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapDefaultMarkerDirective, "y-map-default-marker", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapFeature](https://yandex.ru/dev/jsapi30/doc/en/ref/#class-ymapfeature) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *   <y-map-default-features-layer />
 *
 *   <y-map-feature
 *     [props]="{
 *       geometry: {
 *         type: 'Polygon',
 *         coordinates: [
 *           [
 *             [-0.557696, 51.727351],
 *             [0.302304, 51.727351],
 *             [0.302304, 51.237351],
 *             [-0.557696, 51.237351],
 *           ],
 *         ],
 *       },
 *       style: {
 *         stroke: [{ color: '#006efc', width: 4, dash: [5, 10] }],
 *         fill: 'rgba(56, 56, 219, 0.5)',
 *       },
 *     }"
 *   />
 * </y-map>
 * ```
 */
declare class YMapFeatureDirective implements OnInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private feature?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/en/ref/#YMapFeatureProps}
     */
    props: YMapFeatureProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapFeature>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapFeatureDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapFeatureDirective, "y-map-feature", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapFeatureDataSource](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapfeaturedatasource) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-feature-data-source [props]="{ id: 'clusterer-source' }" />
 * </y-map>
 * ```
 */
declare class YMapFeatureDataSourceDirective implements OnInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private source?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapFeatureDataSourceProps}
     */
    props: YMapFeatureDataSourceProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapFeatureDataSource>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapFeatureDataSourceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapFeatureDataSourceDirective, "y-map-feature-data-source", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * Typings do not export this type, but it's used in a YMapHint component.
 * For now, define it here. Maybe later they will export it.
 * @internal
 */
type YMapHintProps = {
    hint: (object: YMapFeature$1 | YMapMarker | YMapHotspot | undefined) => unknown;
};

/**
 * This component wraps the [ymaps3.YMapHint](https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/hint/#class-ymaphint) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 * This component is from the `@yandex/ymaps3-hint@0.0.1` package, which is asynchronously loaded when you use this component.
 *
 * The API of this component is complicated, but it's very close to what the official React wrapper suggests.
 * We strongly recommend reading and understanding the [official React example](https://yandex.ru/dev/jsapi30/doc/ru/examples/cases/hints) for this component.
 *
 * In a nutshell, each entity (YMapFeature, YMapMarker, YMapHotspot) has a `properties` property, which is `Record<string, unknown>`.
 * When you define these components, you can pass any metadata to this property, which you can later access using `YMapHintProps['hint']`.
 * When you pass a callback to `YMapHintProps['hint']`, you can read the `properties` property and return the hint based on the metadata.
 * What you return from `YMapHintProps['hint']` will be available in `<ng-template />` (it's set via $implicit, so you can use any name for let-*).
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *   <y-map-default-features-layer />
 *
 *   <!-- onHint = (object?: YMapFeature | YMapMarker | YMapHotspot) => object?.properties?.['anyNameKey']; -->
 *   <!-- It accepts an entity on which a user hovered and returns a context, which is set to $implicit in ng-template. -->
 *   <!-- Your function can return anything since we have access to the returned value. -->
 *   <y-map-hint [props]="{ hint: onHint }">
 *     <ng-template let-context>
 *       <div
 *         style="
 *           background-color: #fff;
 *           border-radius: 6px;
 *           padding: 3px 6px 4px;
 *           margin-left: 15px;
 *         "
 *       >
 *         <!-- context.hint is the return value of onHint -->
 *         {{ context?.hint }}
 *       </div>
 *     </ng-template>
 *   </y-map-hint>
 *
 *   <y-map-default-marker
 *     [props]="{
 *       coordinates: [-0.127696, 51.507351],
 *       properties: {
 *         anyNameKey: 'Central London',
 *       },
 *     }"
 *   />
 * </y-map>
 * ```
 */
declare class YMapHintDirective implements AfterContentInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapComponent;
    template?: TemplateRef<any>;
    private readonly destroy$;
    private hint?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/hint/#YMapHintProps}
     */
    props: YMapHintProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapHint>>;
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /**
     * To render a hint, a container is required.
     * This method isolates all the container creation logic and returns the entity.
     */
    private createHintContainer;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapHintDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapHintDirective, "y-map-hint", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, ["template"], never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapListener](https://yandex.ru/dev/jsapi30/doc/en/ref/#class-ymaplistener) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-listener
 *     [props]="{
 *       onClick: onClick,
 *     }"
 *   />
 * </y-map>
 * ```
 */
declare class YMapListenerDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private listener?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/en/ref/#YMapListenerProps}
     */
    props: YMapListenerProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapListener>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapListenerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapListenerDirective, "y-map-listener", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapMarker](https://yandex.ru/dev/jsapi30/doc/en/ref/#class-ymapmarker) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. `YMapMarker['element']` can only be projected, see the example below.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *   <y-map-default-features-layer />
 *
 *   <y-map-marker
 *     [props]="{
 *       coordinates: [-0.127696, 51.507351],
 *       draggable: true,
 *     }"
 *   >
 *     <img
 *       width="64"
 *       height="64"
 *       style="border-radius: 50%"
 *       src="https://cdn.openart.ai/published/nI5hC8sFzqKnKbJtW1hA/ExVfxYNJ_E0Yh_256.webp"
 *       alt="Bulldog"
 *     />
 *   </y-map-marker>
 * </y-map>
 * ```
 */
declare class YMapMarkerDirective implements AfterViewInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly elementRef;
    private readonly yMapComponent;
    private readonly destroy$;
    private marker?;
    private element?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapMarkerProps}
     */
    props: YMapMarkerProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapMarker$1>>;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapMarkerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapMarkerDirective, "y-map-marker", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapControl](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapcontrol) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 * Custom HTML can only be projected, see the example below.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-control>
 *       <p>Custom HTML</p>
 *     </y-map-control>
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapControlDirective implements AfterViewInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly elementRef;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    private element?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapControlProps}
     */
    props: YMapControlProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapControl>>;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /**
     * To render a control, a container is required.
     * This method isolates all the container creation logic and returns the entity.
     */
    private createControlContainer;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapControlDirective, "y-map-control", never, { "props": { "alias": "props"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * Typings do not export this type, but it's used it in many places.
 * For now, define it here. Maybe later they will export it.
 * @internal
 */
interface ComplexOptions<Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> {
    children?: GenericEntity<unknown, object, Root>[];
    container?: boolean;
}

/**
 * This component wraps the [ymaps3.YMapControlButton](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapcontrolbutton) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-control-button [props]="{ text: 'Hello' }" />
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapControlButtonDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapControlCommonButtonProps}
     */
    props: YMapControlCommonButtonProps;
    /**
     * See the API entity documentation for detailed information.
     */
    options?: ComplexOptions<YMap>;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapControlButton>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapControlButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapControlButtonDirective, "y-map-control-button", never, { "props": { "alias": "props"; "required": true; }; "options": { "alias": "options"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapControlCommonButton](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapcontrolcommonbutton) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-control-common-button [props]="{ text: 'Hello' }" />
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapControlCommonButtonDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    /**
     * Button properties. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapControlCommonButtonProps}
     */
    props: YMapControlCommonButtonProps;
    /**
     * See the API entity documentation for detailed information.
     */
    options?: ComplexOptions<YMap>;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapControlCommonButton>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapControlCommonButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapControlCommonButtonDirective, "y-map-control-common-button", never, { "props": { "alias": "props"; "required": true; }; "options": { "alias": "options"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapControls](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapcontrols) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     ...
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapControlsDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    controls$: BehaviorSubject<YMapControls | null>;
    /**
     * Controls properties. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapControlsProps}
     */
    props: YMapControlsProps;
    /**
     * See the API entity documentation for detailed information.
     */
    children?: YMapEntity<unknown, object>[];
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapControls>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapControlsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapControlsDirective, "y-map-controls", never, { "props": { "alias": "props"; "required": true; }; "children": { "alias": "children"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapGeolocationControl](https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/controls/#class-ymapgeolocationcontrol) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 * This component is from the `@yandex/ymaps3-controls@0.0.1` package, which is asynchronously loaded when you use this component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-geolocation-control />
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapGeolocationControlDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/controls/#YMapGeolocationControlProps}
     */
    props: YMapGeolocationControlProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapGeolocationControl>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapGeolocationControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapGeolocationControlDirective, "y-map-geolocation-control", never, { "props": { "alias": "props"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapOpenMapsButton](https://yandex.ru/dev/jsapi30/doc/ru/ref/modules/controls-extra/#class-ymapopenmapsbutton) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 * This component is from the `@yandex/ymaps3-controls-extra` module, which is asynchronously loaded when you use this component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-open-maps-button />
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapOpenMapsButtonDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/modules/controls-extra/#YMapOpenMapsButtonProps}
     */
    props: YMapOpenMapsButtonProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapOpenMapsButton>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapOpenMapsButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapOpenMapsButtonDirective, "y-map-open-maps-button", never, { "props": { "alias": "props"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapScaleControl](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapscalecontrol) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-scale-control />
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapScaleControlDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapScaleControlProps}
     */
    props: YMapScaleControlProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapScaleControl>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapScaleControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapScaleControlDirective, "y-map-scale-control", never, { "props": { "alias": "props"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapZoomControl](https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/controls/#class-ymapzoomcontrol) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments. This component must be used inside a `y-map-controls` component.
 * This component is from the `@yandex/ymaps3-controls@0.0.1` package, which is asynchronously loaded when you use this component.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 9,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-controls [props]="{ position: 'top' }">
 *     <y-map-zoom-control-button />
 *   </y-map-controls>
 * </y-map>
 * ```
 */
declare class YMapZoomControlDirective implements OnInit, OnChanges, OnDestroy {
    private readonly ngZone;
    private readonly yMapControlsDirective;
    private readonly destroy$;
    private control?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/packages/controls/#YMapZoomControlProps}
     */
    props: YMapZoomControlProps;
    /**
     * See the API entity documentation for detailed information.
     */
    options?: ComplexOptions<YMap>;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapZoomControl>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapZoomControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapZoomControlDirective, "y-map-zoom-control-button", never, { "props": { "alias": "props"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapDefaultFeaturesLayer](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapdefaultfeatureslayer) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 10,
 *     },
 *   }"
 * >
 *   <y-map-default-features-layer />
 * </y-map>
 * ```
 */
declare class YMapDefaultFeaturesLayerDirective implements OnInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private layer?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapDefaultFeaturesLayerProps}
     */
    props: YMapDefaultFeaturesLayerProps;
    /**
     * See the API entity documentation for detailed information.
     */
    options?: ComplexOptions<YMap>;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapDefaultFeaturesLayer>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapDefaultFeaturesLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapDefaultFeaturesLayerDirective, "y-map-default-features-layer", never, { "props": { "alias": "props"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapDefaultSchemeLayer](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymapdefaultschemelayer) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 10,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 * </y-map>
 * ```
 */
declare class YMapDefaultSchemeLayerDirective implements OnInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private layer?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapDefaultSchemeLayerProps}
     */
    props: YMapDefaultSchemeLayerProps;
    /**
     * See the API entity documentation for detailed information.
     */
    options?: ComplexOptions<YMap>;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapDefaultSchemeLayer>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapDefaultSchemeLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapDefaultSchemeLayerDirective, "y-map-default-scheme-layer", never, { "props": { "alias": "props"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * This component wraps the [ymaps3.YMapLayer](https://yandex.ru/dev/jsapi30/doc/ru/ref/#class-ymaplayer) class from the Yandex.Maps API.
 * All component inputs are named the same as the API class constructor arguments.
 *
 * ```html
 * <y-map
 *   [props]="{
 *     location: {
 *       center: [-0.127696, 51.507351],
 *       zoom: 10,
 *     },
 *   }"
 * >
 *   <y-map-default-scheme-layer />
 *
 *   <y-map-layer
 *     [props]="{
 *       type: 'markers',
 *       zIndex: 1800,
 *     }"
 *   />
 * </y-map>
 * ```
 */
declare class YMapLayerDirective implements OnInit, OnDestroy, OnChanges {
    private readonly ngZone;
    private readonly yMapComponent;
    private readonly destroy$;
    private layer?;
    /**
     * See the API entity documentation for detailed information. Supports ngOnChanges.
     * {@link https://yandex.ru/dev/jsapi30/doc/ru/ref/#YMapLayerProps}
     */
    props: YMapLayerProps;
    /**
     * The entity instance is created. This event runs outside an Angular zone.
     */
    ready: EventEmitter<YReadyEvent<YMapLayer>>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YMapLayerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<YMapLayerDirective, "y-map-layer", never, { "props": { "alias": "props"; "required": true; }; }, { "ready": "ready"; }, never, never, true, never>;
}

/**
 * The `YApiLoader` service handles loading of the Yandex.Maps API.
 * Use it if you do not need `YMapComponent`.
 *
 * The service supports dynamic configuration changes by subscribing on a `YConfig` observable.
 * It stores global API objects in a local cache, and updates them in runtime if necessary.
 * That's why do not provide this service, it will break the synchronizations between the local cache and HTML scripts.
 *
 * ```ts
 * import { YApiLoaderService } from 'angular-yandex-maps-v3';
 *
 * @Component()
 * export class AppComponent {
 *   constructor(private yApiLoaderService: YApiLoaderService) {
 *     // Don't forget to unsubscribe
 *     this.yApiLoaderService.load()
 *       .subscribe(v => console.log(v))
 *   }
 * }
 * ```
 */
declare class YApiLoaderService {
    private readonly document;
    private readonly ngZone;
    private readonly isBrowser;
    private readonly defaultConfig;
    private readonly config$;
    private readonly cache;
    constructor();
    /**
     * Loads the Yandex.Maps API.
     * Runs outside an Angular zone.
     */
    load(): Observable<typeof ymaps3>;
    private createScript;
    /**
     * Returns a script source from a config.
     * @param config parameters to add to a source
     * @example
     * // returns 'https://api-maps.yandex.ru/2.1/?apikey=658f67a2-fd77-42e9-b99e-2bd48c4ccad4&lang=en_US'
     * getScriptSource({ apikey: '658f67a2-fd77-42e9-b99e-2bd48c4ccad4', lang: 'en_US' })
     */
    private getScriptSource;
    /**
     * Converts a config into query string parameters.
     * @param config object to convert
     * @example
     * // returns "lang=ru_RU&apikey=XXX"
     * convertIntoQueryParams({ lang: 'ru_RU', apikey: 'XXX' })
     */
    private convertConfigIntoQueryParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<YApiLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<YApiLoaderService>;
}

/**
 * API loading parameters.
 * See https://yandex.ru/dev/jsapi30/doc/en/dg/concepts/load#params
 */
interface YConfig {
    /**
     * API key.
     */
    apikey?: string;
    /**
     * Locale.
     */
    lang?: 'ru_RU' | 'ru_UA' | 'uk_UA' | 'tr_TR' | 'en_RU' | 'en_US' | 'he_IL' | 'en_IL';
}

/**
 * @internal
 */
declare const Y_CONFIG: InjectionToken<YConfig | Observable<YConfig>>;
/**
 * Provides a Y_CONFIG token with the given configuration.
 *
 * ```ts
 * import { provideYConfig, YConfig } from 'angular-yandex-maps-v3';
 *
 * export const config: YConfig = {
 *   apikey: 'X-X-X',
 * };
 *
 * export const appConfig: ApplicationConfig = {
 *   providers: [provideZoneChangeDetection({ eventCoalescing: true }), provideYConfig(config)],
 * };
 * ```
 */
declare const provideYConfig: (config: YConfig | Observable<YConfig>) => i0.EnvironmentProviders;

export { YApiLoaderService, YMapClustererDirective, YMapComponent, YMapControlButtonDirective, YMapControlCommonButtonDirective, YMapControlDirective, YMapControlsDirective, YMapDefaultFeaturesLayerDirective, YMapDefaultMarkerDirective, YMapDefaultSchemeLayerDirective, YMapFeatureDataSourceDirective, YMapFeatureDirective, YMapGeolocationControlDirective, YMapHintDirective, YMapLayerDirective, YMapListenerDirective, YMapMarkerDirective, YMapOpenMapsButtonDirective, YMapScaleControlDirective, YMapZoomControlDirective, Y_CONFIG, provideYConfig };
export type { YConfig, YReadyEvent };