@uiloos/core/dist/index.d.ts

/**
 * A function which when called will unsubscribe from the observable.
 *
 * @since 1.0.0
 */
type UnsubscribeFunction = () => void;
/**
 * The interface each component of uiloos/core implements so it
 * can be subscribed to.
 *
 * Note: there is no reason to ever implement the `Observable`
 * interface yourself. It is only exposed so bindings to frameworks
 * can use the type.
 *
 * @since 1.4.0
 */
interface Observable<T, E> {
    /**
    * Subscribe to changes of the Observable. The function you provide
    * will get called whenever changes occur in the Observable.
    *
    * Returns an unsubscribe function which when called will
    * unsubscribe from the Observable.
    *
    * @param {Subscriber<T, E>} subscriber The subscriber which responds to changes in the Observable.
    * @returns {UnsubscribeFunction} A function which when called will unsubscribe from the Observable.
    *
    * @since 1.4.0
    */
    subscribe(subscriber: Subscriber<T, E>): UnsubscribeFunction;
}
/**
 * A function which when called will subscribe to the observable.
 *
 * @since 1.4.0
 */
type Subscriber<T, E> = (observerable: T, event: E) => void;

/**
 * Checks / validates the license for "uiloos".
 *
 * Note: you are not supposed to use this class directly. Use the
 * variable `licenseChecker` instead.
 *
 * @since 1.0.0
 */
declare class _LicenseChecker {
    private _licenseKey;
    private _logOnSuccess;
    private _success;
    /**
     * With `activateLicense` you can set activate your license key for
     * uiloos. Make sure that you set your license key before using any
     * functionality that uiloos provides.
     *
     * You can purchase a license at https://www.uiloos.dev.
     *
     * @param {string} licenseKey The license key of uiloos you want to activate.
     * @param {ActivateLicenseOptions} options The optional options for the `activateLicense` function, can be used to suppress the "license activated" message.
     * @since 1.0.0
     */
    activateLicense(licenseKey: string, options?: ActivateLicenseOptions): void;
    /**
     * Checks the current license to see if it is valid.
     *
     * Note: this method is for internal use inside uiloos only.
     *
     * @since 1.0.0
     */
    _checkLicense(): void;
}
/**
 * The sole instance (a singleton) of the `_LicenseChecker` class.
 *
 * Use this instance of `_LicenseChecker` to call `activateLicense` to
 * activate your license.
 *
 * @see _LicenseChecker
 * @since 1.0.0
 *
 * @example
 *
 * Activating license
 *
 * You activate the license by calling "activateLicense" on the
 * "licenseChecker" instance.
 *
 * ```js
 * import { licenseChecker } from '@uiloos/core';
 * licenseChecker.activateLicense("{LICENSE-HERE}");
 * ```
 */
declare let licenseChecker: _LicenseChecker;
/**
 * The options for the `activateLicense` functions. Can be used
 * to silence the "license activated" message.
 *
 * @since 1.0.0
 */
type ActivateLicenseOptions = {
    /**
     * Whether or not to silence the "license activated" message
     * when the license is valid.
     *
     * @since 1.0.0
     */
    logLicenseActivated: boolean;
};

/**
 * Configures the initial state of the `ActiveList`
 *
 * @since 1.0.0
 */
type ActiveListConfig<T> = {
    /**
     * The contents which you want to display, can be an array of anything
     * you want.
     *
     * Note: the `ActiveList` will wrap each item in the `contents` array
     * inside of a `ActiveListContent` item.
     *
     * Defaults to `[]` meaning there is no content.
     *
     * @since 1.0.0
     */
    contents?: T[];
    /**
     * How many items can be active at the same time.
     *
     * When the value of `limit` is `false` there is no limit to the
     * number of active items.
     *
     * Defaults to `1`.
     *
     * @since 1.0.0
     */
    maxActivationLimit?: number | false;
    /**
     * How the limit is enforced. In other words what the behavior
     * should be when the limit is surpassed.
     *
     * The modes are strings which can be the following values:
     *
     * 1. 'circular': the first item which was added will be removed so
     *    the last item can be added without violating the limit. This
     *    basically means that the first one in is the first one out.
     *
     * 2. 'error': An error is thrown whenever the limit is surpassed,
     *    the error is called the `ActiveListActivationLimitReachedError`.
     *
     * 3. 'ignore': Nothing happens when an item is added and the limit
   *    is reached. The item is simply not added, but no error is
   *    thrown.
     *
     * Defaults to 'circular'.
     *
     * @since 1.0.0
     */
    maxActivationLimitBehavior?: ActiveListMaxActivationLimitBehavior;
    /**
     * Which item or items in the content array are currently active.
     *
     * When the `active` is an array each item in the array is activated
     * from left to right one at a time.
     *
     * Note: "active" is chosen over the "activeIndexes" property.
     *
     * Defaults to `[]` meaning no content is active.
     *
     * @since 1.0.0
     */
    active?: T | T[];
    /**
     * Which index or indexes of the content array are currently active.
     *
     * When the `activeIndexes` is an array each index in the array
     * is activated from left to right one at a time.
     *
     * Note: "active" is chosen over the "activeIndexes" property.
     *
     * Defaults to `[]` meaning no content is active.
     *
     * @since 1.0.0
     */
    activeIndexes?: number | number[];
    /**
     * Whether or not the content starts back at the beginning when
     * the end of the content is reached, and whether the content should
     * go to the end when moving left of the start.
     *
     * Defaults to `true`.
     *
     * @since 1.0.0
     */
    isCircular?: boolean;
    /**
     * Whether or not `autoPlay` is enabled. When `autoPlay` is enabled
     * it will automatically move to the next content, based on the
     * `duration`.
     *
     * When `isCircular` is `true` content will move to the right
     * indefinitely. When `isCircular` is `false` it will stop autoPlay
     * at the end of the content.
     *
     * Note: autoPlay will only start when one or more contents are
     * currently active. The reason for this is that the `duration`, is
     * based on the `ActiveList` `lastActivatedContent` property.
     * Whenever there are no more items to activate the autoPlay will
     * stop.
     *
     * Defaults to no autoPlay.
     *
     * @since 1.0.0
     */
    autoPlay?: ActiveListAutoPlayConfig<T>;
    /**
     * Describes which strings should be associated with what
     * direction, will be the value of the `ActiveList` property
     * `direction`.
     *
     * So when setting the direction `next` to "up"` and the content
     * moves up, the `ActiveList.direction` will be "up". Useful when
     * wanting to apply CSS classes based on the direction.
     *
     * Defaults to `{ next: 'right', previous: 'left' }`.
     *
     * @since 1.0.0
     */
    directions?: ActiveListDirection;
    /**
     * For how many items the `history` may contain in the `ActiveList`.
     *
     * Defaults to `0` meaning that it will not track history.
     *
     * @since 1.0.0
     */
    keepHistoryFor?: number;
    /**
     * The `cooldown` is the number of milliseconds before another
     * activation / deactivation is allowed. For example if the
     * `cooldown` is `5000` the `ActiveList` will not allow
     * transitions until after 5 seconds have passed. Any activation /
     * deactivation in that period will simply be ignored.
     *
     * This can be useful when you have an animation which should be
     * finished before allowing user interaction again.
     *
     * This global `cooldown` is the same for all transitions you might trigger.
     * If you want a `cooldown` that differs per button use the `cooldown`
     * in the `ActiveListActivationOptions` instead.
     *
     * Note that the `cooldown` options with the `ActiveListActivationOptions` takes
     * precedence over this more global cooldown.
     *
     * IMPORTANT: `cooldown` is only ran when `isUserInteraction` within
     * the `ActiveListActivationOptions` is `true`. This means that `autoPlay`, which
     * is not a user interaction, ignores the `cooldown`.
     *
     * @since 1.0.0
     */
    cooldown?: ActiveListCooldownConfig<T>;
};
/**
 * Describes all the behaviors for when the limit of the ActiveList
 * is surpassed.
 *
 * 1. 'circular': the first item which was added will be removed so
 *    the last item can be added without violating the limit. This
 *    basically means that the first one in is the first one out.
 *
 * 2. 'error': An error is thrown whenever the limit is surpassed,
 *    the error is called the `ActiveListActivationLimitReachedError`.
 *
 * 3. 'ignore': Nothing happens when an item is added and the limit
 *    is reached. The item is simply not added, but no error is
 *    thrown.
 *
 * @since 1.0.0
 */
type ActiveListMaxActivationLimitBehavior = 'circular' | 'ignore' | 'error';
/**
 * Represents options for activation / deactivation methods.
 *
 * @since 1.0.0
 */
