import * as i0 from '@angular/core';
import { OnDestroy, OnChanges, SimpleChanges, EventEmitter, TemplateRef, OnInit, PipeTransform, AfterViewInit, ElementRef, AfterContentInit, ModuleWithProviders } from '@angular/core';
import * as i11 from '@angular/cdk/overlay';
import { CdkOverlayOrigin, ConnectedPosition, Overlay, FlexibleConnectedPositionStrategy, ScrollStrategy } from '@angular/cdk/overlay';
import * as i6 from '@angular/material/dialog';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import { ThemePalette } from '@angular/material/core';
import * as i3 from '@angular/forms';
import { ControlValueAccessor } from '@angular/forms';
import { DateTime } from 'ts-luxon';
import { Observable, BehaviorSubject, Subject } from 'rxjs';
import * as i8 from '@angular/material/select';
import { MatSelectChange } from '@angular/material/select';
import * as i5 from '@angular/material/form-field';
import { FloatLabelType } from '@angular/material/form-field';
import * as i1 from '@angular/common';
import * as i2 from '@angular/cdk/a11y';
import * as i4 from '@angular/material/button';
import * as i7 from '@angular/material/input';
import * as i9 from '@angular/material/toolbar';
import * as i10 from '@angular/material/icon';
import * as i12 from '@angular/cdk/portal';

type NgxMatTimepickerFormatType = 12 | 24;

