import { DateAdapter } from '../date-adapter';
import { DateTime } from '../date-time';
import { IOccurrenceGenerator, IRunnable } from '../interfaces';
import { DateInput } from '../utilities';
declare const OPERATOR_ID: unique symbol;
export declare abstract class Operator<T extends typeof DateAdapter> implements IRunnable<T> {
    readonly _streams: IOccurrenceGenerator<T>[];
    protected config: IOperatorConfig<T>;
    static isOperator(object: unknown): object is Operator<any>;
    readonly isInfinite: boolean;
    readonly hasDuration: boolean;
    readonly timezone: string | null;
    /** Returns the first occurrence or, if there are no occurrences, null. */
    readonly firstDate: InstanceType<T> | null;
    /** If generator is infinite, returns `null`. Otherwise returns the end date */
    readonly lastDate: InstanceType<T> | null;
    protected readonly [OPERATOR_ID] = true;
    constructor(_streams: IOccurrenceGenerator<T>[], config: IOperatorConfig<T>);
    abstract set(prop: 'timezone', value: string | null, options?: {
        keepLocalTime?: boolean;
    }): Operator<T>;
    protected abstract calculateIsInfinite(): boolean;
    protected abstract calculateHasDuration(): boolean;
    protected normalizeDateInput(date: DateInput<T>): DateTime;
    protected normalizeDateInput(date?: DateInput<T>): undefined;
    protected normalizeRunOutput(date: DateTime): DateTime;
}
export declare type OperatorFn<T extends typeof DateAdapter> = () => OperatorFnOutput<T>;
export declare type OperatorFnOutput<T extends typeof DateAdapter> = (options: IOperatorConfig<T>) => Operator<T>;
export interface IOperatorConfig<T extends typeof DateAdapter> {
    dateAdapter: T;
    timezone: string | null;
    base?: IRunnable<T>;
}
export {};
//# sourceMappingURL=interface.d.ts.map