type ActiveListActivationOptions<T> = {
    /**
     * Whether or not the action was taken by a user / human. This
     * affects the `autoPlay` when `stopsOnUserInteraction` is `true`,
     * the `autoPlay` stops, when `false` the autoPlay is debounced.
     *
     * Also affects the `cooldown` when `isUserInteraction` is `true`,
     * the `cooldown` is checked, otherwise when `false`
     * the `cooldown` is ignored.
     *
     * Defaults to `true`.
     *
     * @since 1.0.0
     */
    isUserInteraction?: boolean;
    /**
     * The `cooldown` is the number of milliseconds before another
     * activation / deactivation is allowed. For example if the
     * `cooldown` is `5000` the `ActiveList` will not allow
     * transitions until after 5 seconds have passed. Any activation /
     * deactivation in that period will simply be ignored.
     *
     * This can be useful when you have an animation which should be
     * finished before allowing user interaction again.
     *
     * The benefit of this `cooldown` over the `cooldown` in the
     * `Config`, is that this `cooldown` can be different for different
     * actions. For example: it allows you to create two buttons each
     * with a different cooldown.
     *
     * Note that the `cooldown` options within the `ActiveListActivationOptions`
     * takes precedence over the `cooldown` in the `Config`.
     *
     * IMPORTANT: `cooldown` is only ran when `isUserInteraction` within
     * the `ActiveListActivationOptions` is `true`. This means that
     * `autoPlay`, which is not a user interaction, ignores the
     * `cooldown`.
     *
     * @since 1.0.0
     */
    cooldown?: ActiveListCooldownConfig<T>;
};
/**
 * The subscriber which is informed of all state changes the
 * ActiveList goes through.
 *
 * @param {ActiveList<T>} activeList The ActiveList which had changes.
 * @param {ActiveListEvent<T>} event The event that occurred.
 *
 * @since 1.0.0
 */
type ActiveListSubscriber<T> = (activeList: ActiveList<T>, event: ActiveListEvent<T>) => void;
/**
 * Represents a bundle of data which is given as the first parameter
 * to the ContentPredicate function. Based on this data the
 * ContentPredicate must either return `true` or `false`.
 *
 * @since 1.0.0
 */
type ActiveListContentPredicateData<T> = {
    /**
     * The value the ActiveListContent wraps.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index the ActiveListContent has within the ActiveList
     *
     * @since 1.0.0
     */
    index: number;
    /**
     * A reference to the ActiveListContent which wraps the value.
     *
     * @since 1.0.0
     */
    content: ActiveListContent<T>;
    /**
     * A reference to the ActiveList itself.
     *
     * @since 1.0.0
     */
    activeList: ActiveList<T>;
};
/**
 * Represents a callback which is given all relevant data for the
 * action, and expects either `true` or `false` to be returned. If
 * `true` is returned will perform the action.
 *
 * @param {ActiveListContentPredicateData<T>} data The data for which this predicate will determine if the action needs to be performed.
 * @returns {boolean} Whether or not to perform the action associated with the predicate based on the given item and index.
 *
 * @since 1.0.0
 */
type ActiveListContentPredicate<T> = (data: ActiveListContentPredicateData<T>) => boolean;
/**
 * Represents a bundle of data which is given whenever the
 * AutoPlayDurationCallbackData function must determine the number
 * of milliseconds the content should be active for.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlayDurationCallbackData<T> = {
    /**
     * The value which is currently asking which autoPlay duration it should have.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index the value has within the ActiveList
     *
     * @since 1.0.0
     */
    index: number;
    /**
     * A reference to the ActiveListContent which wraps the value.
     *
     * @since 1.0.0
     */
    content: ActiveListContent<T>;
    /**
     * A reference to the ActiveList itself.
     *
     * @since 1.0.0
     */
    activeList: ActiveList<T>;
};
/**
 * Represents a callback function which is given all relevant autoPlay
 * duration data, and expects to be given back the number of
 * milliseconds the content should be active before autoPlay moves on.
 *
 * @param {ActiveListAutoPlayDurationCallbackData<T>} data An object containing all relevant duration data for which the callback function must determine the number of milliseconds the content is active for.
 * @returns {number} The time in milliseconds the content is active for the given AutoPlayDurationCallbackData.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlayDurationCallback<T> = (config: ActiveListAutoPlayDurationCallbackData<T>) => number;
/**
 * Represents the configuration for AutoPlay. AutoPlay means
 * that the ActiveList will move to the next content by itself
 * after a duration.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlayConfig<T> = {
    /**
     * The time in milliseconds the ActiveListContent should remain active, before
     * moving to the next ActiveListContent.
     *
     * @since 1.0.0
     */
    duration: ActiveListAutoPlayDurationCallback<T> | number;
    /**
     * Whether or not the user interacting with the component should
     * stop the autoPlay.
     *
     * When `true` any activation / deactivation method called on
     * the `ActiveList` will stop the autoPlay. When `false` it will
     * debounce the autoPlay instead by the duration.
     *
     * Defaults to `false`.
     *
     * @since 1.0.0
     */
    stopsOnUserInteraction?: boolean;
};
/**
 * AutoPlay means that the ActiveList will move to the next content by
 * itself after a duration.
 *
 * Contains whether or not the autoPlay is playing via `isPlaying` and
 * the current duration via `duration`.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlay = {
    /**
     * Whether or not the ActiveList is playing. In other words whether
     * or not the ActiveList is going to cycle through the content
     * automatically.
     *
     * @since 1.0.0
     */
    isPlaying: boolean;
    /**
     * The amount of milliseconds the item should remain active before
     * jumping to the next item.
     *
     * This duration is the duration for the current item which is
     * playing. It is not affected by calling pause, meaning that
     * when the duration is set to 200ms and you pause after 100ms,
     * the duration will still be 200ms.
     *
     * When calling `stop`, or when `stop` is called when the autoPlay
     * reaches the end, the duration will be set to zero.
     *
     * @since 1.0.0
     */
    duration: number;
    /**
     * Whether or not the ActiveList had the autoPlay stopped at one
     * point before.
     *
     * Use case: say you are making a carousel which should stop on
     * any user interaction, so you set `stopsOnUserInteraction` to
     * `true`. Say you also have another feature: a pause whenever
     * the user hovers over the carousel. These two features would cause
     * a conflict:
     *
     * Whenever the mouse over happens you call `play()`, which negates
     * the `stopsOnUserInteraction`, causing the carousel to play again.
     *
     * To fix this problem you should on the mouse over not call
     * `play()` whenever `hasBeenStoppedBefore` is `true`.
     *
     * @since 1.1.0
     */
    hasBeenStoppedBefore: boolean;
};
/**
 * Represents the configuration of the cooldown.
 *
 * Can be two possible things:
 *
 * 1. A callback function which receives the relevant cooldown data,
 *    and which is required to return the duration in milliseconds.
 *    Useful for providing a different cooldown for different items.
 *
 * 2. A number in milliseconds. When it is a number all items will
 *    have the same cooldown.
 *
 * @since 1.0.0
 */
type ActiveListCooldownConfig<T> = ActiveListCooldownDurationCallback<T> | number;
/**
 * Represents a bundle of data which is given whenever the
 * CooldownDurationCallback function must determine what the number of
 * milliseconds the content should be in a cooldown state.
 *
 * @since 1.0.0
 */
type ActiveListCooldownDurationCallbackData<T> = {
    /**
     * The value which is currently asking which cooldown it should have.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index the value has within the ActiveList
     *
     * @since 1.0.0
     */
    index: number;
    /**
     * A reference to the ActiveListContent which wraps the value.
     *
     * @since 1.0.0
     */
    content: ActiveListContent<T>;
    /**
     * A reference to the ActiveList itself.
     *
     * @since 1.0.0
     */
    activeList: ActiveList<T>;
};
/**
 * Represents a callback function which is given all relevant cooldown
 * duration data, and expects to be given back the number of
 * milliseconds the content should be cooled down before it responds
 * to user interaction again.
 *
 * WARNING: do not return a negative number or zero in this callback
 * as this results in a `ActiveListCooldownDurationError`. The action
 * will still occur however, this means that the ActiveList is invalid
 * when this happens.
 *
 * @param {ActiveListCooldownDurationCallbackData<T>} data An object containing all relevant cooldown data for which the callback function must determine the cooldown duration in number of milliseconds.
 * @returns {number} The time in milliseconds of the duration of the cooldown for the given CooldownCallbackData.
 *
 * @since 1.0.0
 */
type ActiveListCooldownDurationCallback<T> = (data: ActiveListCooldownDurationCallbackData<T>) => number;
/**
 * A Cooldown is a time period in which all user made activations
 * and deactivations are prevented / ignored. Activations and
 * deactivations where the `isUserInteraction` is set to `false`
 * always bypass the cooldown.
 *
 * The use-case is a cooldown can guarantees that animations are
 * completed, before another is triggered.
 *
 * Contains whether or not the cooldown is active via `isActive` and
 * the current duration via `duration`.
 *
 * @since 1.0.0
 */
