@globalpayments/vega 2.19.0 → 2.20.0

package/dist/types/components/vega-calendar/slimmers/common/helpers/calendarEventSorter.d.ts

@@ -1,38 +0,0 @@
-import { CalendarEvent } from '../../../../../helpers/calendar/calendar-event';
-import { Nullable } from '../../../../../types/general';
-import { VegaCalendarFullDayEventLayout } from '../layout/fullDayEventLayout';
-/** The VegaCalendarEventSorter class in TypeScript provides a sort method to sort an array of CalendarEvent objects. */
-export declare class VegaCalendarEventSorter {
-  /**
-   * The function "sort" takes an array of CalendarEvent objects and returns the same array without performing any sorting.
-   *
-   * @param {CalendarEvent[]} events - CalendarEvent[] - an array of CalendarEvent objects that need to be sorted.
-   * @param {number} currentViewIndex - The current index of the row
-   * @param {VegaCalendarFullDayEventLayout} fullDayEventLayout - The current row all long event layout
-   * @returns {Nullable<CalendarEvent>} The `sort` function is currently returning the input array of `CalendarEvent` objects as is, without performing any sorting operation.
-   */
-  sort(events: CalendarEvent[], currentViewIndex: number, fullDayEventLayout: VegaCalendarFullDayEventLayout): Nullable<CalendarEvent>[];
-  /**
-   * The function `sortCalendarEventByTime` sorts an array of `CalendarEvent` objects based on their start and end times.
-   *
-   * @param {CalendarEvent[]} events - An array of CalendarEvent objects. Each CalendarEvent object contains information about a specific event, such as startTime and endTime.
-   * @returns {CalendarEvent[]} The `sortCalendarEventByTime` function is returning an array of `CalendarEvent` objects sorted by their start time and end time. The events are sorted in ascending order based on their start time, and if two events have the same start time, they are further sorted in descending order based on their end time.
-   */
-  sortCalendarEventByTime(events: CalendarEvent[]): CalendarEvent[];
-  /**
-   * The function inserts events from a given array into empty positions in another array of events.
-   *
-   * @param {Nullable<CalendarEvent>[]} viewEvents - `viewEvents` is an array of nullable
-   * `CalendarEvent` objects representing the events currently displayed in the calendar view. Each
-   * element in the array can either be a `CalendarEvent` object or `null`.
-   * @param {CalendarEvent[]} events - The `events` parameter in the `insertEventsToEmptyPosition`
-   * function represents an array of `CalendarEvent` objects that need to be inserted into the
-   * `viewEvents` array at empty positions. The function iterates over the `viewEvents` array and
-   * inserts events from the `events` array
-   * @returns {CalendarEvent|null[]} The `insertEventsToEmptyPosition` function returns an array of `Nullable<CalendarEvent>`
-   * where events from the `events` array are inserted into empty positions in the `viewEvents` array.
-   * If there are no empty positions in `viewEvents`, the function returns the original `viewEvents`
-   * array.
-   */
-  private insertEventsToEmptyPosition;
-}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventDailyRepeatPattern.d.ts

@@ -1,43 +0,0 @@
-import { CalendarDate } from '../../../../../../helpers/calendar';
-import { Nullable } from '../../../../../../types/general';
-import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
-/** The `CalendarEventDailyRepeatPattern` class in TypeScript represents a daily repeating pattern for calendar events. */
-export declare class CalendarEventDailyRepeatPattern extends CalendarEventBaseRepeatPattern {
-  /**
-   * The constructor initializes the current date for a given date range and interval.
-   *
-   * @param {CalendarDate} startDate - The `startDate` parameter is of type `CalendarDate` and represents the starting date for a specific interval or range.
-   * @param {number} interval - The `interval` parameter represents the frequency at which the event
-   * occurs. For example, if the interval is set to 1, it means the event occurs every day. If the
-   * interval is set to 2, it means the event occurs every other day.
-   * @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
-   * `null`, the event will repeat indefinitely until the `until` date is reached.
-   * @param {Nullable<CalendarDate>} until - The `until` parameter in the constructor is of type `Nullable<CalendarDate>`, which
-   * means it can either accept a `CalendarDate` object or be `null`. This parameter 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>);
-  /**
-   * The function generates and caches repeated dates before a specified end date.
-   *
-   * @param {CalendarDate} endDate - The `endDate` parameter represents the date until which you want to
-   * generate repeat dates in the cache. The function `generateRepeatDateCacheBeforeEndDate` is
-   * responsible for populating the cache with repeat dates until the specified `endDate`. It checks the
-   * last date in the cache and generates subsequent repeat dates until
-   */
-  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
-  /**
-   * The function `initCache` initializes a cache array with the `startDate` value.
-   */
-  private initCache;
-  /**
-   * 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 an instance of the `CalendarDate` class.
-   * @returns {Nullable<CalendarDate>} The function `getNextRepeatStartDate` returns either a `CalendarDate` object if certain
-   * conditions are met, or `null` if the conditions are not met.
-   */
-  private getNextRepeatStartDate;
-}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventMonthlyRepeatPattern.d.ts

