@acorex/components 21.0.0-next.3 → 21.0.0-next.31

package/scheduler-picker/index.d.ts

@@ -0,0 +1,1360 @@
+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 };