import * as _angular_core from '@angular/core';
import { InjectionToken } from '@angular/core';
import { MXValueComponent, AXValueChangedEvent } from '@acorex/cdk/common';

type AXSchedulerPickerMode = 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly';
/**
 * Occurrence position and day of week
 * Used for monthly and yearly recurrence patterns
 */
interface AXSchedulerPickerOccurrence {
    position: 1 | 2 | 3 | 4 | -1;
    day: number;
}
/**
 * Main value structure for scheduler picker
 * General pattern that works for all modes
 */
type AXSchedulerPickerValue = {
    mode: AXSchedulerPickerMode;
    interval: number;
    startCondition: {
        type: 'now' | 'byDate';
        startDate: Date;
    };
    recurrence: {
        byDay?: number[];
        byOccurrence?: Array<{
            position: 1 | 2 | 3 | 4 | -1;
            dayOfWeek: number;
        }>;
        byMonth?: number[];
        byMinute?: number[];
        byHour?: number[];
    };
    endCondition: {
        type: 'never' | 'afterOccurrences' | 'byDate';
        occurrences?: number;
        endDate?: Date;
    };
    exclusions?: Date[];
    inclusions?: Date[];
};
/**
 * Recurrence selection mode for monthly scheduling
 */
type AXSchedulerPickerMonthlyRecurrenceMode = 'none' | 'specificDays' | 'occurrence';
/**
 * Recurrence selection mode for yearly scheduling
 */
type AXSchedulerPickerYearlyRecurrenceMode = 'none' | 'specificDate' | 'occurrence';
/**
 * Mode-specific feature options
 */
type AXSchedulerPickerHourlyOptions = {
    showInterval?: boolean;
};
type AXSchedulerPickerDailyOptions = {
    showInterval?: boolean;
    showWeekdaysOnly?: boolean;
};
type AXSchedulerPickerWeeklyOptions = {
    showInterval?: boolean;
    showWeekdaySelection?: boolean;
};
type AXSchedulerPickerMonthlyOptions = {
    showInterval?: boolean;
    recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
};
type AXSchedulerPickerYearlyOptions = {
    showInterval?: boolean;
    recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
    showMonthSelection?: boolean;
};
/**
 * Type-safe union based on mode
 */
type AXSchedulerPickerOptions<T extends AXSchedulerPickerMode> = T extends 'hourly' ? AXSchedulerPickerHourlyOptions : T extends 'daily' ? AXSchedulerPickerDailyOptions : T extends 'weekly' ? AXSchedulerPickerWeeklyOptions : T extends 'monthly' ? AXSchedulerPickerMonthlyOptions : T extends 'yearly' ? AXSchedulerPickerYearlyOptions : never;
/**
 * Custom validator function type
 */
type AXSchedulerPickerCustomValidator = (value: AXSchedulerPickerValue, settings: AXSchedulerPickerSettings) => AXSchedulerPickerValidationError | null;
/**
 * Validation error codes
 */
type AXSchedulerPickerValidationErrorCode = 'required' | 'invalid' | 'outOfRange' | 'conflict' | 'empty' | 'invalidDate' | 'pastDate' | 'custom';
/**
 * Validation error structure
 */
type AXSchedulerPickerValidationError = {
    field: string;
    code: AXSchedulerPickerValidationErrorCode;
    message: string;
    params?: Record<string, any>;
};
/**
 * Type-safe settings based on mode
 */
type AXSchedulerPickerSettings<T extends AXSchedulerPickerMode = AXSchedulerPickerMode> = {
    mode: T;
    options?: AXSchedulerPickerOptions<T>;
    showStartCondition?: boolean;
    showEndConditions?: boolean;
    showExclusions?: boolean;
    showInclusions?: boolean;
    minInterval?: number;
    maxInterval?: number;
    minDate?: Date;
    maxDate?: Date;
    defaultInterval?: number;
    firstDayOfWeek?: number;
    locale?: string;
    customValidators?: AXSchedulerPickerCustomValidator[];
    holidayProvider?: () => Date[] | Promise<Date[]>;
};
type AXSchedulerPickerConfig<T extends AXSchedulerPickerMode = AXSchedulerPickerMode> = AXSchedulerPickerSettings<T>;
type AXSchedulerPickerHourlyConfig = AXSchedulerPickerSettings<'hourly'>;
type AXSchedulerPickerDailyConfig = AXSchedulerPickerSettings<'daily'>;
type AXSchedulerPickerWeeklyConfig = AXSchedulerPickerSettings<'weekly'>;
type AXSchedulerPickerMonthlyConfig = AXSchedulerPickerSettings<'monthly'>;
type AXSchedulerPickerYearlyConfig = AXSchedulerPickerSettings<'yearly'>;