type ActiveListCooldown = {
    /**
     * Whether or not the ActiveList is currently in the cooldown state.
     * When in cooldown all activations and deactivations are ignored.
     *
     * @since 1.0.0
     */
    isActive: boolean;
    /**
     * The amount of milliseconds the ActiveList should remain in
     * the cooldown state.
     *
     * @since 1.0.0
     */
    duration: number;
};
/**
 * Describes which strings should be associated with what
 * direction. For example it could be "right" and "left",
 * or "down" and "up".
 *
 * Will be the value of the `ActiveList` property `direction`.
 *
 * Useful for when animations have a certain direction and you
 * name your animation CSS classes `left-animation` and
 * `right-animation`.
 *
 * @since 1.0.0
 */
type ActiveListDirection = {
    /**
     * The name of the direction when moving to the next item of the
     * `ActiveList`.
     *
     * Could for example be "right" or "down".
     *
     * @since 1.0.0
     */
    next: string;
    /**
     * The name of the direction when moving to the previous item of the
     * `ActiveList`.
     *
     * Could for example be "left" or "up".
     *
     * @since 1.0.0
     */
    previous: string;
};
/**
 * Represents whether the `ActiveListEvent` was inserted, removed, activated
 * swapped, etc etc.
 *
 * @since 1.0.0
 */
type ActiveListEventType = 'INITIALIZED' | 'INSERTED' | 'REMOVED' | 'REMOVED_MULTIPLE' | 'ACTIVATED' | 'ACTIVATED_MULTIPLE' | 'SWAPPED' | 'MOVED' | 'DEACTIVATED' | 'DEACTIVATED_MULTIPLE' | 'AUTO_PLAY_PLAYING' | 'AUTO_PLAY_PAUSED' | 'AUTO_PLAY_STOPPED' | 'COOLDOWN_STARTED' | 'COOLDOWN_ENDED';
/**
 * Represents an event which happened in the ActiveList. Based
 * on the `type` you can determine which event occurred.
 *
 * @since 1.0.0
 */
type ActiveListBaseEvent = {
    /**
     * Which event occurred
     *
     * @since 1.0.0
     */
    type: ActiveListEventType;
    /**
     * The time the event occurred on as a Date object.
     *
     * @since 1.0.0
     */
    time: Date;
};
/**
 * Represents the initialization of the ActiveList
 *
 * @since 1.0.0
 */
type ActiveListInitializedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'INITIALIZED';
    /**
     * The values which were active upon initialization.
     *
     * Note: these are the values at the time of the initialization, they might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    values: T[];
    /**
     * The indexes of the values which were active upon initialization.
     *
     * Note: these are the indexes at the time of the initialization, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    indexes: number[];
};
/**
 * Represents an insertion into the ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListInsertedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'INSERTED';
    /**
     * The value which was inserted.
     *
     * Note: this was the value at the time of insertion, it might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index of the insertion.
     *
     * Note: this was the index at the time of the insertion, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    index: number;
};
/**
 * Represents an removal of an item of the ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListRemovedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'REMOVED';
    /**
     * The value which was removed.
     *
     * Note: this was the value at the time of removal, it might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index of removed item.
     *
     * Note: this was the index at the time of the removal, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    index: number;
};
/**
 * Represents multiple removals of items in the ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListRemovedMultipleEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'REMOVED_MULTIPLE';
    /**
     * The values which were removed
     *
     * Note: these are the values at the time of removal, they might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    values: T[];
    /**
     * The indexes of the removed items.
     *
     * Note: these are the indexes at the time of the removal, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    indexes: number[];
};
/**
 * Represents an activation of an ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListActivatedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'ACTIVATED';
    /**
     * The value which was activated.
     *
     * Note: this was the value at the time of activation, it might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index of the activated item.
     *
     * Note: this was the index at the time of the activation, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    index: number;
    /**
     * The value which was deactivated, will be `null` when no value
     * was deactivated as part of the activation.
     *
     * A deactivation will only happen as part of an activation when
     * `maxActivationLimit` is set to a `number` and
     * `maxActivationLimitBehavior` is set to `circular`.
     *
     * Note: these are the values at the time of deactivation, they might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.5.0
     */
    deactivatedValue: T | null;
    /**
     * The index of the deactivated item, will be `-1` when no index
     * was deactivated as part of the activation.
     *
     * A deactivation will only happen as part of an activation when
     * `maxActivationLimit` is set to a `number` and
     * `maxActivationLimitBehavior` is set to `circular`.
     *
     * Note: this was the index at the time of the deactivation, it might
     * no longer be accurate.
     *
     * @since 1.5.0
     */
    deactivatedIndex: number;
};
/**
 * Represents multiple activations happening at the same time in an
 * ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListActivatedMultipleEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'ACTIVATED_MULTIPLE';
    /**
     * The values which were activated.
     *
     * Note: these are the values at the time of activation, they might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    values: T[];
    /**
     * The indexes of the activated items.
     *
     * Note: these are the indexes at the time of the activation, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    indexes: number[];
    /**
     * The values which were deactivated.
     *
     * A deactivation will only happen as part of an activation when
     * `maxActivationLimit` is set to a `number` and
     * `maxActivationLimitBehavior` is set to `circular`.
     *
     * Note: these are the values at the time of deactivation, they might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.5.0
     */
    deactivatedValues: T[];
    /**
     * The indexes of the deactivated items.
     *
     * A deactivation will only happen as part of an activation when
     * `maxActivationLimit` is set to a `number` and
     * `maxActivationLimitBehavior` is set to `circular`.
     *
     * Note: these are the indexes at the time of the deactivation, it might
     * no longer be accurate.
     *
     * @since 1.5.0
     */
    deactivatedIndexes: number[];
};
/**
 * Represents a deactivation of an ActiveList.
 *
 * IMPORTANT: this event is only fired as a result of a direct
 * deactivation call. So not when activating an item also deactivated
 * an item due to a `maxActivationLimit` being set.
 *
 * @since 1.0.0
 */
type ActiveListDeactivatedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'DEACTIVATED';
    /**
     * The value which was deactivated.
     *
     * Note: this was the value at the time of deactivation, it might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * The index of the deactivated item.
     *
     * Note: this was the index at the time of the deactivation, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    index: number;
};
/**
 * Represents multiple deactivations happening at the same time in an
 * ActiveList.
 *
 * IMPORTANT: this event is only fired as a result of a direct
 * deactivation call. So not when activating an item also deactivated
 * an item due to a `maxActivationLimit` being set.
 *
 *
 * @since 1.0.0
 */
type ActiveListDeactivatedMultipleEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'DEACTIVATED_MULTIPLE';
    /**
     * The values which were deactivated.
     *
     * Note: these are the values at the time of deactivation, they might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    values: T[];
    /**
     * The indexes of the deactivated items.
     *
     * Note: these are the indexes at the time of the deactivation, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    indexes: number[];
};
/**
 * Represents an activation of an ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListSwappedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'SWAPPED';
    /**
     * An object containing the value of the items which were swapped.
     *
     * @since 1.0.0
     */
    value: {
        /**
         * The value of the first item which was swapped.
         *
         * Note: this was the value at the time of the swap, it might
         * no longer be accurate. Keep in mind that when the `value` is
         * an object or an array, they can still be mutated, because no
         * copy is made.
         *
         * @since 1.0.0
         */
        a: T;
        /**
         * The value of the second item which was swapped.
         *
         *  Note: this was the value at the time of the swap, it might
         * no longer be accurate. Keep in mind that when the `value` is
         * an object or an array, they can still be mutated, because no
         * copy is made.
         *
         * @since 1.0.0
         */
        b: T;
    };
    /**
     * An object containing the indexes of the items which were swapped.
     *
     * @since 1.0.0
     */
    index: {
        /**
         * The index of the first item before it was swapped.
         *
         * Note: this was the index at the time of the activation, it might
         * no longer be accurate.
         *
         * @since 1.0.0
         */
        a: number;
        /**
         * The index of the second item before it was swapped.
         *
         * Note: this was the index at the time of the activation, it might
         * no longer be accurate.
         *
         * @since 1.0.0
         */
        b: number;
    };
};
/**
 * Represents an activation of an ActiveList.
 *
 * @since 1.0.0
 */