declare class NgxMatTimepickerDirective implements ControlValueAccessor, OnDestroy, OnChanges {
    get element(): HTMLElement;
    set format(value: number);
    get format(): NgxMatTimepickerFormatType;
    set max(value: string | DateTime);
    get max(): string | DateTime;
    set min(value: string | DateTime);
    get min(): string | DateTime;
    set timepicker(picker: NgxMatTimepickerComponent);
    set value(value: string);
    get value(): string;
    private set _defaultTime(value);
    private get _locale();
    cdkOverlayOrigin: CdkOverlayOrigin;
    disableClick: boolean;
    disabled: boolean;
    private _elementRef;
    private _format;
    private _matFormField;
    private _max;
    private _min;
    private _previousFormat;
    private _subsCtrl$;
    private _timepicker;
    private _timepickerLocaleSrv;
    private _value;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onClick(event: MouseEvent): void;
    onTouched: () => void;
    registerOnChange(fn: (value: any) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    updateValue(e: Event): void;
    writeValue(value: string): void;
    private _onChange;
    private _registerTimepicker;
    private _unregisterTimepicker;
    private _updateInputValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatTimepickerDirective, "[ngxMatTimepicker]", never, { "format": { "alias": "format"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "timepicker": { "alias": "ngxMatTimepicker"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disableClick": { "alias": "disableClick"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

interface NgxMatTimepickerRef {
    close?: () => void;
    hourSelected: EventEmitter<number>;
    timeChanged: EventEmitter<string>;
    timeSet: EventEmitter<string>;
    timeUpdated: Observable<string>;
}

declare class NgxMatTimepickerComponent implements NgxMatTimepickerRef {
    private _dialog;
    static nextId: number;
    set appendToInput(newValue: boolean | string | void);
    set color(newValue: ThemePalette);
    get color(): ThemePalette;
    get disabled(): boolean;
    set dottedMinutesInGap(newValue: boolean | "");
    get dottedMinutesInGap(): boolean;
    set enableKeyboardInput(newValue: boolean | string | void);
    get enableKeyboardInput(): boolean;
    get format(): NgxMatTimepickerFormatType;
    set format(value: NgxMatTimepickerFormatType);
    get inputElement(): HTMLElement;
    get maxTime(): DateTime;
    get minTime(): DateTime;
    get minutesGap(): number;
    set minutesGap(gap: number);
    get overlayOrigin(): CdkOverlayOrigin;
    get time(): string;
    cancelBtnTmpl: TemplateRef<Node>;
    closed: EventEmitter<void>;
    confirmBtnTmpl: TemplateRef<Node>;
    defaultTime: string;
    disableAnimation: boolean;
    editableHintTmpl: TemplateRef<Node>;
    hourSelected: EventEmitter<number>;
    hoursOnly: boolean;
    id: string;
    isEsc: boolean;
    max: DateTime;
    min: DateTime;
    opened: EventEmitter<void>;
    overlayPositions: ConnectedPosition[];
    preventOverlayClick: boolean;
    showPicker: boolean;
    timeChanged: EventEmitter<string>;
    timepickerClass: string;
    timeSet: EventEmitter<string>;
    timeUpdated: BehaviorSubject<string>;
    private _appendToInput;
    private _color;
    private _dialogRef;
    private _dottedMinutesInGap;
    private _enableKeyboardInput;
    private _format;
    private _minutesGap;
    private _overlayRef;
    private _timepickerInput;
    constructor(_dialog: MatDialog);
    close(): void;
    open(): void;
    /***
     * Register an input with this timepicker.
     * input - The timepicker input to register with this timepicker
     */
    registerInput(input: NgxMatTimepickerDirective): void;
    unregisterInput(): void;
    updateTime(time: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerComponent, "ngx-mat-timepicker", never, { "appendToInput": { "alias": "appendToInput"; "required": false; }; "color": { "alias": "color"; "required": false; }; "dottedMinutesInGap": { "alias": "dottedMinutesInGap"; "required": false; }; "enableKeyboardInput": { "alias": "enableKeyboardInput"; "required": false; }; "format": { "alias": "format"; "required": false; }; "minutesGap": { "alias": "minutesGap"; "required": false; }; "cancelBtnTmpl": { "alias": "cancelBtnTmpl"; "required": false; }; "confirmBtnTmpl": { "alias": "confirmBtnTmpl"; "required": false; }; "defaultTime": { "alias": "defaultTime"; "required": false; }; "disableAnimation": { "alias": "disableAnimation"; "required": false; }; "editableHintTmpl": { "alias": "editableHintTmpl"; "required": false; }; "hoursOnly": { "alias": "hoursOnly"; "required": false; }; "isEsc": { "alias": "isEsc"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "preventOverlayClick": { "alias": "preventOverlayClick"; "required": false; }; "timepickerClass": { "alias": "timepickerClass"; "required": false; }; }, { "closed": "closed"; "hourSelected": "hourSelected"; "opened": "opened"; "timeChanged": "timeChanged"; "timeSet": "timeSet"; }, never, never, true, never>;
}

declare class NgxMatTimepickerLocaleService {
    get locale(): string;
    protected _initialLocale: string;
    protected _locale: string;
    constructor(initialLocale: string);
    updateLocale(newValue: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerLocaleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMatTimepickerLocaleService>;
}

interface NgxMatTimepickerClockFace {
    angle: number;
    disabled?: boolean;
    time: number;
}

declare enum NgxMatTimepickerPeriods {
    AM = "AM",
    PM = "PM"
}

declare class NgxMatTimepickerService {
    set hour(hour: NgxMatTimepickerClockFace);
    set minute(minute: NgxMatTimepickerClockFace);
    set period(period: NgxMatTimepickerPeriods);
    get selectedHour(): Observable<NgxMatTimepickerClockFace>;
    get selectedMinute(): Observable<NgxMatTimepickerClockFace>;
    get selectedPeriod(): Observable<NgxMatTimepickerPeriods>;
    private _hour$;
    private _minute$;
    private _period$;
    getFullTime(format: number): string;
    setDefaultTimeIfAvailable(time: string, min: DateTime, max: DateTime, format: number, minutesGap?: number): void;
    private _resetTime;
    private _setDefaultTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMatTimepickerService>;
}

declare enum NgxMatTimepickerUnits {
    HOUR = 0,
    MINUTE = 1
}

declare class NgxMatTimepickerFieldComponent implements OnInit, OnDestroy, ControlValueAccessor {
    private _timepickerService;
    private _timepickerLocaleSrv;
    get color(): ThemePalette;
    set color(newValue: ThemePalette);
    get defaultTime(): string;
    set defaultTime(val: string);
    get floatLabel(): FloatLabelType;
    set floatLabel(newValue: FloatLabelType);
    get format(): NgxMatTimepickerFormatType;
    set format(value: NgxMatTimepickerFormatType);
    get max(): DateTime;
    set max(value: string | DateTime);
    get min(): DateTime;
    set min(value: string | DateTime);
    private get _locale();
    cancelBtnTmpl: TemplateRef<Node>;
    confirmBtnTmpl: TemplateRef<Node>;
    controlOnly: boolean;
    disabled: boolean;
    hour$: BehaviorSubject<NgxMatTimepickerClockFace>;
    hoursList: NgxMatTimepickerClockFace[];
    isChangePeriodDisabled: boolean;
    isTimeRangeSet: boolean;
    maxHour: number;
    minHour: number;
    minute$: BehaviorSubject<NgxMatTimepickerClockFace>;
    minutesList: NgxMatTimepickerClockFace[];
    period: NgxMatTimepickerPeriods;
    periods: NgxMatTimepickerPeriods[];
    timeChanged: EventEmitter<string>;
    timepickerTime: string;
    timeUnit: typeof NgxMatTimepickerUnits;
    toggleIcon: TemplateRef<HTMLObjectElement>;
    private _color;
    private _defaultTime;
    private _floatLabel;
    private _format;
    private _isDefaultTime;
    private _isFirstTimeChange;
    private _max;
    private _min;
    private _previousFormat;
    private _selectedHour;
    private _subsCtrl$;
    constructor(_timepickerService: NgxMatTimepickerService, _timepickerLocaleSrv: NgxMatTimepickerLocaleService);
    changeHour(hour: number): void;
    changeMinute(minute: number): void;
    changePeriod(event: MatSelectChange): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    onTimeSet(time: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    writeValue(val: string): void;
    private _changeDefaultTimeValue;
    private _changeTime;
    private _emitLocalTimeChange;
    private _initTime;
    private _isPeriodDisabled;
    private _onChange;
    private _onTouched;
    private _resetTime;
    private _updateAvailableHours;
    private _updateAvailableMinutes;
    private _updateAvailableTime;
    private _updateTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerFieldComponent, "ngx-mat-timepicker-field", never, { "color": { "alias": "color"; "required": false; }; "defaultTime": { "alias": "defaultTime"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "format": { "alias": "format"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "cancelBtnTmpl": { "alias": "cancelBtnTmpl"; "required": false; }; "confirmBtnTmpl": { "alias": "confirmBtnTmpl"; "required": false; }; "controlOnly": { "alias": "controlOnly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "toggleIcon": { "alias": "toggleIcon"; "required": false; }; }, { "timeChanged": "timeChanged"; }, never, never, true, never>;
}

declare class NgxMatTimepickerToggleIconDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerToggleIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatTimepickerToggleIconDirective, "[ngxMatTimepickerToggleIcon]", never, {}, {}, never, never, true, never>;
}

declare class NgxMatTimepickerToggleComponent {
    get disabled(): boolean;
    set disabled(value: boolean);
    customIcon: NgxMatTimepickerToggleIconDirective;
    timepicker: NgxMatTimepickerComponent;
    private _disabled;
    open(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerToggleComponent, "ngx-mat-timepicker-toggle", never, { "disabled": { "alias": "disabled"; "required": false; }; "timepicker": { "alias": "for"; "required": false; }; }, {}, ["customIcon"], ["[ngxMatTimepickerToggleIcon]"], true, never>;
}

interface NgxMatTimepickerConfig {
    appendToInput: boolean;
    cancelBtnTmpl: TemplateRef<Node>;
    color: ThemePalette;
    confirmBtnTmpl: TemplateRef<Node>;
    defaultTime: string;
    disableAnimation: boolean;
    disabled: boolean;
    dottedMinutesInGap: boolean;
    editableHintTmpl: TemplateRef<Node>;
    enableKeyboardInput: boolean;
    format: NgxMatTimepickerFormatType;
    hoursOnly: boolean;
    inputElement: any;
    maxTime: DateTime;
    minTime: DateTime;
    minutesGap: number;
    preventOverlayClick: boolean;
    time: string;
    timepickerBaseRef: NgxMatTimepickerRef;
    timepickerClass: string;
}

declare class NgxMatTimepickerEventService {
    get backdropClick(): Observable<MouseEvent>;
    get keydownEvent(): Observable<KeyboardEvent>;
    private _backdropClick$;
    private _keydownEvent$;
    constructor();
    dispatchEvent(event: KeyboardEvent | MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMatTimepickerEventService>;
}

declare class NgxMatTimepickerBaseDirective implements OnInit, OnDestroy {
    protected _timepickerSrv: NgxMatTimepickerService;
    protected _eventSrv: NgxMatTimepickerEventService;
    protected _timepickerLocaleSrv: NgxMatTimepickerLocaleService;
    data: NgxMatTimepickerConfig;
    set color(newValue: ThemePalette);
    get color(): ThemePalette;
    get defaultTime(): string;
    set defaultTime(time: string);
    private get _locale();
    activeTimeUnit: NgxMatTimepickerUnits;
    selectedHour: Observable<NgxMatTimepickerClockFace>;
    selectedMinute: Observable<NgxMatTimepickerClockFace>;
    selectedPeriod: Observable<NgxMatTimepickerPeriods>;
    timeUnit: typeof NgxMatTimepickerUnits;
    protected _color: ThemePalette;
    protected _defaultTime: string;
    protected _subsCtrl$: Subject<void>;
    constructor(_timepickerSrv: NgxMatTimepickerService, _eventSrv: NgxMatTimepickerEventService, _timepickerLocaleSrv: NgxMatTimepickerLocaleService, data: NgxMatTimepickerConfig);
    changePeriod(period: NgxMatTimepickerPeriods): void;
    changeTimeUnit(unit: NgxMatTimepickerUnits): void;
    close(): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    onHourChange(hour: NgxMatTimepickerClockFace): void;
    onHourSelected(hour: number): void;
    onKeydown(e: any): void;
    onMinuteChange(minute: NgxMatTimepickerClockFace): void;
    setTime(): void;
    protected _defineTime(): void;
    protected _onTimeChange(): void;
    protected _setDefaultTime(time: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatTimepickerBaseDirective, "[ngxMatTimepickerBase]", never, { "color": { "alias": "color"; "required": false; }; "defaultTime": { "alias": "defaultTime"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NgxMatTimepickerHoursFaceDirective {
    set color(newValue: ThemePalette);
    get color(): ThemePalette;
    set format(newValue: NgxMatTimepickerFormatType);
    get format(): NgxMatTimepickerFormatType;
    hourChange: EventEmitter<NgxMatTimepickerClockFace>;
    hourSelected: EventEmitter<number>;
    hoursList: NgxMatTimepickerClockFace[];
    maxTime: DateTime;
    minTime: DateTime;
    selectedHour: NgxMatTimepickerClockFace;
    protected _color: ThemePalette;
    protected _format: NgxMatTimepickerFormatType;
    constructor();
    onTimeSelected(time: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerHoursFaceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatTimepickerHoursFaceDirective, "[ngxMatTimepickerHoursFace]", never, { "color": { "alias": "color"; "required": false; }; "format": { "alias": "format"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "selectedHour": { "alias": "selectedHour"; "required": false; }; }, { "hourChange": "hourChange"; "hourSelected": "hourSelected"; }, never, never, true, never>;
}

declare class NgxMatTimepickerActiveHourPipe implements PipeTransform {
    transform(hour: number, currentHour: number, isClockFaceDisabled: boolean): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerActiveHourPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatTimepickerActiveHourPipe, "activeHour", true>;
}

declare class NgxMatTimepickerActiveMinutePipe implements PipeTransform {
    transform(minute: number, currentMinute: number, gap: number | void, isClockFaceDisabled: boolean): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerActiveMinutePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatTimepickerActiveMinutePipe, "activeMinute", true>;
}

declare class NgxMatTimepickerDialComponent implements OnChanges {
    private _localeSrv;
    activeTimeUnit: NgxMatTimepickerUnits;
    set color(newValue: ThemePalette);
    get color(): ThemePalette;
    get hourString(): string;
    get minuteString(): string;
    private get _locale();
    editableHintTmpl: TemplateRef<Node>;
    format: NgxMatTimepickerFormatType;
    hour: number | string;
    hourChanged: EventEmitter<NgxMatTimepickerClockFace>;
    hours: NgxMatTimepickerClockFace[];
    hoursOnly: boolean;
    isEditable: boolean;
    isHintVisible: boolean;
    maxTime: DateTime;
    meridiems: string[];
    minTime: DateTime;
    minute: number | string;
    minuteChanged: EventEmitter<NgxMatTimepickerClockFace>;
    minutes: NgxMatTimepickerClockFace[];
    minutesGap: number;
    period: NgxMatTimepickerPeriods;
    periodChanged: EventEmitter<NgxMatTimepickerPeriods>;
    timeUnit: typeof NgxMatTimepickerUnits;
    timeUnitChanged: EventEmitter<NgxMatTimepickerUnits>;
    private _color;
    constructor(_localeSrv: NgxMatTimepickerLocaleService);
    changeHour(hour: NgxMatTimepickerClockFace): void;
    changeMinute(minute: NgxMatTimepickerClockFace): void;
    changePeriod(period: NgxMatTimepickerPeriods): void;
    changeTimeUnit(unit: NgxMatTimepickerUnits): void;
    hideHint(): void;
    ngOnChanges(changes: SimpleChanges): void;
    showHint(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerDialComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerDialComponent, "ngx-mat-timepicker-dial", never, { "activeTimeUnit": { "alias": "activeTimeUnit"; "required": false; }; "color": { "alias": "color"; "required": false; }; "editableHintTmpl": { "alias": "editableHintTmpl"; "required": false; }; "format": { "alias": "format"; "required": false; }; "hour": { "alias": "hour"; "required": false; }; "hoursOnly": { "alias": "hoursOnly"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "minute": { "alias": "minute"; "required": false; }; "minutesGap": { "alias": "minutesGap"; "required": false; }; "period": { "alias": "period"; "required": false; }; }, { "hourChanged": "hourChanged"; "minuteChanged": "minuteChanged"; "periodChanged": "periodChanged"; "timeUnitChanged": "timeUnitChanged"; }, never, never, true, never>;
}

declare class NgxMatTimepickerParserPipe implements PipeTransform {
    private _timepickerLocaleSrv;
    private get _locale();
    private readonly _numberingSystem;
    constructor(_timepickerLocaleSrv: NgxMatTimepickerLocaleService);
    transform(time: string | number, timeUnit?: NgxMatTimepickerUnits): string;
    private _parseTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerParserPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatTimepickerParserPipe, "ngxMatTimepickerParser", true>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMatTimepickerParserPipe>;
}

declare class NgxMatTimepickerDialControlComponent implements AfterViewInit, OnDestroy {
    private _elRef;
    private _timeParserPipe;
    private get _selectedTime();
    disabled: boolean;
    focused: EventEmitter<void>;
    isActive: boolean;
    isEditable: boolean;
    minutesGap: number;
    previousTime: number | string;
    time: string;
    timeChanged: EventEmitter<NgxMatTimepickerClockFace>;
    timeList: NgxMatTimepickerClockFace[];
    timeUnit: NgxMatTimepickerUnits;
    timeUnitChanged: EventEmitter<NgxMatTimepickerUnits>;
    unfocused: EventEmitter<void>;
    constructor(_elRef: ElementRef, _timeParserPipe: NgxMatTimepickerParserPipe);
    changeTimeByKeyboard(e: any): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onKeydown(e: any): void;
    onModelChange(value: string): void;
    saveTimeAndChangeTimeUnit(event: FocusEvent, unit: NgxMatTimepickerUnits): void;
    updateTime(): void;
    private _addTime;
    private _changeTimeByArrow;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerDialControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerDialControlComponent, "ngx-mat-timepicker-dial-control", never, { "disabled": { "alias": "disabled"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "isEditable": { "alias": "isEditable"; "required": false; }; "minutesGap": { "alias": "minutesGap"; "required": false; }; "time": { "alias": "time"; "required": false; }; "timeList": { "alias": "timeList"; "required": false; }; "timeUnit": { "alias": "timeUnit"; "required": false; }; }, { "focused": "focused"; "timeChanged": "timeChanged"; "timeUnitChanged": "timeUnitChanged"; "unfocused": "unfocused"; }, never, never, true, never>;
}

declare class NgxMatTimepickerDialogComponent extends NgxMatTimepickerBaseDirective {
    data: NgxMatTimepickerConfig;
    protected _dialogRef: MatDialogRef<NgxMatTimepickerDialogComponent>;
    constructor(data: NgxMatTimepickerConfig, _dialogRef: MatDialogRef<NgxMatTimepickerDialogComponent>, timepickerSrv: NgxMatTimepickerService, eventSrv: NgxMatTimepickerEventService, timepickerLocaleSrv: NgxMatTimepickerLocaleService);
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerDialogComponent, "ngx-mat-timepicker-dialog", never, {}, {}, never, never, true, never>;
}

declare class NgxMatTimepickerFaceComponent implements AfterViewInit, OnChanges, OnDestroy {
    clockFace: ElementRef;
    clockHand: ElementRef;
    color: ThemePalette;
    dottedMinutesInGap: boolean;
    faceTime: NgxMatTimepickerClockFace[];
    format: NgxMatTimepickerFormatType;
    innerClockFaceSize: number;
    isClockFaceDisabled: boolean;
    minutesGap: number;
    selectedTime: NgxMatTimepickerClockFace;
    timeChange: EventEmitter<NgxMatTimepickerClockFace>;
    timeSelected: EventEmitter<number>;
    timeUnit: typeof NgxMatTimepickerUnits;
    unit: NgxMatTimepickerUnits;
    private _isStarted;
    private _touchEndHandler;
    private _touchStartHandler;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onMousedown(e: any): void;
    onMouseup(e: any): void;
    selectTime(e: any): void;
    trackByTime(_item_: any, time: NgxMatTimepickerClockFace): string | number;
    private _addTouchEvents;
    private _decreaseClockHand;
    private _increaseClockHand;
    private _isInnerClockFace;
    private _removeTouchEvents;
    private _selectAvailableTime;
    private _setClockHandPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerFaceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerFaceComponent, "ngx-mat-timepicker-face", never, { "color": { "alias": "color"; "required": false; }; "dottedMinutesInGap": { "alias": "dottedMinutesInGap"; "required": false; }; "faceTime": { "alias": "faceTime"; "required": false; }; "format": { "alias": "format"; "required": false; }; "minutesGap": { "alias": "minutesGap"; "required": false; }; "selectedTime": { "alias": "selectedTime"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; }, { "timeChange": "timeChange"; "timeSelected": "timeSelected"; }, never, ["*", "*"], true, never>;
}

declare class NgxMatTimepickerMinutesFaceComponent implements OnChanges {
    set color(newValue: ThemePalette);
    get color(): ThemePalette;
    dottedMinutesInGap: boolean;
    format: NgxMatTimepickerFormatType;
    maxTime: DateTime;
    minTime: DateTime;
    minuteChange: EventEmitter<NgxMatTimepickerClockFace>;
    minutesGap: number;
    minutesList: NgxMatTimepickerClockFace[];
    period: NgxMatTimepickerPeriods;
    selectedHour: number;
    selectedMinute: NgxMatTimepickerClockFace;
    timeUnit: typeof NgxMatTimepickerUnits;
    private _color;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerMinutesFaceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerMinutesFaceComponent, "ngx-mat-timepicker-minutes-face", never, { "color": { "alias": "color"; "required": false; }; "dottedMinutesInGap": { "alias": "dottedMinutesInGap"; "required": false; }; "format": { "alias": "format"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "minutesGap": { "alias": "minutesGap"; "required": false; }; "period": { "alias": "period"; "required": false; }; "selectedHour": { "alias": "selectedHour"; "required": false; }; "selectedMinute": { "alias": "selectedMinute"; "required": false; }; }, { "minuteChange": "minuteChange"; }, never, never, true, never>;
}

declare class NgxMatTimepickerPeriodComponent {
    protected _overlay: Overlay;
    activeTimeUnit: NgxMatTimepickerUnits;
    format: NgxMatTimepickerFormatType;
    hours: NgxMatTimepickerClockFace[];
    isPeriodAvailable: boolean;
    maxTime: DateTime;
    meridiems: string[];
    minTime: DateTime;
    minutes: NgxMatTimepickerClockFace[];
    overlayPositionStrategy: FlexibleConnectedPositionStrategy;
    overlayScrollStrategy: ScrollStrategy;
    periodChanged: EventEmitter<NgxMatTimepickerPeriods>;
    selectedHour: number | string;
    selectedPeriod: NgxMatTimepickerPeriods;
    timePeriod: typeof NgxMatTimepickerPeriods;
    constructor(_overlay: Overlay);
    animationDone(): void;
    changePeriod(period: NgxMatTimepickerPeriods): void;
    private _getDisabledTimeByPeriod;
    private _isSwitchPeriodAvailable;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerPeriodComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerPeriodComponent, "ngx-mat-timepicker-period", never, { "activeTimeUnit": { "alias": "activeTimeUnit"; "required": false; }; "format": { "alias": "format"; "required": false; }; "hours": { "alias": "hours"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "meridiems": { "alias": "meridiems"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "minutes": { "alias": "minutes"; "required": false; }; "selectedHour": { "alias": "selectedHour"; "required": false; }; "selectedPeriod": { "alias": "selectedPeriod"; "required": false; }; }, { "periodChanged": "periodChanged"; }, never, never, true, never>;
}

declare class NgxMatTimepickerStandaloneComponent extends NgxMatTimepickerBaseDirective {
    data: NgxMatTimepickerConfig;
    constructor(data: NgxMatTimepickerConfig, timepickerSrv: NgxMatTimepickerService, eventSrv: NgxMatTimepickerEventService, timepickerLocaleSrv: NgxMatTimepickerLocaleService);
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerStandaloneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerStandaloneComponent, "ngx-mat-timepicker-standalone", never, {}, {}, never, never, true, never>;
}

declare class NgxMatTimepicker12HoursFaceComponent extends NgxMatTimepickerHoursFaceDirective implements OnChanges {
    period: NgxMatTimepickerPeriods;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepicker12HoursFaceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepicker12HoursFaceComponent, "ngx-mat-timepicker-12-hours-face", never, { "period": { "alias": "period"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NgxMatTimepicker24HoursFaceComponent extends NgxMatTimepickerHoursFaceDirective implements AfterContentInit {
    constructor();
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepicker24HoursFaceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepicker24HoursFaceComponent, "ngx-mat-timepicker-24-hours-face", never, {}, {}, never, never, true, never>;
}

declare class NgxMatTimepickerAutofocusDirective implements OnChanges, OnDestroy {
    private _element;
    private _document;
    isFocusActive: boolean;
    private _activeElement;
    constructor(_element: ElementRef, _document: any);
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerAutofocusDirective, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatTimepickerAutofocusDirective, "[ngxMatTimepickerAutofocus]", never, { "isFocusActive": { "alias": "ngxMatTimepickerAutofocus"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NgxMatTimepickerMinutesFormatterPipe implements PipeTransform {
    transform(minute: number, gap?: number): number | string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerMinutesFormatterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatTimepickerMinutesFormatterPipe, "minutesFormatter", true>;
}

declare class NgxMatTimepickerControlComponent implements OnChanges {
    private _timeParser;
    static nextId: number;
    set color(newValue: ThemePalette);
    get color(): ThemePalette;
    disabled: boolean;
    set floatLabel(newValue: FloatLabelType);
    get floatLabel(): FloatLabelType;
    id: number;
    isFocused: boolean;
    max: number;
    min: number;
    placeholder: string;
    preventTyping: boolean;
    time: number;
    timeChanged: EventEmitter<number>;
    timeList: NgxMatTimepickerClockFace[];
    timeUnit: NgxMatTimepickerUnits;
    private _color;
    private _floatLabel;
    private _previousTime;
    constructor(_timeParser: NgxMatTimepickerParserPipe);
    changeTime(event: InputEvent): void;
    decrease(): void;
    increase(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onBlur(): void;
    onFocus(): void;
    onKeydown(event: any): void;
    onModelChange(value: string): void;
    private _changeTimeIfValid;
    private _getAvailableTime;
    private _getNextAvailableTime;
    private _getPrevAvailableTime;
    private _isSelectedTimeDisabled;
    private _setAvailableTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerControlComponent, "ngx-mat-timepicker-time-control", never, { "color": { "alias": "color"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "preventTyping": { "alias": "preventTyping"; "required": false; }; "time": { "alias": "time"; "required": false; }; "timeList": { "alias": "timeList"; "required": false; }; "timeUnit": { "alias": "timeUnit"; "required": false; }; }, { "timeChanged": "timeChanged"; }, never, never, true, never>;
}

declare class NgxMatTimepickerContentComponent {
    appendToInput: boolean;
    inputElement: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatTimepickerContentComponent, "ngx-mat-timepicker-content", never, { "appendToInput": { "alias": "appendToInput"; "required": false; }; "inputElement": { "alias": "inputElement"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class NgxMatTimepickerTimeFormatterPipe implements PipeTransform {
    transform(time: number | string, timeUnit: NgxMatTimepickerUnits): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerTimeFormatterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatTimepickerTimeFormatterPipe, "timeFormatter", true>;
}

declare class NgxMatTimepickerTimeLocalizerPipe implements PipeTransform {
    private _timepickerLocaleSrv;
    private get _locale();
    constructor(_timepickerLocaleSrv: NgxMatTimepickerLocaleService);
    transform(time: number | string, timeUnit: NgxMatTimepickerUnits, isKeyboardEnabled?: boolean): string;
    private _formatTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerTimeLocalizerPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxMatTimepickerTimeLocalizerPipe, "timeLocalizer", true>;
}

declare class NgxMatTimepickerModule {
    static setLocale(locale: string): ModuleWithProviders<NgxMatTimepickerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatTimepickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatTimepickerModule, never, [typeof i1.CommonModule, typeof i2.A11yModule, typeof i3.FormsModule, typeof i4.MatButtonModule, typeof i5.MatFormFieldModule, typeof i6.MatDialogModule, typeof i7.MatInputModule, typeof i8.MatSelectModule, typeof i9.MatToolbarModule, typeof i10.MatIconModule, typeof i11.OverlayModule, typeof i12.PortalModule, typeof NgxMatTimepickerBaseDirective, typeof NgxMatTimepickerHoursFaceDirective, typeof NgxMatTimepickerActiveHourPipe, typeof NgxMatTimepickerActiveMinutePipe, typeof NgxMatTimepickerComponent, typeof NgxMatTimepickerDialComponent, typeof NgxMatTimepickerDialControlComponent, typeof NgxMatTimepickerDialogComponent, typeof NgxMatTimepickerDirective, typeof NgxMatTimepickerFaceComponent, typeof NgxMatTimepickerMinutesFaceComponent, typeof NgxMatTimepickerPeriodComponent, typeof NgxMatTimepickerStandaloneComponent, typeof NgxMatTimepickerToggleComponent, typeof NgxMatTimepicker12HoursFaceComponent, typeof NgxMatTimepicker24HoursFaceComponent, typeof NgxMatTimepickerToggleIconDirective, typeof NgxMatTimepickerAutofocusDirective, typeof NgxMatTimepickerMinutesFormatterPipe, typeof NgxMatTimepickerFieldComponent, typeof NgxMatTimepickerControlComponent, typeof NgxMatTimepickerParserPipe, typeof NgxMatTimepickerContentComponent, typeof NgxMatTimepickerTimeFormatterPipe, typeof NgxMatTimepickerTimeLocalizerPipe], [typeof NgxMatTimepickerComponent, typeof NgxMatTimepickerToggleComponent, typeof NgxMatTimepickerFieldComponent, typeof NgxMatTimepickerDirective, typeof NgxMatTimepickerToggleIconDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatTimepickerModule>;
}

export { NgxMatTimepickerComponent, NgxMatTimepickerDirective, NgxMatTimepickerFieldComponent, NgxMatTimepickerLocaleService, NgxMatTimepickerModule, NgxMatTimepickerToggleComponent, NgxMatTimepickerToggleIconDirective };
export type { NgxMatTimepickerConfig, NgxMatTimepickerFormatType };