/**
 * A powerful, fully customizable scheduler picker component for creating recurrence patterns
 *
 * ## Features
 * - Supports 5 modes: hourly, daily, weekly, monthly, and yearly
 * - Flexible start and end conditions
 * - Date exclusions and inclusions
 * - Natural language summary generation
 * - Export to Cron and RRule (iCalendar) formats
 * - Full i18n support
 * - Type-safe configuration
 *
 * ## Basic Usage
 * ```typescript
 * <ax-scheduler-picker
 *   [config]="{ mode: 'daily', showEndConditions: true }"
 *   [(value)]="pattern"
 *   (summaryChange)="onSummaryChange($event)"
 * />
 * ```
 *
 * ## Public API
 * - `validatePattern()` - Manually trigger validation
 * - `getPreview(count)` - Get next N occurrences
 * - `toCron()` - Convert to cron expression
 * - `toRRule()` - Convert to RRule string
 * - `reset()` - Reset to default pattern
 * - `clear()` - Clear all data
 * - `validationErrors` - Signal containing current validation errors
 *
 * @category Components
 */
declare class AXSchedulerPickerComponent extends MXValueComponent<AXSchedulerPickerValue> {
    /**
     * Settings for the scheduler picker
     * Controls which options are visible and behavior
     */
    config: _angular_core.InputSignal<AXSchedulerPickerSettings>;
    /**
     * Emits when the human-readable summary changes
     */
    summaryChange: _angular_core.OutputEmitterRef<string>;
    private service;
    /**
     * Internal pattern value
     */
    protected pattern: _angular_core.WritableSignal<AXSchedulerPickerValue>;
    /**
     * Current mode derived from config
     */
    protected mode: _angular_core.Signal<AXSchedulerPickerMode>;
    /**
     * Effect run counter to prevent stale async updates
     */
    private effectRunId;
    /**
     * Merged configuration with defaults
     */
    protected mergedConfig: _angular_core.Signal<{
        options: {
            showInterval?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        };
        mode: AXSchedulerPickerMode;
        showStartCondition?: boolean;
        showEndConditions?: boolean;
        showExclusions?: boolean;
        showInclusions?: boolean;
        minInterval?: number;
        maxInterval?: number;
        minDate?: Date;
        maxDate?: Date;
        defaultInterval?: number;
        firstDayOfWeek?: number;
        locale?: string;
        customValidators?: AXSchedulerPickerCustomValidator[];
        holidayProvider?: () => Date[] | Promise<Date[]>;
    } | {
        options: {
            showInterval?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        };
        mode: AXSchedulerPickerMode;
        showStartCondition?: boolean;
        showEndConditions?: boolean;
        showExclusions?: boolean;
        showInclusions?: boolean;
        minInterval?: number;
        maxInterval?: number;
        minDate?: Date;
        maxDate?: Date;
        defaultInterval?: number;
        firstDayOfWeek?: number;
        locale?: string;
        customValidators?: AXSchedulerPickerCustomValidator[];
        holidayProvider?: () => Date[] | Promise<Date[]>;
    } | {
        options: {
            showInterval?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        };
        mode: AXSchedulerPickerMode;
        showStartCondition?: boolean;
        showEndConditions?: boolean;
        showExclusions?: boolean;
        showInclusions?: boolean;
        minInterval?: number;
        maxInterval?: number;
        minDate?: Date;
        maxDate?: Date;
        defaultInterval?: number;
        firstDayOfWeek?: number;
        locale?: string;
        customValidators?: AXSchedulerPickerCustomValidator[];
        holidayProvider?: () => Date[] | Promise<Date[]>;
    } | {
        options: {
            showInterval?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        };
        mode: AXSchedulerPickerMode;
        showStartCondition?: boolean;
        showEndConditions?: boolean;
        showExclusions?: boolean;
        showInclusions?: boolean;
        minInterval?: number;
        maxInterval?: number;
        minDate?: Date;
        maxDate?: Date;
        defaultInterval?: number;
        firstDayOfWeek?: number;
        locale?: string;
        customValidators?: AXSchedulerPickerCustomValidator[];
        holidayProvider?: () => Date[] | Promise<Date[]>;
    } | {
        options: {
            showInterval?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaysOnly?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
            showWeekdaySelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerMonthlyRecurrenceMode;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaysOnly?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            showWeekdaySelection?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: "none" | "specificDays" | "occurrence" | "specificDate";
            showMonthSelection?: boolean;
        } | {
            showInterval?: boolean;
            recurrenceMode?: AXSchedulerPickerYearlyRecurrenceMode;
            showMonthSelection?: boolean;
        };
        mode: AXSchedulerPickerMode;
        showStartCondition?: boolean;
        showEndConditions?: boolean;
        showExclusions?: boolean;
        showInclusions?: boolean;
        minInterval?: number;
        maxInterval?: number;
        minDate?: Date;
        maxDate?: Date;
        defaultInterval?: number;
        firstDayOfWeek?: number;
        locale?: string;
        customValidators?: AXSchedulerPickerCustomValidator[];
        holidayProvider?: () => Date[] | Promise<Date[]>;
    }>;
    /**
     * Validation errors (public for external access)
     */
    readonly validationErrors: _angular_core.WritableSignal<string[]>;
    /**
     * Human-readable summary of the pattern
     */
    protected summary: _angular_core.WritableSignal<string>;
    protected internalValueChanged(value: AXSchedulerPickerValue): void;
    constructor();
    /**
     * Initialize with default value based on mode
     */
    protected initializeDefaultValue(): void;
    /**
     * Update pattern value
     */
    protected updatePattern(updates: Partial<AXSchedulerPickerValue>): void;
    /**
     * Deep merge pattern updates with current pattern
     * Preserves nested object properties that aren't being updated
     */
    private mergePatternUpdates;
    /**
     * Manually validate the current pattern
     *
     * Validates the pattern against configured rules and constraints.
     * Updates the `validationErrors` signal and component state.
     *
     * @returns Promise resolving to `true` if pattern is valid, `false` otherwise
     *
     * @example
     * ```typescript
     * const isValid = await schedulerPicker.validatePattern();
     * if (!isValid) {
     *   const errors = schedulerPicker.validationErrors();
     *   console.log('Validation errors:', errors);
     * }
     * ```
     */
    validatePattern(): Promise<boolean>;
    /**
     * Get preview of next N occurrences based on the current pattern
     *
     * @param count - Number of occurrences to return (default: 10)
     * @param startFrom - Optional starting date (default: now)
     * @returns Promise resolving to array of dates representing next occurrences
     * @returns Empty array if pattern is invalid or not set
     *
     * @example
     * ```typescript
     * const dates = await schedulerPicker.getPreview(5);
     * console.log('Next 5 occurrences:', dates);
     * ```
     */
    getPreview(count?: number, startFrom?: Date): Promise<Date[]>;
    /**
     * Convert current pattern to cron expression
     *
     * @returns Promise resolving to cron expression string
     * @returns Empty string if pattern is not set or invalid
     *
     * @example
     * ```typescript
     * const cron = await schedulerPicker.toCron();
     * console.log('Cron expression:', cron); // "0 9 * * 1-5"
     * ```
     */
    toCron(): Promise<string>;
    /**
     * Convert current pattern to RRule string (iCalendar format)
     *
     * @returns Promise resolving to RRule string
     * @returns Empty string if pattern is not set or invalid
     *
     * @example
     * ```typescript
     * const rrule = await schedulerPicker.toRRule();
     * console.log('RRule:', rrule); // "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR"
     * ```
     */
    toRRule(): Promise<string>;
    /**
     * Reset pattern to default value based on current mode
     * Clears current pattern and re-initializes with mode-specific defaults
     *
     * @param e - Optional event parameter (inherited from base class)
     *
     * @example
     * ```typescript
     * schedulerPicker.reset();
     * // Pattern is now reset to default for the configured mode
     * ```
     */
    reset(e?: boolean): void;
    /**
     * Clear pattern completely
     * Removes all pattern data, summary, and validation errors
     * Sets component state to 'clear'
     *
     * @example
     * ```typescript
     * schedulerPicker.clear();
     * // All data cleared, component is now empty
     * ```
     */
    clear(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerComponent, "ax-scheduler-picker", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "value": { "alias": "value"; "required": false; }; "state": { "alias": "state"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "valueChange": "valueChange"; "stateChange": "stateChange"; "onValueChanged": "onValueChanged"; "onBlur": "onBlur"; "onFocus": "onFocus"; "summaryChange": "summaryChange"; }, never, never, true, never>;
}

/**
 * Service for scheduler picker utilities
 * Handles conversions, calculations, and validation
 */
declare class AXSchedulerPickerService {
    private translationService;
    /**
     * Calculate next N occurrences from pattern
     * Uses lazy-loaded rrule library for complex calculations
     */
    calculateOccurrences(pattern: AXSchedulerPickerValue, count: number, startFrom?: Date): Promise<Date[]>;
    /**
     * Convert pattern to cron expression
     * Uses lazy-loaded cron-parser library
     */
    toCronExpression(pattern: AXSchedulerPickerValue): Promise<string>;
    /**
     * Convert cron expression to pattern
     * Parses standard cron format: minute hour day month weekday
     */
    fromCronExpression(cron: string): Promise<AXSchedulerPickerValue | null>;
    /**
     * Analyze a cron field to extract interval and values
     */
    private analyzeCronField;
    /**
     * Convert pattern to RRule string (iCalendar format)
     */
    toRRule(pattern: AXSchedulerPickerValue): Promise<string>;
    /**
     * Convert RRule string to pattern
     */
    fromRRule(rruleStr: string): Promise<AXSchedulerPickerValue | null>;
    /**
     * Generate human-readable description
     * Uses lazy-loaded cronstrue library for i18n
     */
    toNaturalLanguage(pattern: AXSchedulerPickerValue, locale?: string): Promise<string>;
    /**
     * Validate pattern against config and rules
     */
    validatePattern(pattern: AXSchedulerPickerValue, settings: AXSchedulerPickerSettings): Promise<AXSchedulerPickerValidationError[]>;
    /**
     * Check if a specific date matches the pattern
     */
    isDateMatch(pattern: AXSchedulerPickerValue, date: Date): Promise<boolean>;
    /**
     * Get next occurrence from a specific date
     */
    getNextOccurrence(pattern: AXSchedulerPickerValue, from: Date): Promise<Date | null>;
    /**
     * Convert pattern to RRule object
     * Helper method for RRule operations
     */
    private toRRuleObject;
    /**
     * Get day name constant for RRule
     */
    private getDayName;
    /**
     * Get localized day names
     */
    private getDayNames;
    /**
     * Get localized month names
     */
    private getMonthNames;
    /**
     * Get text for occurrence position
     */
    private getOccurrencePositionText;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXSchedulerPickerService>;
}

/**
 * Hourly mode default configuration
 */
declare const AXSchedulerPickerHourlyDefaultConfig: AXSchedulerPickerHourlyConfig;
/**
 * Daily mode default configuration
 */
declare const AXSchedulerPickerDailyDefaultConfig: AXSchedulerPickerDailyConfig;
/**
 * Weekly mode default configuration
 */
declare const AXSchedulerPickerWeeklyDefaultConfig: AXSchedulerPickerWeeklyConfig;
/**
 * Monthly mode default configuration
 */
declare const AXSchedulerPickerMonthlyDefaultConfig: AXSchedulerPickerMonthlyConfig;
/**
 * Yearly mode default configuration
 */
declare const AXSchedulerPickerYearlyDefaultConfig: AXSchedulerPickerYearlyConfig;
/**
 * Injection tokens for each mode configuration
 */
declare const AX_SCHEDULER_PICKER_HOURLY_CONFIG: InjectionToken<AXSchedulerPickerHourlyConfig>;
declare const AX_SCHEDULER_PICKER_DAILY_CONFIG: InjectionToken<AXSchedulerPickerDailyConfig>;
declare const AX_SCHEDULER_PICKER_WEEKLY_CONFIG: InjectionToken<AXSchedulerPickerWeeklyConfig>;
declare const AX_SCHEDULER_PICKER_MONTHLY_CONFIG: InjectionToken<AXSchedulerPickerMonthlyConfig>;
declare const AX_SCHEDULER_PICKER_YEARLY_CONFIG: InjectionToken<AXSchedulerPickerYearlyConfig>;
/**
 * Helper function to get default config by mode
 */
declare function getDefaultSchedulerPickerConfig<T extends 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly'>(mode: T): T extends 'hourly' ? AXSchedulerPickerHourlyConfig : T extends 'daily' ? AXSchedulerPickerDailyConfig : T extends 'weekly' ? AXSchedulerPickerWeeklyConfig : T extends 'monthly' ? AXSchedulerPickerMonthlyConfig : AXSchedulerPickerYearlyConfig;

/**
 * Constants for scheduler picker module
 */
/**
 * Day of week interface
 */
interface AXSchedulerPickerDayOfWeek {
    id: number;
    text: string;
    key: string;
    rruleKey: string;
}
/**
 * Month interface
 */
interface AXSchedulerPickerMonth {
    id: number;
    text: string;
    key: string;
}
/**
 * Occurrence position interface
 */
interface AXSchedulerPickerOccurrencePosition {
    value: 1 | 2 | 3 | 4 | -1;
    text: string;
    key: string;
}
/**
 * Days of the week (0-6: Sunday-Saturday)
 */
declare const AX_SCHEDULER_PICKER_DAYS_OF_WEEK: Readonly<AXSchedulerPickerDayOfWeek[]>;
/**
 * Months of the year (0-11: January-December)
 */
declare const AX_SCHEDULER_PICKER_MONTHS: Readonly<AXSchedulerPickerMonth[]>;
/**
 * Occurrence positions (1st, 2nd, 3rd, 4th, Last)
 */
declare const AX_SCHEDULER_PICKER_OCCURRENCE_POSITIONS: Readonly<AXSchedulerPickerOccurrencePosition[]>;
/**
 * RRule day keys mapping (for RRule library)
 */
declare const AX_SCHEDULER_PICKER_RRULE_DAY_KEYS: Readonly<string[]>;
/**
 * Translation keys for days of week
 */
declare const AX_SCHEDULER_PICKER_DAY_TRANSLATION_KEYS: Readonly<string[]>;
/**
 * Translation keys for months
 */
declare const AX_SCHEDULER_PICKER_MONTH_TRANSLATION_KEYS: Readonly<string[]>;
/**
 * Default first day of week (0 = Sunday)
 */
declare const AX_SCHEDULER_PICKER_DEFAULT_FIRST_DAY_OF_WEEK = 0;
/**
 * Default time format
 */
declare const AX_SCHEDULER_PICKER_DEFAULT_TIME_FORMAT: "24h";
/**
 * Default time precision
 */
declare const AX_SCHEDULER_PICKER_DEFAULT_TIME_PRECISION: "minutes";
/**
 * Default locale
 */
declare const AX_SCHEDULER_PICKER_DEFAULT_LOCALE = "en-US";
/**
 * Weekday range for daily mode (Monday-Friday)
 */
declare const AX_SCHEDULER_PICKER_WEEKDAY_START = 1;
declare const AX_SCHEDULER_PICKER_WEEKDAY_END = 5;
/**
 * Default occurrences count for end condition
 */
declare const AX_SCHEDULER_PICKER_DEFAULT_OCCURRENCES = 10;

/**
 * Helper function to reorder days based on first day of week
 */
declare function reorderDaysByFirstDay(firstDayOfWeek?: number): AXSchedulerPickerDayOfWeek[];
/**
 * Get RRule day key by day index
 */
declare function getRRuleDayKey(dayIndex: number): string;
/**
 * Get day translation key by index
 */
declare function getDayTranslationKey(dayIndex: number): string;
/**
 * Get month translation key by index
 */
declare function getMonthTranslationKey(monthIndex: number): string;
/**
 * Normalize date to midnight for consistent comparison
 */
declare function normalizeDate(date: Date): Date;
/**
 * Check if two dates are the same day (ignoring time)
 */
declare function isSameDate(date1: Date, date2: Date): boolean;
/**
 * Check if date exists in array (day comparison only)
 */
declare function dateExistsInArray(date: Date, dates: Date[]): boolean;

interface AXSchedulerPickerEndCondition {
    type: 'never' | 'afterOccurrences' | 'byDate';
    occurrences?: number;
    endDate?: Date;
}
declare class AXSchedulerPickerEndConditionSelectorComponent {
    endCondition: _angular_core.InputSignal<AXSchedulerPickerEndCondition>;
    config: _angular_core.InputSignal<AXSchedulerPickerSettings>;
    endConditionChange: _angular_core.OutputEmitterRef<AXSchedulerPickerEndCondition>;
    protected selectedType: _angular_core.WritableSignal<"byDate" | "never" | "afterOccurrences">;
    protected occurrences: _angular_core.WritableSignal<number>;
    protected endDate: _angular_core.WritableSignal<Date>;
    protected readonly endTypeItems: {
        id: string;
        text: string;
    }[];
    constructor();
    protected onTypeChange(event: AXValueChangedEvent<'never' | 'afterOccurrences' | 'byDate'>): void;
    protected onOccurrencesChange(value: number): void;
    protected onDateChange(value: Date): void;
    private emitChange;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerEndConditionSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerEndConditionSelectorComponent, "ax-scheduler-picker-end-condition-selector", never, { "endCondition": { "alias": "endCondition"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "endConditionChange": "endConditionChange"; }, never, never, true, never>;
}

interface AXSchedulerPickerStartCondition {
    type: 'now' | 'byDate';
    startDate: Date;
}
declare class AXSchedulerPickerStartConditionSelectorComponent {
    startCondition: _angular_core.InputSignal<AXSchedulerPickerStartCondition>;
    config: _angular_core.InputSignal<AXSchedulerPickerSettings>;
    startConditionChange: _angular_core.OutputEmitterRef<AXSchedulerPickerStartCondition>;
    protected selectedType: _angular_core.WritableSignal<"now" | "byDate">;
    protected startDate: _angular_core.WritableSignal<Date>;
    protected readonly startTypeItems: {
        id: string;
        text: string;
    }[];
    constructor();
    protected onTypeChange(event: AXValueChangedEvent<'now' | 'byDate'>): void;
    protected onDateChange(value: Date): void;
    private emitChange;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerStartConditionSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerStartConditionSelectorComponent, "ax-scheduler-picker-start-condition-selector", never, { "startCondition": { "alias": "startCondition"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "startConditionChange": "startConditionChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerDailyPanelComponent {
    pattern: _angular_core.InputSignal<AXSchedulerPickerValue>;
    config: _angular_core.InputSignal<AXSchedulerPickerDailyConfig>;
    patternChange: _angular_core.OutputEmitterRef<Partial<AXSchedulerPickerValue>>;
    protected weekdayOnly: _angular_core.WritableSignal<boolean>;
    constructor();
    protected onIntervalChange(interval: number): void;
    protected onWeekdayOnlyChange(value: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerDailyPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerDailyPanelComponent, "ax-scheduler-picker-daily-panel", never, { "pattern": { "alias": "pattern"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "patternChange": "patternChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerHourlyPanelComponent {
    pattern: _angular_core.InputSignal<AXSchedulerPickerValue>;
    config: _angular_core.InputSignal<AXSchedulerPickerHourlyConfig>;
    patternChange: _angular_core.OutputEmitterRef<Partial<AXSchedulerPickerValue>>;
    protected onIntervalChange(interval: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerHourlyPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerHourlyPanelComponent, "ax-scheduler-picker-hourly-panel", never, { "pattern": { "alias": "pattern"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "patternChange": "patternChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerMonthlyPanelComponent {
    pattern: _angular_core.InputSignal<AXSchedulerPickerValue>;
    config: _angular_core.InputSignal<AXSchedulerPickerMonthlyConfig>;
    patternChange: _angular_core.OutputEmitterRef<Partial<AXSchedulerPickerValue>>;
    protected selectedDays: _angular_core.WritableSignal<number[]>;
    protected occurrence: _angular_core.WritableSignal<AXSchedulerPickerOccurrence>;
    constructor();
    protected onIntervalChange(interval: number): void;
    protected onDaysChange(days: number[]): void;
    protected onOccurrenceChange(occurrence: AXSchedulerPickerOccurrence): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerMonthlyPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerMonthlyPanelComponent, "ax-scheduler-picker-monthly-panel", never, { "pattern": { "alias": "pattern"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "patternChange": "patternChange"; }, never, never, true, never>;
}

/**
 * Weekly recurrence panel
 */
declare class AXSchedulerPickerWeeklyPanelComponent {
    pattern: _angular_core.InputSignal<AXSchedulerPickerValue>;
    config: _angular_core.InputSignal<AXSchedulerPickerWeeklyConfig>;
    patternChange: _angular_core.OutputEmitterRef<Partial<AXSchedulerPickerValue>>;
    protected selectedDays: _angular_core.WritableSignal<number[]>;
    protected dayItems: _angular_core.Signal<{
        text: string;
        id: number;
        key: string;
        rruleKey: string;
    }[]>;
    constructor();
    protected onIntervalChange(interval: number): void;
    protected onDaysChange(event: AXValueChangedEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerWeeklyPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerWeeklyPanelComponent, "ax-scheduler-picker-weekly-panel", never, { "pattern": { "alias": "pattern"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "patternChange": "patternChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerYearlyPanelComponent {
    pattern: _angular_core.InputSignal<AXSchedulerPickerValue>;
    config: _angular_core.InputSignal<AXSchedulerPickerYearlyConfig>;
    patternChange: _angular_core.OutputEmitterRef<Partial<AXSchedulerPickerValue>>;
    protected selectedMonths: _angular_core.WritableSignal<number[]>;
    protected selectedDays: _angular_core.WritableSignal<number[]>;
    protected occurrence: _angular_core.WritableSignal<AXSchedulerPickerOccurrence>;
    constructor();
    protected onIntervalChange(interval: number): void;
    protected onMonthsChange(months: number[]): void;
    protected onDaysChange(days: number[]): void;
    protected onOccurrenceChange(occurrence: AXSchedulerPickerOccurrence): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerYearlyPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerYearlyPanelComponent, "ax-scheduler-picker-yearly-panel", never, { "pattern": { "alias": "pattern"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "patternChange": "patternChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerDaySelectorComponent {
    /**
     * Selected day numbers (1-31)
     */
    days: _angular_core.InputSignal<number[]>;
    /**
     * Emits when day selection changes
     */
    daysChange: _angular_core.OutputEmitterRef<number[]>;
    protected dayItems: {
        id: number;
        text: string;
    }[];
    /**
     * Handle day selection change
     */
    protected onDaysChange(event: AXValueChangedEvent<number | number[]>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerDaySelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerDaySelectorComponent, "ax-scheduler-picker-day-selector", never, { "days": { "alias": "days"; "required": false; "isSignal": true; }; }, { "daysChange": "daysChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerExclusionManagerComponent {
    exclusions: _angular_core.InputSignal<Date[]>;
    config: _angular_core.InputSignal<AXSchedulerPickerSettings>;
    exclusionsChange: _angular_core.OutputEmitterRef<Date[]>;
    protected newExclusionDate: _angular_core.WritableSignal<Date>;
    protected exclusionList: _angular_core.WritableSignal<Date[]>;
    constructor();
    protected addExclusion(): void;
    protected removeExclusion(date: Date): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerExclusionManagerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerExclusionManagerComponent, "ax-scheduler-picker-exclusion-manager", never, { "exclusions": { "alias": "exclusions"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "exclusionsChange": "exclusionsChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerInclusionManagerComponent {
    inclusions: _angular_core.InputSignal<Date[]>;
    inclusionsChange: _angular_core.OutputEmitterRef<Date[]>;
    protected newInclusionDate: _angular_core.WritableSignal<Date>;
    protected inclusionList: _angular_core.WritableSignal<Date[]>;
    constructor();
    protected addInclusion(): void;
    protected removeInclusion(date: Date): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerInclusionManagerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerInclusionManagerComponent, "ax-scheduler-picker-inclusion-manager", never, { "inclusions": { "alias": "inclusions"; "required": false; "isSignal": true; }; }, { "inclusionsChange": "inclusionsChange"; }, never, never, true, never>;
}

/**
 * Interval selector component
 * Allows user to select "Every X [units]"
 */
declare class AXSchedulerPickerIntervalSelectorComponent {
    /**
     * Current interval value
     */
    interval: _angular_core.InputSignal<number>;
    /**
     * Configuration
     */
    config: _angular_core.InputSignal<AXSchedulerPickerSettings>;
    /**
     * Emits when interval changes
     */
    intervalChange: _angular_core.OutputEmitterRef<number>;
    /**
     * Handle interval value change
     */
    protected onIntervalChange(value: number): void;
    /**
     * Get unit translation key based on mode
     */
    protected getUnitKey(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerIntervalSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerIntervalSelectorComponent, "ax-scheduler-picker-interval-selector", never, { "interval": { "alias": "interval"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "intervalChange": "intervalChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerMonthSelectorComponent {
    /**
     * Selected month indices (0-11)
     */
    months: _angular_core.InputSignal<number[]>;
    /**
     * Emits when month selection changes
     */
    monthsChange: _angular_core.OutputEmitterRef<number[]>;
    protected readonly monthItems: {
        text: string;
        id: number;
        key: string;
    }[];
    /**
     * Handle month selection change
     */
    protected onMonthsChange(event: AXValueChangedEvent<number | number[]>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerMonthSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerMonthSelectorComponent, "ax-scheduler-picker-month-selector", never, { "months": { "alias": "months"; "required": false; "isSignal": true; }; }, { "monthsChange": "monthsChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerOccurrenceSelectorComponent {
    /**
     * Current occurrence selection (position + day)
     */
    occurrence: _angular_core.InputSignal<AXSchedulerPickerOccurrence>;
    /**
     * Emits when occurrence selection changes
     */
    occurrenceChange: _angular_core.OutputEmitterRef<AXSchedulerPickerOccurrence>;
    protected selectedPosition: _angular_core.WritableSignal<1 | 2 | 3 | 4 | -1>;
    protected selectedDay: _angular_core.WritableSignal<number>;
    protected readonly positions: {
        text: string;
        value: 1 | 2 | 3 | 4 | -1;
        key: string;
    }[];
    protected readonly days: {
        value: number;
        text: string;
    }[];
    constructor();
    /**
     * Handle position selection change
     */
    protected onPositionChangeEvent(event: AXValueChangedEvent<1 | 2 | 3 | 4 | -1>): void;
    /**
     * Handle day selection change
     */
    protected onDayChangeEvent(event: AXValueChangedEvent<number>): void;
    private emitChange;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerOccurrenceSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerOccurrenceSelectorComponent, "ax-scheduler-picker-occurrence-selector", never, { "occurrence": { "alias": "occurrence"; "required": false; "isSignal": true; }; }, { "occurrenceChange": "occurrenceChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerTimeSelectorComponent {
    time: _angular_core.InputSignal<string>;
    timeChange: _angular_core.OutputEmitterRef<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerTimeSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerTimeSelectorComponent, "ax-scheduler-picker-time-selector", never, { "time": { "alias": "time"; "required": false; "isSignal": true; }; }, { "timeChange": "timeChange"; }, never, never, true, never>;
}

declare class AXSchedulerPickerTimezoneSelectorComponent {
    /**
     * Current timezone value
     */
    timezone: _angular_core.InputSignal<string>;
    /**
     * Emits when timezone selection changes
     */
    timezoneChange: _angular_core.OutputEmitterRef<string>;
    /**
     * Handle timezone selection change
     */
    protected onTimezoneChange(event: AXValueChangedEvent<string>): void;
    protected timezones: {
        value: string;
        text: string;
    }[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerTimezoneSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerTimezoneSelectorComponent, "ax-scheduler-picker-timezone-selector", never, { "timezone": { "alias": "timezone"; "required": false; "isSignal": true; }; }, { "timezoneChange": "timezoneChange"; }, never, never, true, never>;
}

/**
 * Demo configuration panel for scheduler picker
 * Provides interactive controls to customize scheduler picker settings
 */
declare class AXSchedulerPickerConfigComponent {
    configChange: _angular_core.OutputEmitterRef<AXSchedulerPickerSettings>;
    modeChange: _angular_core.OutputEmitterRef<AXSchedulerPickerMode>;
    selectedMode: _angular_core.WritableSignal<AXSchedulerPickerMode>;
    modeOptions: {
        value: string;
        text: string;
    }[];
    showInterval: _angular_core.WritableSignal<boolean>;
    showStartCondition: _angular_core.WritableSignal<boolean>;
    showEndConditions: _angular_core.WritableSignal<boolean>;
    showExclusions: _angular_core.WritableSignal<boolean>;
    showInclusions: _angular_core.WritableSignal<boolean>;
    showWeekdaysOnly: _angular_core.WritableSignal<boolean>;
    showWeekdaySelection: _angular_core.WritableSignal<boolean>;
    monthlyRecurrenceMode: _angular_core.WritableSignal<"none" | "specificDays" | "occurrence">;
    yearlyRecurrenceMode: _angular_core.WritableSignal<"none" | "occurrence" | "specificDate">;
    showMonthSelection: _angular_core.WritableSignal<boolean>;
    config: _angular_core.Signal<AXSchedulerPickerSettings>;
    constructor();
    protected onModeChange(mode: AXSchedulerPickerMode): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSchedulerPickerConfigComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXSchedulerPickerConfigComponent, "ax-scheduler-picker-config", never, {}, { "configChange": "configChange"; "modeChange": "modeChange"; }, never, never, true, never>;
}

export { AXSchedulerPickerComponent, AXSchedulerPickerConfigComponent, AXSchedulerPickerDailyDefaultConfig, AXSchedulerPickerDailyPanelComponent, AXSchedulerPickerDaySelectorComponent, AXSchedulerPickerEndConditionSelectorComponent, AXSchedulerPickerExclusionManagerComponent, AXSchedulerPickerHourlyDefaultConfig, AXSchedulerPickerHourlyPanelComponent, AXSchedulerPickerInclusionManagerComponent, AXSchedulerPickerIntervalSelectorComponent, AXSchedulerPickerMonthSelectorComponent, AXSchedulerPickerMonthlyDefaultConfig, AXSchedulerPickerMonthlyPanelComponent, AXSchedulerPickerOccurrenceSelectorComponent, AXSchedulerPickerService, AXSchedulerPickerStartConditionSelectorComponent, AXSchedulerPickerTimeSelectorComponent, AXSchedulerPickerTimezoneSelectorComponent, AXSchedulerPickerWeeklyDefaultConfig, AXSchedulerPickerWeeklyPanelComponent, AXSchedulerPickerYearlyDefaultConfig, AXSchedulerPickerYearlyPanelComponent, AX_SCHEDULER_PICKER_DAILY_CONFIG, AX_SCHEDULER_PICKER_DAYS_OF_WEEK, AX_SCHEDULER_PICKER_DAY_TRANSLATION_KEYS, AX_SCHEDULER_PICKER_DEFAULT_FIRST_DAY_OF_WEEK, AX_SCHEDULER_PICKER_DEFAULT_LOCALE, AX_SCHEDULER_PICKER_DEFAULT_OCCURRENCES, AX_SCHEDULER_PICKER_DEFAULT_TIME_FORMAT, AX_SCHEDULER_PICKER_DEFAULT_TIME_PRECISION, AX_SCHEDULER_PICKER_HOURLY_CONFIG, AX_SCHEDULER_PICKER_MONTHLY_CONFIG, AX_SCHEDULER_PICKER_MONTHS, AX_SCHEDULER_PICKER_MONTH_TRANSLATION_KEYS, AX_SCHEDULER_PICKER_OCCURRENCE_POSITIONS, AX_SCHEDULER_PICKER_RRULE_DAY_KEYS, AX_SCHEDULER_PICKER_WEEKDAY_END, AX_SCHEDULER_PICKER_WEEKDAY_START, AX_SCHEDULER_PICKER_WEEKLY_CONFIG, AX_SCHEDULER_PICKER_YEARLY_CONFIG, dateExistsInArray, getDayTranslationKey, getDefaultSchedulerPickerConfig, getMonthTranslationKey, getRRuleDayKey, isSameDate, normalizeDate, reorderDaysByFirstDay };
export type { AXSchedulerPickerConfig, AXSchedulerPickerCustomValidator, AXSchedulerPickerDailyConfig, AXSchedulerPickerDailyOptions, AXSchedulerPickerDayOfWeek, AXSchedulerPickerEndCondition, AXSchedulerPickerHourlyConfig, AXSchedulerPickerHourlyOptions, AXSchedulerPickerMode, AXSchedulerPickerMonth, AXSchedulerPickerMonthlyConfig, AXSchedulerPickerMonthlyOptions, AXSchedulerPickerMonthlyRecurrenceMode, AXSchedulerPickerOccurrence, AXSchedulerPickerOccurrencePosition, AXSchedulerPickerOptions, AXSchedulerPickerSettings, AXSchedulerPickerStartCondition, AXSchedulerPickerValidationError, AXSchedulerPickerValidationErrorCode, AXSchedulerPickerValue, AXSchedulerPickerWeeklyConfig, AXSchedulerPickerWeeklyOptions, AXSchedulerPickerYearlyConfig, AXSchedulerPickerYearlyOptions, AXSchedulerPickerYearlyRecurrenceMode };