@@ -1,55 +0,0 @@
-import { CalendarDate } from '../../../../../../helpers/calendar';
-import { Nullable } from '../../../../../../types/general';
-import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
-/** The `CalendarEventMonthlyRepeatPattern` class in TypeScript represents a monthly repeat pattern for calendar events. */
-export declare class CalendarEventMonthlyRepeatPattern extends CalendarEventBaseRepeatPattern {
-  private byMonthDay;
-  /**
-   * The constructor initializes the event with specified start and end dates, interval, count, and until date, and sets the byMonthDay property to the start date's day.
-   *
-   * @param {CalendarDate} startDate - The `startDate` parameter represents the starting date of the
-   * event or interval. It is of type `CalendarDate`, which likely includes the year, month, and day
-   * components of the date.
-   * @param {number} interval - The `interval` parameter specifies the frequency of the recurring
-   * events. 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 (or is `null`), the event will repeat indefinitely based on the other parameters like `
-   * @param {Nullable<CalendarDate>} until - The `until` parameter is a nullable `CalendarDate` that specifies the end date for
-   * the recurring event. If provided, the event will repeat until this date. If not provided, the event
-   * will repeat indefinitely based on the other parameters like `count` or `endDate`.
-   */
-  constructor(startDate: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>);
-  /**
-   * This function generates and caches repeated dates before a specified end date.
-   *
-   * @param {CalendarDate} endDate - The `endDate` parameter in the
-   * `generateRepeatDateCacheUntilEndDate` function is a CalendarDate object that represents the end
-   * date until which the repeat dates need to be generated and cached. The function checks if the last
-   * cached date is before the `endDate` and generates additional repeat dates until it reaches
-   */
-  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
-  /**
-   * The function `initCache` initializes a cache array with the startDate value.
-   */
-  private initCache;
-  /**
-   * The getNextRepeatStartDate function calculates the next start date based on a given date and interval, considering constraints such as end date and count limit.
-   *
-   * @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`.
-   * @returns {Nullable<CalendarDate>} The function `getNextRepeatStartDate` returns a nullable `CalendarDate`. It either returns
-   * the next calculated `CalendarDate` based on the input date and interval, or it returns `null` if
-   * certain conditions are met (such as reaching the specified end date or count limit).
-   */
-  private getNextRepeatStartDate;
-  /**
-   * get the new date with fixed date, if the date.getDate() not equal the fixed date, find the next month
-   *
-   * @param {number} year year
-   * @param {number} month month
-   * @returns {Date} the new date
-   */
-  private getNextStartDate;
-}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventRepeatPatternFactory.d.ts

@@ -1,34 +0,0 @@
-import { VegaCalendarEventRepeatOptions } from '../../../../types';
-import { CalendarEventBaseRepeatPattern } from '../repeatPattern/baseRepeatPattern';
-/** This code snippet defines a TypeScript class `CalendarEventRepeatPatternFactory` that serves as a factory for creating different types of repeat patterns for calendar events. Here's a breakdown of what the class and its methods are doing: */
-declare class CalendarEventRepeatPatternFactory {
-  /**
-   * This `getPattern` method within the `CalendarEventRepeatPatternFactory` class is a public method that is responsible for creating and returning a specific type of repeat pattern for a calendar event based on the input parameters provided. Here's a breakdown of what this method is doing:
-   *
-   * @param {Date} startDate repeat start date
-   * @param {VegaCalendarEventRepeatOptions|undefined} repeatOptions repeat options
-   * @returns {CalendarEventBaseRepeatPattern} the match repeat pattern
-   */
-  getPattern(startDate: Date, repeatOptions: VegaCalendarEventRepeatOptions): CalendarEventBaseRepeatPattern;
-  /**
-   * The `initDate` function initializes a `CalendarDate` object based on the input date string or Date object provided.
-   *
-   * @param {Nullable<string | Date>} date - The `date` parameter can be either a string or a Date object.
-   * @returns {Nullable<CalendarDate>} The function `initDate` returns a `Nullable<CalendarDate>`, which means it can return either a `CalendarDate` object or `null`.
-   */
-  private initDate;
-  /**
-   * The function `initRepeatPattern` initializes a repeat pattern based on the frequency specified for a calendar event.
-   *
-   * @param {VegaCalendarEventRepeatType} frequency event frequency
-   * @param {CalendarDate} repeatStartDate event start date
-   * @param {number} interval event repeat interval
-   * @param {Nullable<number>} count the event repeat count
-   * @param {Nullable<CalendarDate>} repeatEndDate repeat end date
-   * @param {Nullable<VegaCalendarWeekDayType[]>} byWeekDay weekly week days
-   * @returns {CalendarEventBaseRepeatPattern} calendar event repeat pattern instance
-   */
-  private initRepeatPattern;
-}
-declare const _default: CalendarEventRepeatPatternFactory;
-export default _default;

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventWeeklyRepeatPattern.d.ts

@@ -1,99 +0,0 @@
-import { CalendarDate, CalendarPeriod } from '../../../../../../helpers/calendar';
-import { Nullable } from '../../../../../../types/general';
-import { VegaCalendarWeekDayType } from '../../../../types';
-import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
-/** The `CalendarEventWeeklyRepeatPattern` class in TypeScript represents a weekly repeat pattern for calendar events, allowing for matching dates based on specific weekdays and generating future dates with optional constraints. */
-export declare class CalendarEventWeeklyRepeatPattern extends CalendarEventBaseRepeatPattern {
-  private static weekDay;
-  private byWeekDay;
-  /**
-   * This TypeScript constructor initializes a calendar date range with specified parameters including start date, end date, interval, count, until date, and an array of week days.
-   *
-   * @param {CalendarDate} startDate - The `startDate` parameter represents the starting date of the
-   * calendar event or schedule. It is of type `CalendarDate`, which likely includes the year, month, and day components of a date.
-   * @param {number} interval - The `interval` parameter represents the frequency of the recurrence. For
-   * example, if `interval` is set to 1, the event will occur every week. If it's set to 2, the event
-   * will occur every two weeks.
-   * @param {Nullable<number>} count - The `count` parameter specifies the number of occurrences of the rule. If `count` is
-   * provided, the recurrence will generate at most that many occurrences. If `count` is not provided,
-   * the recurrence will continue indefinitely based on other parameters like `endDate` or `until`.
-   * @param {Nullable<CalendarDate>} until - The `until` parameter specifies the end date for the recurrence rule. If provided,
-   * the recurrence will continue until this date. If not provided, the recurrence will continue
-   * indefinitely based on other parameters like `count` or `interval`.
-   * @param {Nullable<VegaCalendarWeekDayType[]>} byWeekDay - The `byWeekDay` parameter is an array of
-   * `VegaCalendarWeekDayType` values, which represent the days of the week for which the event should occur.
-   */
-  constructor(startDate: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>, byWeekDay: Nullable<VegaCalendarWeekDayType[]>);
-  /**
-   * The function `getRepeatSeries` retrieves a series of repeated events within a specified calendar period.
-   *
-   * @param {CalendarPeriod} period - The `period` parameter in the `getRepeatSeries` method represents
-   * a specific time period in the form of a `CalendarPeriod` object. This object typically contains a
-   * `startDate` and an `endDate`, which define the range of dates for which you want to generate repeat series.
-   * @param {number} eventSpansDays - the current repeat series cross days, default value is one
-   * @returns {CalendarDate[]} repeat start date array
-   */
-  getRepeatSeries(period: CalendarPeriod, eventSpansDays?: number): CalendarDate[];
-  /**
-   * This function generates repeated dates and caches them until a specified end date.
-   *
-   * @param {CalendarDate} endDate - The `endDate` parameter is a `CalendarDate` object that represents
-   * the date until which the repeat date cache needs to be generated. The function
-   * `generateRepeatDateCacheUntilEndDate` generates repeat dates until this specified end date.
-   */
-  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
-  /**
-   * The function getNextRepeatStartDate calculates the next start dates based on a given array of CalendarDate objects and returns them if certain conditions are met.
-   *
-   * @param {CalendarDate[]} dates - The `dates` parameter is an array of `CalendarDate` objects.
-   * @returns {Nullable<CalendarDate[]>} The `getNextRepeatStartDate` function returns a nullable array of `CalendarDate` objects.
-   * If there are no next dates available or if the cache count exceeds a specified limit, it returns
-   * `null`. Otherwise, it returns an array of `CalendarDate` objects representing the next start dates.
-   */
-  private getNextRepeatStartDate;
-  /**
-   * The function `getNextStartDates` takes an array of `CalendarDate` objects, calculates the next dates based on a specified interval, and filters out dates that are after a specified end date.
-   *
-   * @param {CalendarDate[]} dates - The `dates` parameter is an array of `CalendarDate` objects
-   * representing specific dates in a calendar. Each `CalendarDate` object has properties for the year,
-   * month, and date.
-   * @returns {Date[]} The `getNextStartDates` function returns an array of `Date` objects representing the next
-   * start dates based on the input `CalendarDate` array. The function calculates the next start dates
-   * by adding a specific interval (multiplied by 7 to represent weeks) to each date in the input array.
-   * Finally, it filters out any dates that are after a specified `until` date, if provided.
-   */
-  private getNextStartDates;
-  /**
-   * The `initCache` function initializes a cache of calendar dates based on the start date and weekly repeat pattern.
-   */
-  private initCache;
-  /**
-   * The function `sortWeekDay` sorts an array of week days based on their position in a predefined list.
-   *
-   * @param {boolean} weekDay - The `weekDay` parameter is an array of week day values that need to be sorted in a
-   * specific order. The function `sortWeekDay` takes this array and sorts it based on a predefined
-   * order specified in `CalendarEventWeeklyRepeatPattern.weekDay`.
-   * @returns {VegaCalendarWeekDayType[]} The `sortWeekDay` function is returning the `weekDay` array sorted based on the index of
-   * each `VegaCalendarWeekDayType` item in the `CalendarEventWeeklyRepeatPattern.weekDay` array.
-   */
-  private sortWeekDay;
-  /**
-   * This function returns the index of the current day in a week, with Sunday represented as 0.
-   *
-   * @param {CalendarDate} date - The `date` parameter in the `getCurrentDayIndex` function is of type
-   * `CalendarDate`, which is a custom data type representing a date in a calendar.
-   * @returns {number} The function `getCurrentDayIndex` returns the index of the current day in the week, with
-   * Sunday being represented as 0 and Saturday being represented as 6.
-   */
-  private getCurrentDayIndex;
-  /**
-   * The function `getValidCache` returns a filtered and concatenated array of CalendarDate objects from the cache based on a start date.
-   *
-   * @returns {CalendarDate[]} The `getValidCache` method returns an array of `CalendarDate` objects that meet the
-   * condition of having a date greater than or equal to the `startDate` property. The method first
-   * flattens a nested array of `CalendarDate` objects stored in the `cache` property, then filters out
-   * the `CalendarDate` objects that do not meet the condition, and finally concatenates the filtered
-   * array
-   */
-  private getValidCache;
-}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventYearlyRepeatPattern.d.ts

