import { EventSchema } from '../../schemas/Event';
import { EventId } from 'teambition-types';
export declare type Timeframe = {
    startDate: Date;
    endDate: Date;
};
export interface DateInfo {
    startDate: string;
    endDate: string;
    recurrence?: string[];
}
export declare type InstanceCreator<T> = (source: T, timeframe?: Timeframe) => T;
export declare class RecurrenceFactory<T extends DateInfo> implements IterableIterator<T | undefined> {
    readonly type: string;
    protected readonly source: T;
    private startDateCursor;
    private done;
    private readonly makeInst;
    private duration;
    private isRecurrence;
    private rruleSet;
    [Symbol.iterator]: () => this;
    protected constructor(source: T, type: string, makeInst: InstanceCreator<T>);
    protected makeInstance(timeframe?: Timeframe): T;
    isRecurrent(): boolean;
    next(): IteratorResult<T | undefined>;
    private getOneTimeframeAfter;
    private takePred;
    private slice;
    takeUntil(startDateUntil: Date, endDateUntil?: Date): T[];
    takeFrom(fromDate: Date, startDateTo: Date, endDateTo?: Date): T[];
    after(date: Date): T | null;
    findByTimestamp(timestamp: number): T | null;
}
export declare class EventGenerator extends RecurrenceFactory<EventSchema> {
    private static makeInst;
    constructor(event: EventSchema);
    findByEventId(eventId: EventId): EventSchema | null;
}
export declare class Recurrence extends RecurrenceFactory<DateInfo> {
    private static makeInst;
    constructor(dateInfo: DateInfo);
}