import { CalendarDate } from '../../../../../../helpers/calendar';
import { Nullable } from '../../../../../../types/general';
import { CalendarEventBaseRepeatPattern } from './base-repeat-pattern';
/** The `CalendarEventYearlyRepeatPattern` class defines a yearly repeat pattern for calendar events, checking for matches and generating future dates based on specified criteria. */
export declare class CalendarEventYearlyRepeatPattern extends CalendarEventBaseRepeatPattern {
  private matchMonth;
  private matchDay;
  /**
   * The constructor initializes a new instance with specified start and end dates, interval, count, and until date.
   *
   * @param {CalendarDate} startDate - The `startDate` parameter is of type `CalendarDate` and
   * represents the starting date of a calendar event or interval.
   * @param {number} interval - The `interval` parameter represents the frequency at which the event
   * occurs. For example, if the interval is set to 2, the event will occur every 2 units of time (days,
   * weeks, months, etc.).
   * @param {Nullable<number>} count - The `count` parameter specifies the number of occurrences of the event. If `count`
   * is provided, the event will repeat `count` times within the specified interval. If `count` is not
   * provided, the event will repeat indefinitely based on the other parameters like `endDate` or
   * `until`.
   * @param {Nullable<CalendarDate>} until - The `until` parameter in the constructor is of type `Nullable<CalendarDate>`. This
   * means that it can either accept a `CalendarDate` object or be `null`. It is used to specify a date
   * until which the recurring event should repeat. If `until` is provided, the event
   */
  constructor(startDate: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>);
  /**
   * Generate repeat display string.
   *
   * @returns {string} repeat display string
   */
  generateRepeatString(): string;
  /**
   * The function generates repeat dates and caches them until reaching the specified end date.
   *
   * @param {CalendarDate} endDate - The `endDate` parameter in the
   * `generateRepeatDateCacheUntilEndDate` function is a CalendarDate object that represents the date
   * until which the repeat date cache should be generated. The function checks if the last date in the
   * cache is before the `endDate`, and if so, it generates additional repeat dates
   */
  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
  /**
   * The function getNextRepeatStartDate calculates the next repeat start date based on a given date and certain conditions.
   *
   * @param {CalendarDate} date - The `date` parameter represents the current date for which you want to
   * calculate the next repeat start date. It is of type `CalendarDate`, which seems to be a custom
   * class or structure that holds year, month, and day information.
   * @returns {Nullable<CalendarDate>} The function `getNextRepeatStartDate` returns either a `CalendarDate` object or `null`
   * based on certain conditions. If the next date exceeds the `until` date or the count limit has been
   * reached, it returns `null`. Otherwise, it adds the next date to the cache and returns it as a
   * `CalendarDate`.
   */
  private getNextRepeatStartDate;
  /**
   * get the new date with fixed month and fixed date, if the date.getDate() not equal the fixed date or fixed month, find the next year
   *
   * @param {number} year year
   * @returns {Date} the new date
   */
  private getNextStartDate;
  /**
   * The function `initCache` initializes a cache array with the `startDate` value.
   */
  private initCache;
}