@@ -1,57 +0,0 @@
-import { CalendarDate } from '../../../../../../helpers/calendar';
-import { Nullable } from '../../../../../../types/general';
-import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
-/** 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>);
-  /**
-   * 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;
-}

package/dist/types/components/vega-calendar/slimmers/common/layout/baseEventLayout.d.ts

@@ -1,11 +0,0 @@
-import { VegaCalendarBaseEventLayoutCell } from './baseEventLayoutCell';
-/** This TypeScript code snippet defines an abstract class `VegaCalendarBaseEventLayout` that serves as a base for event layout functionality in a calendar application. */
-export declare abstract class VegaCalendarBaseEventLayout {
-  protected abstract cells: VegaCalendarBaseEventLayoutCell[];
-  /**
-   * The function returns an array of VegaCalendarBaseEventLayoutCell objects.
-   *
-   * @returns {VegaCalendarBaseEventLayoutCell[]} An array of VegaCalendarLongEventLayoutRow objects is being returned.
-   */
-  get eventLayoutCells(): VegaCalendarBaseEventLayoutCell[];
-}

package/dist/types/components/vega-calendar/slimmers/common/layout/baseEventLayoutGenerator.d.ts

@@ -1,16 +0,0 @@
-import { CalendarEvent } from '../../../../../helpers/calendar/calendar-event';
-import { VegaCalendarBaseEventLayout } from './baseEventLayout';
-import { VegaCalendarBaseEventLayoutCell } from './baseEventLayoutCell';
-/** This code snippet is defining an abstract class named `VegaCalendarBaseEventLayoutGenerator` in TypeScript. The class contains an abstract method `generate` that must be implemented by any class that extends `VegaCalendarBaseEventLayoutGenerator`. */
-export declare abstract class VegaCalendarBaseEventLayoutGenerator {
-  /**
-   * The function `addCurrentEventToLayout` adds a long event view to a layout row without overlapping with existing events.
-   *
-   * @param {VegaCalendarBaseEventLayoutCell[]} layoutCells - The `layoutCells` parameter is an array of
-   * `VegaCalendarBaseEventLayoutCell` objects. These objects represent rows in a layout where long events are displayed without overlapping each other.
-   * @param {unknown} input - The `currentView` parameter represents the current long event view that you want to add to the layout rows without overlapping with existing events. The function `addCurrentEventToLayoutRow` searches for a layout row that does not have any overlap with the current view. If such a row is found,
-   */
-  protected addCurrentEventToLayout(layoutCells: VegaCalendarBaseEventLayoutCell[], input: unknown): void;
-  abstract generate(calendarEvents: CalendarEvent[][] | CalendarEvent[]): VegaCalendarBaseEventLayout;
-  protected abstract createNewLayoutCell(): VegaCalendarBaseEventLayoutCell;
-}