type ActiveListMovedEvent<T> = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'MOVED';
    /**
     * The value which was moved.
     *
     * Note: this was the value at the time of the move, it might
     * no longer be accurate. Keep in mind that when the `value` is
     * an object or an array, they can still be mutated, because no
     * copy is made.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * An object containing the "from" and "to" index of the item which
     * were moved.
     *
     * Note: this was the index at the time of the activation, it might
     * no longer be accurate.
     *
     * @since 1.0.0
     */
    index: {
        /**
         * The index of the "from" item before it was moved.
         *
         * Note: this was the index at the time of the activation, it might
         * no longer be accurate.
         *
         * @since 1.0.0
         */
        from: number;
        /**
         * The index of the "to" item before it was moved.
         *
         * Note: this was the index at the time of the activation, it might
         * no longer be accurate.
         *
         * @since 1.0.0
         */
        to: number;
    };
};
/**
 * Represents an ActiveList autoPlay being restarted again when it was
 * stopped or paused.
 *
 * Note: this event is not fired when a ActiveList is initialized
 * even though this does start the autoPlay.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlayPlayingEvent = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'AUTO_PLAY_PLAYING';
};
/**
 * Represents an ActiveList autoPlay being paused.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlayPausedEvent = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'AUTO_PLAY_PAUSED';
};
/**
 * Represents an ActiveList autoPlay being stopped.
 *
 * Can be fired for four reasons:
 *
 * 1. The `stop` method on the `ActiveList` is called.
 *
 * 2. The autoPlay reached the last of the items, which can only
 *    happen when `isCircular` is `false`.
 *
 * 3. When all content items are removed when the autoPlay is playing.
 *    It will then stop automatically since there are no more items.
 *
 * 4. When no more items are left active, in this case the autoPlay
 *    will stop as well.
 *
 * Note: due to reasons 3 and 4 this event can be fired right before
 * a 'REMOVED', 'REMOVED_MULTIPLE', 'DEACTIVATED' and
 * 'DEACTIVATED_MULTIPLE' event.
 *
 * @since 1.0.0
 */
type ActiveListAutoPlayStoppedEvent = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'AUTO_PLAY_STOPPED';
};
/**
 * Represents an ActiveList being in a cooldown state, meaning no
 * activations or deactivations can occur.
 *
 * @since 1.0.0
 */
type ActiveListCooldownStartedEvent = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'COOLDOWN_STARTED';
};
/**
 * Represents an ActiveList moving out of the cooldown state, meaning
 * all activation and deactivations can occur again.
 *
 * @since 1.0.0
 */
type ActiveListCooldownEndedEvent = ActiveListBaseEvent & {
    /**
     * Which type occurred
     *
     * @since 1.0.0
     */
    type: 'COOLDOWN_ENDED';
};
/**
 * A ActiveListEvent represents an event happened in the ActiveList.
 * For example the insertion, removal, or activation of a
 * ActiveListContent<T>.
 *
 * @since 1.0.0
 */
type ActiveListEvent<T> = ActiveListInitializedEvent<T> | ActiveListInsertedEvent<T> | ActiveListRemovedEvent<T> | ActiveListRemovedMultipleEvent<T> | ActiveListActivatedEvent<T> | ActiveListActivatedMultipleEvent<T> | ActiveListSwappedEvent<T> | ActiveListMovedEvent<T> | ActiveListDeactivatedEvent<T> | ActiveListDeactivatedMultipleEvent<T> | ActiveListAutoPlayPlayingEvent | ActiveListAutoPlayPausedEvent | ActiveListAutoPlayStoppedEvent | ActiveListCooldownStartedEvent | ActiveListCooldownEndedEvent;
/**
 * Represents where the action needs to take place for when a
 * predicate is provided.
 *
 * 1. When the mode is 'at', the `ActiveListContent` is inserted to the
 *    position where the predicate matches. This is the `default`
 *    mode.
 *
 * 2. When the mode is 'after', the `ActiveListContent` is inserted to after
 *    the position where the predicate matches.
 *
 * 3. When the mode is 'before', the `ActiveListContent` is inserted to
 *    before the position where the predicate matches.
 *
 * @since 1.0.0
 */
type ActiveListPredicateMode = 'at' | 'before' | 'after';
/**
 * Represents options for methods which require predicates.
 *
 * @since 1.0.0
 */
type ActiveListPredicateOptions = {
    /**
     * Represents where the action needs to take place for when a
     * predicate is provided.
     *
     * Represents where the action needs to take place for when a
     * predicate is provided.
     *
     * 1. When the mode is 'at', the `ActiveListContent` is inserted to the
     *    position where the predicate matches. This is the `default`
     *    mode.
     *
     * 2. When the mode is 'after', the `ActiveListContent` is inserted to after
     *    the position where the predicate matches.
     *
     * 3. When the mode is 'before', the `ActiveListContent` is inserted to
     *    before the position where the predicate matches.
     *
     * @since 1.0.0
     */
    mode: ActiveListPredicateMode;
};

/**
 * Represents a piece of content in the `contents` array of the `ActiveList`.
 *
 * The purpose of the ActiveListContent is to act as a wrapper around the
 * value which is actually in the contents array. It knows things like
 * whether the item is active or not.
 *
 * It also contains methods to activate, remove, swap and move itself
 * within the ActiveList.
 *
 * @since 1.0.0
 */