package/dist/types/components/vega-calendar/slimmers/common/layout/fullDayEventLayout.d.ts

@@ -1,30 +0,0 @@
-import { CalendarEvent } from '../../../../../helpers/calendar/calendar-event';
-import { Nullable } from '../../../../../types/general';
-import { VegaCalendarBaseEventLayout } from './baseEventLayout';
-import { VegaCalendarFullDayEventLayoutRow } from './fullDayEventLayoutRow';
-/** The VegaCalendarLongEventLayout class manages the layout of long events in a calendar by organizing them into rows. */
-export declare class VegaCalendarFullDayEventLayout extends VegaCalendarBaseEventLayout {
-  protected cells: VegaCalendarFullDayEventLayoutRow[];
-  /**
-   * The constructor function initializes a VegaCalendarFullDayEventLayoutRow array in TypeScript.
-   *
-   * @param {VegaCalendarFullDayEventLayoutRow[]} rows - An array of VegaCalendarFullDayEventLayoutRow objects.
-   */
-  constructor(rows: VegaCalendarFullDayEventLayoutRow[]);
-  /**
-   * This TypeScript function returns the index of a row containing a specific calendar event.
-   *
-   * @param {CalendarEvent} eventItem - The `eventItem` parameter is a `CalendarEvent` object that represents an event in a calendar.
-   * @returns {number} The function `getEventRowsIndex` returns the index of the row in the `rows` array where the `eventItem` is found based on the condition specified in the `findIndex` method.
-   */
-  getEventRowsIndex(eventItem: CalendarEvent): number;
-  /**
-   * This function retrieves CalendarEvents from each row in a calendar layout based on a specified index.
-   *
-   * @param {number} index - The `index` parameter in the `getEventsByIndex` method is a number that
-   * represents the slot index for which you want to retrieve calendar events. The method iterates
-   * through each row in the `rows` array and retrieves the calendar event at the specified slot index from each row. The method
-   * @returns {(Nullable<CalendarEvent>)[]} An array of CalendarEvent objects is being returned.
-   */
-  getEventsByIndex(index: number): Nullable<CalendarEvent>[];
-}

package/dist/types/components/vega-calendar/slimmers/common/layout/fullDayEventLayoutGenerator.d.ts

@@ -1,39 +0,0 @@
-import { CalendarEvent } from '../../../../../helpers/calendar/calendar-event';
-import { VegaCalendarBaseEventLayoutGenerator } from './baseEventLayoutGenerator';
-import { VegaCalendarFullDayEventLayout } from './fullDayEventLayout';
-import { VegaCalendarFullDayEventLayoutRow } from './fullDayEventLayoutRow';
-/** The `VegaCalendarLongEventLayoutGenerator` class in TypeScript generates a layout for long calendar events with overlapping prevention logic. */
-export declare class VegaCalendarFullDayEventLayoutGenerator extends VegaCalendarBaseEventLayoutGenerator {
-  /**
-   * The function generates a long event layout for a calendar based on the input calendar events.
-   *
-   * @param {CalendarEvent[][]} calendarEvents - CalendarEvent[][] is a two-dimensional array where each
-   * element represents a day in the calendar and contains an array of CalendarEvent objects representing events on that day.
-   * @returns {VegaCalendarFullDayEventLayout} A new instance of `VegaCalendarFullDayEventLayout` is being returned, which is constructed
-   * using the `layoutRows` array containing `VegaCalendarFullDayEventLayoutRow` objects.
-   */
-  generate(calendarEvents: CalendarEvent[][]): VegaCalendarFullDayEventLayout;
-  /**
-   * The function creates a new instance of VegaCalendarFullDayEventLayoutRow.
-   *
-   * @returns {VegaCalendarFullDayEventLayoutRow} An instance of the class `VegaCalendarFullDayEventLayoutRow` is being returned.
-   */
-  protected createNewLayoutCell(): VegaCalendarFullDayEventLayoutRow;
-  /**
-   * Filter the all should order group event from event list
-   *
-   * @param {CalendarEvent[][]} allEvents all event list
-   * @returns {VegaCalendarFullDayEventView[]} the group event view list
-   */
-  private collectAllShouldOrderLongEvents;
-  /**
-   * This function sorts an array of VegaCalendarFullDayEventView objects based on their start and end times.
-   *
-   * @param {VegaCalendarFullDayEventView[]} eventViews - The `eventViews` parameter is an array of
-   * `VegaCalendarFullDayEventView` objects that represent long events in a calendar. The function
-   * `sortLongEventViews` takes this array as input and sorts it based on the start and end times of the events.
-   * @returns {VegaCalendarFullDayEventView[]} The function `sortLongEventViews` is returning an array of `VegaCalendarFullDayEventView`
-   * objects that have been sorted based on the comparison logic provided in the sorting function. The sorting is done based on the `start` and `end` properties of the objects in the array.
-   */
-  private sortLongEventViews;
-}

package/dist/types/components/vega-calendar/slimmers/common/layout/fullDayEventLayoutRow.d.ts

@@ -1,26 +0,0 @@
-import { CalendarEvent } from '../../../../../helpers/calendar/calendar-event';
-import { Nullable } from '../../../../../types/general';
-import { VegaCalendarFullDayEventView } from '../../../types';
-import { VegaCalendarBaseEventLayoutCell } from './baseEventLayoutCell';
-/** The `VegaCalendarLongEventLayoutRow` class in TypeScript manages the layout of long events in a calendar by updating slots and checking for overlaps. */
-export declare class VegaCalendarFullDayEventLayoutRow extends VegaCalendarBaseEventLayoutCell {
-  static readonly defaultSlots: Nullable<CalendarEvent>[];
-  protected slots: Nullable<CalendarEvent>[];
-  /**
-   * The function `updateRowSlots` updates a row of slots in a calendar view with a long event.
-   *
-   * @param {VegaCalendarFullDayEventView} eventView - The `eventView` parameter in the `updateRowSlots` method is of type `VegaCalendarFullDayEventView`. It contains information about a long event in a
-   */
-  updateSlots(eventView: VegaCalendarFullDayEventView): void;
-  /**
-   * The function checks if a given event overlaps with existing events in a calendar view.
-   *
-   * @param {VegaCalendarFullDayEventView} eventView - The `eventView` parameter in the `hasOverlapEvent`
-   * function represents a view of a long event in a Vega calendar. It contains the `start` and `end`
-   * properties which specify the start and end times of the event. The function checks if there is any
-   * overlap with existing events in
-   * @returns {boolean} The function `hasOverlapEvent` returns a boolean value indicating whether there is an
-   * overlap in the slots between the start and end times of the given `VegaCalendarFullDayEventView` event.
-   */
-  hasOverlapEvent(eventView: VegaCalendarFullDayEventView): boolean;
-}

package/dist/types/components/vega-calendar/slimmers/day-view/renderers/timed-event/layout/dayViewTimedEventLayout.d.ts

@@ -1,20 +0,0 @@
-import { CalendarEvent } from '../../../../../../../helpers/calendar/calendar-event';
-import { VegaCalendarBaseEventLayout } from '../../../../common/layout/baseEventLayout';
-import { VegaCalendarDayViewTimedEventLayoutColumn } from './dayViewTimedEventLayoutColumn';
-/** This TypeScript class, VegaCalendarDayViewTimedEventLayout, manages the layout of events in a day view calendar. */
-export declare class VegaCalendarDayViewTimedEventLayout extends VegaCalendarBaseEventLayout {
-  protected cells: VegaCalendarDayViewTimedEventLayoutColumn[];
-  /**
-   * The constructor function initializes the columns property with the provided array of VegaCalendarDayViewTimedEventLayoutColumn objects.
-   *
-   * @param {VegaCalendarDayViewTimedEventLayoutColumn[]} columns - An array of VegaCalendarDayViewTimedEventLayoutColumn objects.
-   */
-  constructor(columns: VegaCalendarDayViewTimedEventLayoutColumn[]);
-  /**
-   * The function `getEventColumnsSpannedCount` calculates the number of columns spanned by a given calendar event in a day view layout.
-   *
-   * @param {CalendarEvent} eventItem - The `getEventColumnsSpannedCount` function takes a `CalendarEvent` object as the `eventItem` parameter. This function calculates the number of columns spanned by the given event within the calendar view.
-   * @returns {number} The function `getEventColumnsSpannedCount` returns the number of columns spanned by the given `eventItem` in the `VegaCalendarDayViewTimedEventLayoutColumn` array `columns`.
-   */
-  getEventColumnsSpannedCount(eventItem: CalendarEvent): number;
-}