declare class ActiveListContent<T> {
    /**
     * Reference to the ActiveList is it a part of.
     *
     * @since 1.0.0
     */
    activeList: ActiveList<T>;
    /**
     * The index of the `ActiveListContent` which it has within the `contents`.
     *
     * @since 1.0.0
     */
    index: number;
    /**
     * The actual `value` of the `ActiveListContent` it can be whatever the
     * developer wants it to be.
     *
     * @since 1.0.0
     */
    value: T;
    /**
     * Whether or not the `ActiveListContent` is currently active.
     *
     * @since 1.0.0
     */
    isActive: boolean;
    /**
     * Whether or not the `ActiveListContent` has been active at least once
     * in the past.
     *
     * @since 1.0.0
     */
    hasBeenActiveBefore: boolean;
    /**
     * Whether or not the `ActiveListContent` is considered to be the first
     * item in the `contents`.
     *
     * @since 1.0.0
     */
    isFirst: boolean;
    /**
     * Whether or not the `ActiveListContent` is considered to be the last
     * item in the `contents`.
     *
     * @since 1.0.0
     */
    isLast: boolean;
    /**
     * Whether this `ActiveListContent` has at least one other `ActiveListContent` coming
     * after it in the `contents`
     *
     * @since 1.0.0
     */
    hasNext: boolean;
    /**
     * Whether this `ActiveListContent` has at least one other `ActiveListContent` coming
     * before it in the `contents`.
     *
     * @since 1.0.0
     */
    hasPrevious: boolean;
    /**
     * Whether this `ActiveListContent` comes directly after the `ActiveListContent`, in the
     * `contents` array, which is currently the `lastActiveList`.
     *
     * @since 1.0.0
     */
    isNext: boolean;
    /**
     * Whether this `ActiveListContent` comes directly before the `ActiveListContent`, in the
     * `contents` array, which is currently the `lastActiveList`.
     *
     * @since 1.0.0
     */
    isPrevious: boolean;
    /**
     * Creates an ActiveListContent which belongs to the given ActiveList.
     *
     * Note: you should never create instances of ActiveListContent yourself. You
     * are supposed to let ActiveList do this for you.
     *
     * @param {ActiveList<T>} activeList The ActiveList this ActiveListContent belongs to.
     * @param {number} index The index of this ActiveListContent within the ActiveList.
     * @param {T} value The value this ActiveListContent wraps.
     *
     * @since 1.0.0
     */
    constructor(activeList: ActiveList<T>, index: number, value: T);
    /**
     * When calling `activate` it will make this `ActiveListContent` active.
     *
     * @param {ActiveListActivationOptions<T>} [activationOptions] The activation options @see ActiveListActivationOptions<T>
     *
     * @since 1.0.0
     */
    activate(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * When calling `deactivate` it will make this `ActiveListContent` inactive.
     *
     * @param {ActiveListActivationOptions<T>} [activationOptions] The activation options @see ActiveListActivationOptions<T>
     *
     * @since 1.0.0
     */
    deactivate(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * When calling `toggle` it will flip the this `ActiveListContent`
     * `isActive` state.
     *
     * So when `isActive` is `true` and `toggle` is called, `isActive`
     * will become `false`. When `isActive` is `false` and `toggle` is
     * called, `isActive` will become `true`.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {ActiveListActivationOptions<T>} [activationOptions] The activation options @see ActiveListActivationOptions<T>
     *
     * @since 1.0.0
     */
    toggle(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * When calling `remove` it will remove this `ActiveListContent`, and return
     * the `value` the ActiveListContent held.
     *
     * @returns {T} The removed value
     *
     * @since 1.0.0
     */
    remove(): T;
    /**
     * Swaps the `ActiveListContent` with the `ActiveListContent` at the given index.
     *
     * Note: if the active `ActiveListContent` is swapped, it will stay active,
     * it will only get a new position.
     *
     * @param {number} index The index to swap the current `ActiveListContent` with.
     * @throws {ActiveListItemNotFoundError} Item not found error
     *
     * @since 1.0.0
     */
    swapWith(item: T): void;
    /**
     * Swaps the `ActiveListContent` with the `ActiveListContent` at the given index.
     *
     * Note: if the active `ActiveListContent` is swapped, it will stay active,
     * it will only get a new position.
     *
     * @param {number} index] The index to swap the current `ActiveListContent` with.
     * @throws {ActiveListIndexOutOfBoundsError} Index out of bounds error.
     *
     * @since 1.0.0
     */
    swapWithByIndex(index: number): void;
    /**
     * Swaps the `ActiveListContent` with the next `ActiveListContent` in the sequence.
     *
     * If `isCircular` of the `ActiveList` is `true` swapping whilst on
     * the last index will make this `ActiveListContent` swap with the
     * first index. If `isCircular` is `false` it will do nothing,
     *  and keep the `ActiveListContent` on the last index.
     *
     * Note: if the active `ActiveListContent` is swapped, it will stay active,
     * it will only get a new position.
     *
     * @since 1.0.0
     */
    swapWithNext(): void;
    /**
     * Swaps the `ActiveListContent` with the previous `ActiveListContent` in the sequence.
     *
     * If `isCircular` of the `ActiveList` is `true` swapping whilst on
     * the first index will make this `ActiveListContent` swap with the
     * last index. If `isCircular` is `false` it will do nothing,
     *  and keep the `ActiveListContent` on the first index.
     *
     * Note: if the active `ActiveListContent` is swapped, it will stay active,
     * it will only get a new position.
     *
     * @since 1.0.0
     */
    swapWithPrevious(): void;
    /**
     * Moves the `ActiveListContent` to the position at index "to".
     *
     * It is possible to move the `ActiveListContent` to the last place by making
     * the "to" index the length of the `contents` array.
     *
     * Note: if the active `ActiveListContent` is moved it will stay active,
     * meaning that the activeIndex will get updated.
     *
     * @param {number} to The location the `from` needs to move "to".
     * @throws {ActiveListIndexOutOfBoundsError} Index out of bounds error.
     *
     * @since 1.0.0
     */
    moveToIndex(to: number): void;
    /**
     * Moves the `ActiveListContent` to the position of the item for which
     * the predicate returns `true`.
     *
     * If no item matches the predicate nothing is moved.
     *
     * The position to where the `ActiveListContent` is inserted can be altered by
     * providing a mode:
     *
     *  1. When the mode is 'at', the `ActiveListContent` is inserted to the
     *     position where the predicate matches. This is the `default`
     *     mode.
     *
     *  2. When the mode is 'after', the `ActiveListContent` is inserted to after
     *     the position where the predicate matches.
     *
     *  3. When the mode is 'before', the `ActiveListContent` is inserted to
     *     before the position where the predicate matches.
     *
     * @param {ActiveListContentPredicate<T>} predicate The predicate function which when `true` is returned moves the item to after that position.
     * @param {ActiveListPredicateOptions} options The options for the predicate, when no options are provided the mode will default to "at".
     *
     * @since 1.0.0
     */
    moveToPredicate(predicate: ActiveListContentPredicate<T>, options?: ActiveListPredicateOptions): void;
    /**
     * Moves the `ActiveListContent` to the first position in the contents array.
     *
     * Note: if the active `ActiveListContent` is moved it will stay active,
     * meaning that the activeIndex will get updated.
     *
     * @since 1.0.0
     */
    moveToFirst(): void;
    /**
     * Moves the `ActiveListContent` to the last position in the contents array.
     *
     * Note: if the active `ActiveListContent` is moved it will stay active,
     * meaning that the activeIndex will get updated.
     *
     * @since 1.0.0
     */
    moveToLast(): void;
}

/**
 * ActiveList is a class which represents visual elements which
 * have multiple pieces of content which can be active or inactive.
 *
 * The `ActiveList` can be used to implement multiple types of
 * components:
 *
 *  1. A tabs component for which one tab can be active at a time.
 *
 *  2. A carrousel component: the user sees single slide, which will
 *     autoPlay to the next slide automatically.
 *
 *  3. A dropdown menu with one active menu item.
 *
 *  4. A accordion component from which the user can open multiple
 *     items at once.
 *
 *  5. A list the user can sort and move around.
 *
 *  6. Etc etc
 *
 * Another way of defining the ActiveList is that it is an array
 * / list like data structure, because it supports things like
 * insertion and removal.
 *
 * ActiveList will make sure that when content is inserted, that
 * the active content is not affected.
 *
 * @since 1.0.0
 */
declare class ActiveList<T> implements Observable<ActiveList<T>, ActiveListEvent<T>> {
    /**
     * Whether or not to inform subscribers of changes / record history.
     * Used in the `initialize` to temporarily stop subscriptions running
     * the initial activation, and altering the history.
     */
    private _isInitializing;
    /**
     * The `ActiveListContent` instances which the `ActiveList` holds.
     *
     * @since 1.0.0
     */
    readonly contents: ActiveListContent<T>[];
    /**
     * How many items can be active at the same time.
     *
     * When the value of `limit` is `false` there is no limit to the
     * number of active items.
     *
     * Defaults to 1.
     *
     * @since 1.0.0
     */
    maxActivationLimit: number | false;
    /**
     * How the `maxActivationLimit` is enforced. In other words what the
     * behavior should be when the limit is surpassed.
     *
     * The modes are strings which can be the following values:
     *
     * 1. 'circular': the first item which was added will be removed so
     *    the last item can be added without violating the limit. This
     *    basically means that the first one in is the first one out.
     *
     * 2. 'error': An error is thrown whenever the limit is surpassed,
     *    the error is called the `ActiveListActivationLimitReachedError`.
     *
     * 3. 'ignore': Nothing happens when an item is added and the limit
   *    is reached. The item is simply not added, but no error is
   *    thrown.
     *
     * Defaults to 'circular'.
     *
     * @since 1.0.0
     */
    maxActivationLimitBehavior: ActiveListMaxActivationLimitBehavior;
    /**
     * All `value` of the content which are currently considered active.
     *
     * @since 1.0.0
     */
    readonly active: T[];
    /**
     * All `ActiveListContent` which are currently considered active.
     *
     * @since 1.0.0
     */
    readonly activeContents: ActiveListContent<T>[];
    /**
     * All indexes of which are currently considered active.
     *
     * @since 1.0.0
     */
    readonly activeIndexes: number[];
    /**
     * Which `value` from within an `ActiveListContent` was the last
     * value which was activated.
     *
     * In other words: of all active values which value was activated
     * the last chronologically.
     *
     * When nothing is activated in the `ActiveList` the value of
     * `lastActivated` will be `null`.
     *
     * @since 1.0.0
     */
    lastActivated: T | null;
    /**
     * Which `ActiveListContent` is the last ActiveListContent which
     * was activated.
     *
     * In other words: of all active contents which content was
     * activated the last chronologically.
     *
     * When nothing is activated in the `ActiveList` the value of
     * `lastActivatedContent` will be `null`.
     *
     * @since 1.0.0
     */
    lastActivatedContent: ActiveListContent<T> | null;
    /**
     * Which index of the `contents` array was the last index which
     * was activated.
     *
     * In other words: of all active indexes which index was activated
     * the last chronologically.
     *
     * When nothing is activated in the `ActiveList` the value of
     * `lastActivatedIndex` will be `-1`.
     *
     * @since 1.0.0
     */
    lastActivatedIndex: number;
    /**
     * Which `value` from within an `ActiveListContent` was the last
     * value which was deactivated.
     *
     * When nothing was deactivated previously in the `ActiveList` the
     * value of `lastDeactivated` will be `null`.
     *
     * @since 1.5.0
     */
    lastDeactivated: T | null;
    /**
     * Which `ActiveListContent` is the last ActiveListContent which
     * was deactivated.
     *
     * When nothing was deactivated previously in the `ActiveList` the
     * value of `lastDeactivatedContent` will be `null`.
     *
     * @since 1.5.0
     */
    lastDeactivatedContent: ActiveListContent<T> | null;
    /**
     * Which index of the `contents` array was the last index which
     * was deactivated.
     *
     * When nothing was deactivated previously in the `ActiveList` the
     * value of `lastDeactivatedIndex` will be `-1`.
     *
     * @since 1.5.0
     */
    lastDeactivatedIndex: number;
    /**
     * Whether or not the content starts back at the beginning when
     * the end of the content is reached, and whether the content should
     * go to the end when moving left of the start.
     *
     * Defaults to `false`.
     *
     * @since 1.0.0
     */
    isCircular: boolean;
    /**
     * The direction the `ActiveList` has previously moved to on
     * activation or deactivation.
     *
     * Useful for when animating the `ActiveList` when wanting to
     * animate differently based on the direction the content is
     * activating towards.
     *
     * The direction is determined using the following rules for
     * activation:
     *
     * 1. When `isCircular` is `false`:
     *
     *  a. If the `lastActivatedIndex` is -1 the direction is always `next`.
     *     The `lastActivatedIndex` is -1 when no item is active.
     *
     *  b. If the `lastActivatedIndex` lies before the activated index the
     *    direction is `next`.
     *
     *  c. If the `lastActivatedIndex` lies after the activated index the
     *    direction is `previous`.
     *
     * 2. When `isCircular` is `true`,
     *
     *  a. If the `lastActivatedIndex` is -1 the direction is always `next`.
     *     The `lastActivatedIndex` is -1 when no item is active.
     *
     *  b. The direction is determined by checking which direction
     *     is the shortest path. If the shortest paths are tied, the
     *     direction will become `next`.
     *
     * Note: the direction is only changed upon activation and
     * deactivation. Removing / inserting, moving and swapping do not
     * affect the direction.
     *
     * Defaults to the value of the `Config` property `direction.next`.
     *
     * @since 1.0.0
     */
    direction: string;
    /**
     * The opposite of the `direction` property of the `ActiveList`.
     * If the `direction` is `next` the opposite direction is always
     * `previous` and vice versa.
     *
     * Defaults to the value of the `Config` property `direction.previous`.
     *
     * @since 1.5.0
     */
    oppositeDirection: string;
    private _history;
    /**
     * Contains the history of the changes in the contents array.
     *
     * Tracks 15 types of changes:
     *
     *  1. INITIALIZED: fired when ActiveList is initialized.
     *
     *  2. INSERTED: fired when an item is added.
     *
     *  3. REMOVED: fired when an item is removed.
     *
     *  4. REMOVED_MULTIPLE: fired when multiple items are removed with a predicate.
     *
     *  5. ACTIVATED: fired when an item is activated.
     *
     *  6  ACTIVATED_MULTIPLE: fired when multiple items are activated with a predicate.
     *
     *  7. DEACTIVATED: fired when an item is deactivated.
     *
     *  8. DEACTIVATED_MULTIPLE: fired when multiple items are deactivated with a predicate.
     *
     *  9. SWAPPED: fired when an item is swapped.
     *
     *  10. MOVED: fired when an item is moved.
     *
     *  11. AUTO_PLAY_PLAYING: fired when play is called.
     *
     *  12. AUTO_PLAY_PAUSED: fired when pause is called.
     *
     *  13. AUTO_PLAY_STOPPED: fired when stop is called, or the autoPlay stops due to a condition.
     *
     *  14. COOLDOWN_STARTED: fired when ActiveList goes into cooldown state
     *
     *  15. COOLDOWN_ENDED: fired when ActiveList goes out of cooldown state
     *
     * Goes only as far back as configured in the `Config` property
     * `keepHistoryFor`, to prevent an infinitely growing history.
     * Note that by default no history is kept, as `keepHistoryFor`
     * is zero by default.
     *
     * The last item in the `history` is the current active item. The
     * further to the left the further in the past you go.
     *
     * This means that a history at index 0 is further in the past than
     * an item at index 1.
     *
     * WARNING: all events store indexes, values and combinations thereof.
     * The `index` of an item in the history may no longer be accurate, it
     * is the index at the time of the event. Same goes for the `value`
     * when it is an array of object, as it might have been mutated, the
     * history items do not store copies of the values.
     *
     * @since 1.0.0
     */
    readonly history: ActiveListEvent<T>[];
    private _observer;
    /**
     * Whether or not the `active` item has changed at least once.
     * Useful when you want to know if the `ActiveList` is still
     * in its initial state.
     *
     * Note: when the `initialize` method of the `Actions` is called this
     * boolean is reset.
     *
     * @since 1.0.0
     */
    hasActiveChangedAtLeastOnce: boolean;
    private _activationCooldownTimer;
    /**
     * A Cooldown is a time period in which all user made activations
     * and deactivations are prevented / ignored. Activations and
     * deactivations where the `isUserInteraction` is set to `false`
     * always bypass the cooldown.
     *
     * The use-case is a cooldown can guarantees that animations are
     * completed, before another is triggered.
     *
     * Contains whether or not the cooldown is active via `isActive` and
     * the current duration via `duration`.
     *
     * @since 1.0.0
     */
    readonly cooldown: ActiveListCooldown;
    private _autoPlay;
    /**
     * AutoPlay means that the ActiveList will move to the next content by
     * itself after a duration.
     *
     * Contains whether or not the autoPlay is playing via `isPlaying`,
     * the current duration via `duration`, and whether or not the
     * autoPlay has been stopped before via `hasBeenStoppedBefore`
     *
     * @since 1.0.0
     */
    readonly autoPlay: ActiveListAutoPlay;
    private _directions;
    /**
     * Creates an ActiveList based on the ActiveListConfig config.
     *
     * You can also optionally provide an subscriber so you can get
     * informed of the changes happening to the ActiveList.
     *
     * @param {ActiveListConfig<T>} config The initial configuration of the ActiveList.
     * @param {ActiveListSubscriber<T> | undefined} subscriber An optional subscriber which responds to changes in the ActiveList.
     * @throws {ActiveListAutoPlayDurationError} autoPlay duration must be a positive number when defined
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @since 1.0.0
     */
    constructor(config?: ActiveListConfig<T>, subscriber?: ActiveListSubscriber<T>);
    /**
     * Subscribe to changes of the ActiveList. The function you
     * provide will get called whenever changes occur in the
     * ActiveList.
     *
     * Returns an unsubscribe function which when called will unsubscribe
     * from the ActiveList.
     *
     * @param {ActiveListSubscriber<T>} subscriber The subscriber which responds to changes in the ActiveList.
     * @returns {UnsubscribeFunction} A function which when called will unsubscribe from the ActiveList.
     *
     * @since 1.0.0
     */
    subscribe(subscriber: ActiveListSubscriber<T>): UnsubscribeFunction;
    /**
     * Unsubscribe the subscriber so it no longer receives changes / updates
     * of the state changes of the ActiveList.
     *
     * @param {ActiveListSubscriber<T>} subscriber The subscriber which you want to unsubscribe.
     *
     * @since 1.0.0
     */
    unsubscribe(subscriber: ActiveListSubscriber<T>): void;
    /**
     * Unsubscribes all subscribers at once, all subscribers will no
     * longer receives changes / updates of the state changes of
     * the ActiveList.
     *
     * @since 1.5.0
     */
    unsubscribeAll(): void;
    /**
     * Initializes the ActiveList based on the config provided. This can
     * effectively reset the ActiveList when called, including the
     * history, autoPlay and cooldown.
     *
     * @param {ActiveListConfig<T>} config The new configuration which will override the old one
     * @throws {ActiveListAutoPlayDurationError} autoPlay duration must be a positive number when defined
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @since 1.0.0
     */
    initialize(config: ActiveListConfig<T>): void;
    private _initializeABrokenContent;
    /**
     * Activates an item based on the index in the content array.
     *
     * If the index does not exist an error will be thrown.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {number} index The index to activate
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activateByIndex(index: number, activationOptions?: ActiveListActivationOptions<T>): void;
    private _doActivateByIndex;
    /**
     * Activates the given item based on identity by comparing the item
     * via a `===` check. When multiple items match on `===` only the
     * first matching item is activated.
     *
     * If the item does not exist in the content array it will
     * throw an error.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {T} item The item to activate
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activate(item: T, activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Activates all items that match the predicate.
     *
     * If no items match the predicate nothing happens.
     *
     * If multiple items were activated as a result of calling
     * `activateByPredicate` they will be activated in order of
     * appearance in the contents array.
     *
     * Items can also be deactivated if the `maxActivationLimit` is set
     * to a number and the `maxActivationLimitBehavior` is set to
     * "circular", if space needs to be made for the new activations.
     *
     * When `maxActivationLimitBehavior` is set to "error", all items
     * that can be accommodated are activated, but when the limit is
     * exceeded the activation stops. The subscribers are then informed
     * of which items were activated, and then the error is thrown.
     *
     * Even through each item is activated sequentially, only one event
     * is emitted, and one call is made to the subscribers, even if
     * multiple items are activated and deactivated.
     *
     * Within the `ActiveListActivatedMultipleEvent` only the end
     * activate / deactivate results are reported.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`. When the cooldown is configured
     * as a function, the last activated content will be the parameter
     * to the cooldown function.
     *
     * @param {ActiveListContentPredicate<T>} predicate A predicate function, when the predicate returns `true` it will activate that item.
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activateByPredicate(predicate: ActiveListContentPredicate<T>, activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Activates the next item in the sequence based on the `lastActivated`
     * ActiveListContent.
     *
     * If no `lastActivated` is present when `activateNext` is called
     * the first element is activated.
     *
     * If the `contents` are empty when `activateNext` is called
     * nothing will happen.
     *
     * When on the last position: if `isCircular` is `true` it will circle
     * around and activate the first position. When `isCircular` is `false`
     * it will stay on the last position and do nothing.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activateNext(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Activates the previous item in the sequence based on the
     * `lastActivated` ActiveListContent.
     *
     * If no `lastActivated` is present when `activatePrevious` is called
     * the first element is activated.
     *
     * If the `contents` are empty when `activatePrevious` is called
     * nothing will happen.
     *
     * When on the first position: if `isCircular` is `true` it will circle
     * around and activate the last position. When `isCircular` is `false`
     * it will stay on the first position and do nothing.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activatePrevious(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Activates the first item of the contents.
     *
     * If the `contents` are empty when `activateFirst` is called
     * nothing will happen.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activateFirst(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Activates the last item of the contents.
     *
     * If the `contents` are empty when `activateLast` is called
     * nothing will happen.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListActivationLimitReachedError} thrown when maxActivationLimit is exceeded, and maxActivationLimitBehavior is "error".
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    activateLast(activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Deactivates an item based on the index in the content array.
     *
     * If the index does not exist an error will be thrown.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {number} index The index to deactivate
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    deactivateByIndex(index: number, activationOptions?: ActiveListActivationOptions<T>): void;
    private _doDeactivateByIndex;
    /**
     * Deactivates the given item based on identity by comparing the item
     * via a `===` check. When multiple items match on `===` only the
     * first matching item is activated.
     *
     * If the item does not exist in the content array it will
     * throw an error.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {T} item The item to deactivate
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    deactivate(item: T, activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Deactivates all items that match the predicate.
     *
     * If no items match the predicate nothing happens.
     *
     * If multiple items match they will be deactivated in order of
     * appearance in the contents array. Only one call is made to the
     * subscribers, even if multiple items are deactivated.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`. When the cooldown is configured
     * as a function, the last deactivated content will be the parameter
     * to the cooldown function.
     *
     * @param {ActiveListContentPredicate<T>} predicate A predicate function, when the predicate returns `true` it will deactivate that item.
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListCooldownDurationError} cooldown duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    deactivateByPredicate(predicate: ActiveListContentPredicate<T>, activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * When calling `toggleByIndex` it will flip the `ActiveListContent`
     * which resides on the index `isActive` state .
     *
     * So when `isActive` is `true` and `toggle` is called, `isActive`
     * will become `false`. When `isActive` is `false` and `toggle` is
     * called, `isActive` will become `true`.
     *
     * If the index does not exist an error will be thrown.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {number} index The index to activate
     * @param {ActiveListActivationOptions<T>} [activationOptions] The activation options
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     *
     * @since 1.0.0
     */
    toggleByIndex(index: number, activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Toggles the given item based on identity by comparing the item
     * via a `===` check. When multiple items match on `===` only the
     * first matching item is activated.
     *
     * So when `isActive` is `true` and `toggle` is called, `isActive`
     * will become `false`. When `isActive` is `false` and `toggle` is
     * called, `isActive` will become `true`.
     *
     * If the item does not exist in the content array it will
     * throw an error.
     *
     * With the `activationOptions` you can determine the effects
     * on `cooldown` and `autoPlay`.
     *
     * @param {T} item The item to toggle
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     *
     * @since 1.0.0
     */
    toggle(item: T, activationOptions?: ActiveListActivationOptions<T>): void;
    /**
     * Will start playing the ActiveList based on the active
     * autoPlayConfig. When `autoPlayConfig` is not defined nothing
     * will happen when calling play.
     *
     * When there is no more content the playing will stop automatically.
     *
     * Note: autoPlay will only start when one or more contents are
     * currently active. The reason for this is that the `duration`, is
     * based on the `ActiveList` `lastActivatedContent` property.
     * Whenever there are no more items to activate the autoPlay will
     * stop.
     *
     * @throws {ActiveListAutoPlayDurationError} autoPlay duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    play(): void;
    /**
     * When the ActiveList is playing it will pause the autoPlay.
     *
     * When paused, the current autoPlay duration is remember and resumed
     * from that position, when `play` is called again.
     *
     * For example: when the duration is 1 second and the `pause` is
     * called after 0.8 seconds, it will after `play` is called, take
     * 0.2 seconds to go to the next content.
     *
     * Note: if the autoPlay is already paused calling `pause` again
     * will do nothing, the time used for the remaining duration is
     * based on the first pause.
     *
     * @since 1.0.0
     */
    pause(): void;
    /**
     * When the ActiveList is playing it will stop the autoPlay.
     *
     * By calling `play` again it is possible to restart the autoPlay.
     * However the duration will behave in this scenario as it if was
     * reset.
     *
     * For example: when the duration is 1 second and the `stop` is
     * called after 0.8 seconds, it will after `play` is called, take
     * 1 second to go to the next content.
     *
     * @since 1.0.0
     */
    stop(): void;
    /**
     * Configures the autoPlay, when the autoPlay is `null` the autoPlay
     * is stopped.
     *
     * Can be used to reconfigure the speed of the autoPlay after the
     * ActiveList has been created.
     *
     * Note: calling `configureAutoPlay` will not set (reset) the
     * hasBeenStoppedBefore` to `false` when called.
     *
     * @param {ActiveListAutoPlayConfig<T> | null} autoPlayConfig The new autoPlay configuration
     * @throws {ActiveListAutoPlayDurationError} autoPlay duration must be a positive number when defined
     *
     * @since 1.0.0
     */
    configureAutoPlay(autoPlayConfig: ActiveListAutoPlayConfig<T> | null): void;
    /**
     * Will add an item to the `contents` array, at the specified `index`.
     *
     * Note: `insertAtIndex` will not allow holes to be created, this
     * means that the index can only be between `0` and `contents.length`.
     * If you give it a larger or smaller index it will throw an error.
     *
     * @param {T} item The item to insert.
     * @param {number} index The index at which to insert the item.
     * @returns {ActiveListContent<T>} The newly inserted item wrapped in an `ActiveListContent`
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     *
     * @since 1.0.0
     */
    insertAtIndex(item: T, index: number): ActiveListContent<T>;
    /**
     * Will add an item to the end of the `contents` array.
     *
     * @param {T} item The item to insert.
     * @returns {ActiveListContent<T>} The newly inserted item wrapped in an `ActiveListContent`
     *
     * @since 1.0.0
     */
    push(item: T): ActiveListContent<T>;
    /**
     * Will add an item at the start of the `contents` array.
     *
     * @param {T} item The item to insert.
     * @returns {ActiveListContent<T>} The newly inserted item wrapped in an `ActiveListContent`
     *
     * @since 1.0.0
     */
    unshift(item: T): ActiveListContent<T>;
    /**
     * Will add an item at the position in the `contents` array when when
     * the predicate returns `true` for the `item` and `index`.
     *
     * If no item matches the predicate nothing is inserted and `null`
     * will be returned.
     *
     * The position to where the `ActiveListContent` is inserted can be altered by
     * providing a mode:
     *
     *  1. When the mode is 'at', the `ActiveListContent` is inserted to the
     *     position where the predicate matches. This is the `default`
     *     mode.
     *
     *  2. When the mode is 'after', the `ActiveListContent` is inserted to after
     *     the position where the predicate matches.
     *
     *  3. When the mode is 'before', the `ActiveListContent` is inserted to
     *     before the position where the predicate matches.
     *
     * @param {T} item The item to insert.
     * @param {ActiveListContentPredicate<T>} predicate A predicate function, when the predicate returns `true` it will move the item to that position.
     * @param {ActiveListPredicateOptions} options The options for the predicate, when no options are provided the mode will default to "at".
     *
     * @since 1.0.0
     */
    insertByPredicate(item: T, predicate: ActiveListContentPredicate<T>, options?: ActiveListPredicateOptions): ActiveListContent<T> | null;
    /**
     * Will remove an item in the `contents` array, at the specified `index`.
     *
     * If you remove the `lastDeactivated` item it will be set to null.
     *
     * Throws an error if the index does not exist within the `contents`
     * array.
     *
     * @param {number} index The index at which to remove the item.
     * @returns {T} The removed value
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     *
     * @since 1.0.0
     */
    removeByIndex(index: number): T;
    private _doRemoveAtIndex;
    /**
     * Removes the given item based on identity by comparing the item
     * via a `===` check. When multiple items match on `===` only the
     * first matching item is removed.
     *
     * If you remove the `lastDeactivated` item it will be set to null.
     *
     * If the item does not exist in the content array it will
     * throw an error.
     *
     * @param {T} item The item to remove
     * @returns {T} The removed item
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     *
     * @since 1.0.0
     */
    remove(item: T): T;
    /**
     * Removes the last item of the of the `contents` array.
     *
     * If you remove the `lastDeactivated` item it will be set to null.
     *
     * If the `contents` array at the time of the `pop` is empty
     * `undefined` is returned.
     *
     * @param {ActiveListActivationOptions<T>} ActiveListActivationOptions The activation options
     * @returns {T | undefined} The removed value, or undefined if the `contents` array is empty.
     *
     * @since 1.0.0
     */
    pop(): T | undefined;
    /**
     * Removes the first item of the `contents` array.
     *
     * If you remove the `lastDeactivated` item it will be set to null.
     *
     * If the `contents` array at the time of the `shift` is empty
     * `undefined` is returned.
     *
     * @returns {T | undefined} The removed value, or undefined if the `contents` array is empty.
     *
     * @since 1.0.0
     */
    shift(): T | undefined;
    /**
     * Will remove all items from the `contents` array for which the
     * predicate based on the `item` and `index` returns `true`.
     *
     * If no item matches the predicate nothing is removed and an empty
     * array will be returned.
     *
     * If you remove the `lastDeactivated` item it will be set to null.
     *
     * @param {T} item The item to insert.
     * @param {ActiveListContentPredicate<T>} predicate A predicate function, when the predicate returns `true` it will remove the item.
     * @returns {T[]} The removed items.
     *
     * @since 1.0.0
     */
    removeByPredicate(predicate: ActiveListContentPredicate<T>): T[];
    /**
     * Swaps the `ActiveListContent` at index a, with the `ActiveListContent` at index b.
     *
     * Note: if the active `ActiveListContent` is swapped, it will stay active,
     * it will only get a new position.
     *
     * @param {number} a The first index to swap.
     * @param {number} b The second index to swap.
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     *
     * @since 1.0.0
     */
    swapByIndex(a: number, b: number): void;
    /**
     * Swaps the `ActiveListContent` with item a, with the `ActiveListContent` with
     * item b. Swaps the items based on identity by comparing the items
     * via a `===` check. When multiple items match on `===` only the
     * first matching item is swapped.
     *
     * Note: if the active `ActiveListContent` is swapped, it will stay active,
     * it will only get a new position.
     *
     * @param {T} a The first item to swap.
     * @param {T} b The second item to swap.
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     *
     * @since 1.0.0
     */
    swap(a: T, b: T): void;
    /**
     * Moves the `ActiveListContent` at index "from", to the position at index "to".
     *
     * It is possible to move the `ActiveListContent` to the last place by making
     * the "to" index the length of the `contents` array.
     *
     * Note: if the active `ActiveListContent` is moved it will stay active,
     * meaning that the lastActivatedIndex will get updated.
     *
     * @param {number} from The "from" index which needs to be moved
     * @param {number} to The location the `from` needs to move "to".
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     *
     * @since 1.0.0
     */
    moveByIndex(from: number, to: number): void;
    /**
     * Moves the item, to the position at index "to".
     *
     * It is possible to move the `ActiveListContent` to the last place by making
     * the "to" index the length of the `contents` array.
     *
     * Note: if the active `ActiveListContent` is moved it will stay active,
     * meaning that the lastActivatedIndex will get updated.
     *
     * @param {T} item The item to move
     * @param {number} to The location the `item` needs to move "to".
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     * @throws {ActiveListIndexOutOfBoundsError} index cannot be out of bounds
     *
     * @since 1.0.0
     */
    move(item: T, to: number): void;
    /**
     * Moves the `ActiveListContent`, at the index, to the position of the
     * item for which the predicate returns `true`.
     *
     * If no item matches the predicate nothing is moved.
     *
     * The position to where the `ActiveListContent` moves can be altered by
     * providing a mode:
     *
     *  1. When the mode is 'at', the `ActiveListContent` is moved to the position
     *     where the predicate matches. This is the `default` mode.
     *
     *  2. When the mode is 'after', the `ActiveListContent` is moved to after the
     *     position where the predicate matches.
     *
     *  3. When the mode is 'before', the `ActiveListContent` is moved to before
     *     the position where the predicate matches.
     *
     * @param {number} index The index to move.
     * @param {ActiveListContentPredicate<T>} predicate A predicate function, when the predicate returns `true` it will move the item to that position.
     * @param {ActiveListPredicateOptions} options The options for the predicate, when no options are provided the mode will default to "at".
     *
     * @since 1.0.0
     */
    moveByIndexByPredicate(index: number, predicate: ActiveListContentPredicate<T>, options?: ActiveListPredicateOptions): void;
    /**
     * Moves the `ActiveListContent` which matches the value of the item based
     * on `===` equality. To the position of the item for which
     * the predicate returns `true`.
     *
     * When multiple items match on `===` only the first matching item is moved.
     *
     * If no item matches the predicate nothing is moved.
     *
     * The position to where the `ActiveListContent` moves can be altered by
     * providing a mode:
     *
     *  1. When the mode is 'at', the `ActiveListContent` is moved to the position
     *     where the predicate matches. This is the `default` mode.
     *
     *  2. When the mode is 'after', the `ActiveListContent` is moved to after the
     *     position where the predicate matches.
     *
     *  3. When the mode is 'before', the `ActiveListContent` is moved to before
     *     the position where the predicate matches.
     *
     * @param {T} item The item to move.
     * @param {ActiveListContentPredicate<T>} predicate A predicate function, when the predicate returns `true` it will move the item to after that position.
     * @param {ActiveListPredicateOptions} options The options for the predicate, when no options are provided the mode will default to "at".
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     *
     * @since 1.0.0
     */
    moveByPredicate(item: T, predicate: ActiveListContentPredicate<T>, options?: ActiveListPredicateOptions): void;
    /**
     * Gets the index for a given item.
     *
     * If the item does not exist in the content array it will
     * throw an error.
     *
     * @param {T} item The item to get the index for.
     * @returns {number} The index of the given item.
     * @throws {ActiveListItemNotFoundError} item must be in the contents array based on === equality
     *
     * @since 1.0.0
     */
    getIndex(item: T): number;
    /**
     * Returns the final index available in the contents array.
     *
     * @returns {number} The last index of the contents array.
     *
     * @since 1.0.0
     */
    getLastIndex(): number;
    _getBoundedNextIndex(index: number): number;
    _getBoundedPreviousIndex(index: number): number;
    _getUnboundedNextIndex(index: number): number;
    _getUnboundedPreviousIndex(index: number): number;
    /**
     * Whether or not the contents is an empty array.
     *
     * @since 1.0.0
     */
    isEmpty(): boolean;
    private _getDirectionWhenMovingToIndex;
    private _repairContents;
    private _repairContent;
    private _emptyLastActives;
    private _emptyLastDeactivated;
    private _becameEmpty;
    private _setLastActives;
    private _deactivateContent;
    private _execPred;
    _inform(event: ActiveListEvent<T>): void;
    private _checkIndex;
    private _modeToMod;
}

/**
 * The configuration for the `createActiveListSubscriber` function.
 *
 * You should provide all methods for the events that you want to
 * listen to, the ones you are not interested
 *
 * @since 1.5.0
 */
type CreateActiveListSubscriberConfig<T> = {
    /**
     * Optionally whether or not you want to show debug logging.
     *
     * When `debug` is enabled whenever an event method is not provided
     * but the event is fired, a `console.warn` message is logged. This
     * allows you to easier detect missing methods during development.
     *
     * Defaults to `false`, meaning nothing will be logged to the console.
     *
     * @since 1.5.0
     */
    debug?: boolean;
    /**
     * Method which is called whenever an `MOVED` event is fired
     * from within the ActiveList.
     *
     * @param {ActiveListMovedEvent<T>} event The event that was fired.
     * @param {ActiveList<T>} activeList The ActiveList the event was fired from
     * @since 1.5.0
     */
    onMoved?: (event: ActiveListMovedEvent<T>, activeList: ActiveList<T>) => void;
    /**
     * Method which is called whenever an `INSERTED` event is fired
     * from within the ActiveList.
     *
     * @param {ActiveListMovedEvent<T>} event The event that was fired.
     * @param {ActiveList<T>} activeList The ActiveList the event was fired from
     * @since 1.5.0
     */
    onInserted?: (event: ActiveListInsertedEvent<T>, activeList: ActiveList<T>) => void;
    /**
     * Method which is called whenever an `INITIALIZED` event is fired
     * from within the ActiveList.
     *
     * @param {ActiveListMovedEvent<T>} event The event that was fired.
     * @param {ActiveList<T>} activeList The ActiveList the event was fired from
     * @since 1.5.0
     */
    onInitialized?: (event: ActiveListInitializedEvent<T>, activeList: ActiveList<T>) => void;
    /**
     * Method which is called whenever an `COOLDOWN_STARTED` event is
     * fired from within the ActiveList.
     *
     * @param {ActiveListMovedEvent<T>} event The event that was fired.
     * @param {ActiveList<T>} activeList The ActiveList the event was fired from
     * @since 1.5.0
     */
    onCooldownStarted?: (event: ActiveListCooldownStartedEvent, activeList: ActiveList<T>) => void;
    /**
     * Method which is called whenever an `COOLDOWN_ENDED` event is
     * fired from within the ActiveList.
     *
     * @param {ActiveListMovedEvent<T>} event The event that was fired.
     * @param {ActiveList<T>} activeList The ActiveList the event was fired from
     * @since 1.5.0
     */
    onCooldownEnded?: (event: ActiveListCooldownEndedEvent, activeList: ActiveList<T>) => void;
    /**
     * Method which is called whenever an `AUTO_PLAY_STOPPED` event is
     * fired from within the ActiveList.
     *
     * @param {ActiveListMovedEvent<T>} event The event that was fired.
     * @param {ActiveList<T>} activeList The ActiveList the event was fired from
     * @since 1.5.0
     */
    onAutoPlayStopped?: (event: ActiveListAutoPlayStoppedEvent, activeList: ActiveList