package/dist/types/components/vega-calendar/slimmers/day-view/renderers/timed-event/layout/dayViewTimedEventLayoutColumn.d.ts

@@ -1,28 +0,0 @@
-import { CalendarEvent } from '../../../../../../../helpers/calendar/calendar-event';
-import { Nullable } from '../../../../../../../types/general';
-import { VegaCalendarBaseEventLayoutCell } from '../../../../common/layout/baseEventLayoutCell';
-/** The class `VegaCalendarDayViewEventLayoutColumn` manages the layout of events in a day view calendar by storing event slots and providing methods to interact with them. */
-export declare class VegaCalendarDayViewTimedEventLayoutColumn extends VegaCalendarBaseEventLayoutCell {
-  static readonly defaultSlots: Nullable<CalendarEvent>[];
-  protected slots: Nullable<CalendarEvent>[];
-  /**
-   * The function `hasOverlapEvent` checks if a given calendar event overlaps with existing events in the calendar.
-   *
-   * @param {CalendarEvent} eventItem - The `eventItem` parameter in the `hasOverlapEvent` function represents a `CalendarEvent` object that contains information about an event such as its start time, end time, and possibly other details related to the event.
-   * @returns {boolean} The function `hasOverlapEvent` returns a boolean value indicating whether there is an overlap in the calendar event slots. If there is an overlap, it returns `true`, otherwise it returns `false`.
-   */
-  hasOverlapEvent(eventItem: CalendarEvent): boolean;
-  /**
-   * The function `updateColumnSlots` updates the slots array by replacing a range of elements with a given event item.
-   *
-   * @param {CalendarEvent} eventItem - The `eventItem` parameter is a `CalendarEvent` object that represents an event in a calendar.
-   */
-  updateSlots(eventItem: CalendarEvent): void;
-  /**
-   * The function `getIndexRangeFromEvent` takes a `CalendarEvent` object and returns an array of time indices based on the start and end times of the event.
-   *
-   * @param {CalendarEvent} eventItem - A CalendarEvent object containing information about a specific event in a calendar, such as its start time and end time.
-   * @returns {number[]} An array of two numbers representing the index range of the start and end times of the given CalendarEvent.
-   */
-  private getIndexRangeFromEvent;
-}

package/dist/types/components/vega-calendar/slimmers/day-view/renderers/timed-event/layout/dayViewTimedEventLayoutGenerator.d.ts

@@ -1,20 +0,0 @@
-import { CalendarEvent } from '../../../../../../../helpers/calendar/calendar-event';
-import { VegaCalendarBaseEventLayoutGenerator } from '../../../../common/layout/baseEventLayoutGenerator';
-import { VegaCalendarDayViewTimedEventLayout } from './dayViewTimedEventLayout';
-import { VegaCalendarDayViewTimedEventLayoutColumn } from './dayViewTimedEventLayoutColumn';
-/** The `VegaCalendarDayViewEventLayoutGenerator` class in TypeScript generates a layout for calendar events in a day view. */
-export declare class VegaCalendarDayViewTimedEventLayoutGenerator extends VegaCalendarBaseEventLayoutGenerator {
-  /**
-   * The function generates a layout for displaying calendar events in a day view.
-   *
-   * @param {CalendarEvent[]} calendarEvents - CalendarEvent[] - an array of calendar events containing information such as event title, start time, end time, and other relevant details.
-   * @returns {VegaCalendarDayViewTimedEventLayout} A `VegaCalendarDayViewTimedEventLayout` object is being returned, which is constructed using the `layoutColumns` array containing `VegaCalendarDayViewTimedEventLayoutColumn` objects.
-   */
-  generate(calendarEvents: CalendarEvent[]): VegaCalendarDayViewTimedEventLayout;
-  /**
-   * The function creates a new instance of VegaCalendarDayViewTimedEventLayoutColumn.
-   *
-   * @returns {VegaCalendarDayViewTimedEventLayoutColumn} An instance of the class `VegaCalendarDayViewTimedEventLayoutColumn` is being returned.
-   */
-  protected createNewLayoutCell(): VegaCalendarDayViewTimedEventLayoutColumn;
-}

package/dist/types/constants/publicApi.d.ts

@@ -1,9 +0,0 @@
-export * from './tokens/borderRadius';
-export * from './tokens/breakpoints';
-export * from './tokens/colors';
-export * from './tokens/icons';
-export * from './tokens/rings';
-export * from './tokens/shadows';
-export * from './tokens/spacing';
-export * from './tokens/typography';
-export { BreakpointKeys } from './ui';

package/dist/types/decorators/property-decorators/injectElementAppender.d.ts

@@ -1,24 +0,0 @@
-import { ComponentInterface } from '../../stencil-public-runtime';
-import { ElementAppenderShowConfig } from '../../helpers/ui/elementAppender';
-declare type ShowConfigFactoryType = (target?: ComponentInterface) => ElementAppenderShowConfig;
-/**
- * - click: means the dropdown show/hide by click, it also listen global area click. example: VegaPopover
- * - hover: means the dropdown show/hide by hover, it also listen global area click. example: VegaDropdown VegaAppHeaderButton
- * - none: means element appender not listens any event, you should control the dropdown show/hide in component. example: VegaDatePicker
- * - custom: means element appender only listen the outer area click. when clicked the dropdown will hide. example: VegaTimePicker
- */
-declare type TriggerType = 'click' | 'hover' | 'none' | 'custom';
-declare type GetTriggerType = (target?: ComponentInterface) => TriggerType;
-/**
- * It creates a proxy for the `ElementAppender` class and attaches it to the component class as a
- * property
- *
- * @param {ShowConfigFactoryType} showConfigFactory - A function that returns a ShowConfig object.
- * @param {GetTriggerType} [getTrigger] - The name of the property that will trigger the dropdown to
- * show/hide.
- * @param {string} [isDropdownShowName] - The name of the property that will be used to determine if
- * the dropdown is shown or not.
- * @returns {void} A function that takes a component class and a string.
- */
-export declare function InjectElementAppender(showConfigFactory: ShowConfigFactoryType, getTrigger: GetTriggerType, isDropdownShowName: string): (target: ComponentInterface, key: string) => void;
-export {};

package/dist/types/decorators/property-decorators/injectKeyboardManager.d.ts

@@ -1,12 +0,0 @@
-import { ComponentInterface } from '../../stencil-public-runtime';
-import { KeyboardEventListener } from '../../helpers/keyboard/keyboardManager';
-/**
- * It takes a function that returns an array of keyboard event listeners, and returns a decorator
- * function that takes a component class and a property name, and registers the listeners returned by
- * the function with the keyboard manager when the component is loaded, and remove registers them when the
- * component is disconnected
- *
- * @param {(instance: ComponentInterface) => KeyboardEventListener[]} listenersRetriever - (instance: ComponentInterface) => KeyboardEventListener[]
- * @returns {void} A decorator function that takes a component class and a property name.
- */
-export declare function InjectKeyboardManager(listenersRetriever: (instance: ComponentInterface) => KeyboardEventListener[]): (target: ComponentInterface, key: string) => void;

package/dist/types/helpers/change-manager/changeManager.d.ts

@@ -1,43 +0,0 @@
-import { Observer } from './observer/observer';
-import { Subject } from './subject/subjectInterface';
-/**
- * The ChangeManager is a class that allows observers to register themselves to a subject
- * and notify the observer if signaled by subject
- *
- * @requires Subject
- * @requires Observer
- * @property {Map<Subject, Observer<unknown>[]>} pubSubMap - the map of subject to observers
- */
-declare class ChangeManager {
-  private pubSubMap;
-  /**
-   * If the subject is already in the map, add the observer to the list of observers for that subject. If the subject is not
-   * in the map, add the subject to the map and add the observer to the list of observers for that subject
-   *
-   * @param {Subject} subject - The subject of the event.
-   * @param {Observer<unknown>} observer - The observer that will be registered.
-   */
-  register(subject: Subject, observer: Observer<unknown>): void;
-  /**
-   * If the subject is in the map, remove the observer from the list of observers for that subject
-   *
-   * @param {Subject} subject - The subject of the event.
-   * @param {Observer<unknown>} observer - The observer to be unregistered.
-   */
-  unregister(subject: Subject, observer: Observer<unknown>): void;
-  /**
-   * The function clears the observers for a given subject in a pub-sub map.
-   *
-   * @param {Subject} subject - The subject parameter is an object that represents the subject of the observer pattern. It is used as a key to identify the observers that are subscribed to it.
-   */
-  clearObserversBySubject(subject: Subject): void;
-  /**
-   * If the subject is in the map, then notify all observers of the subject
-   *
-   * @param {Subject} subject - Subject
-   * @param {unknown} payload - The payload to be sent to the observer.
-   */
-  notify(subject: Subject, payload: unknown): void;
-}
-declare const _default: ChangeManager;
-export default _default;