import { DeviceResponseType, DeviceTaskType } from "../Devices/IDevice";
import { DeviceControlFeature, IDeviceTask } from "../Devices/IDeviceTask";
import { AstronomicalClockWithOffsetArgument, DayOfWeekArgument, DeviceStateArgument, DeviceStateComparisonMethod, SimpleTimeSpanArgument, TimeArgument } from "./LeftArgumentTypes";
import { DelayTask, LockExecutionTask, NotifyTask } from "./SceneTaskTypes";
import { ConditionsTypes, DeviceStateType, HandledType, IRawSequence, ISequence, ISequenceInfo, SceneTaskTypeNum, SupportedTaskTypes } from "./Scenes";
export declare class SequenceBuilder {
    protected _result: SequenceRequestData | null;
    protected _tmp: SequenceRequestData;
    protected _tmpTask: ControllerTaskRequestData | null;
    private _service;
    private _prevSeqGuid;
    private _currentSeqGuid;
    private _editingExistingSequence;
    private _rawExistingSequenceTasks;
    private _sequenceName;
    private _sequenceIcon;
    constructor(sequenceName?: string, sequenceIcon?: string);
    /**
     * Sets current (new or in edit) sequence name
     * @param name name
     */
    SetSequenceName(name: string): void;
    /**
     * Sets current (new or in edit) sequence icon
     * @param icon icon
     */
    SetSequenceIcon(icon: string): void;
    /**
     * Gets next sequence from sequence chain
     */
    GetNext(): ISequence | null;
    /**
     * Method allows to clone builder with all sqeuence atributes and tasks.
     * Function re-generate all guids in chain and reset navigation to first element.
     * @returns cloned builder (new object)
     */
    CloneCurrentBuilder(): SequenceBuilder;
    /**
     * Gets previous sequence from sequence chain
     */
    GetPrevious(): ISequence | null;
    /**
     * Gets sequence by guid
     * @param sequenceGuid sequence guid
     */
    GetByGuid(sequenceGuid: string): ISequence | null;
    EditCurrentSequence(sequence: IRawSequence): EditSequence;
    /**
     * Function creates argument of type AstronomicalClockWithOffse in the argument chain
     * @param arg
     * @returns function that adds argument to end of chain
     */
    ArgumentAsAstronomicalClockWithOffset(arg: AstronomicalClockWithOffsetArgument, atMeetCondition: boolean, comparasion?: ConditionsTypes): AddOrEditArgument;
    ArgumentAsActionWithEmptyCondition(): AddOrEditArgument;
    /**
     * Function creates argument of type DayOfWeekArgument in the argument chain
     * @param arg
     * @param atMeetCondition
     * @param comparison
     * @returns function that adds argument to end of chain
     */
    ArgumentAsDaysOfWeek(arg: DayOfWeekArgument[], atMeetCondition: boolean, comparison?: ConditionsTypes): AddOrEditArgument;
    /**
     * Function creates argument of type SimpleTimeSpanArgument in the argument chain
     * @param arg
     * @param comparison
     * @returns function that adds argument to end of chain
     */
    ArgumentAsTimeSpan(arg: SimpleTimeSpanArgument, comparison?: ConditionsTypes): AddOrEditArgument;
    /**
     * Function creates argument of type ArgumentAsTime in the argument chain
     * @param arg
     * @param atMeetCondition
     * @param comparison
     * @returns function that adds argument to end of chain
     */
    ArgumentAsTime(arg: TimeArgument, atMeetCondition: boolean, comparison?: ConditionsTypes): AddOrEditArgument;
    /**
     * Function creates argument of type DeviceStateArgument in the argument chain
     * @param arg
     * @param atMeetCondition
     * @param atMeetConditionTimeout
     * @param comparison
     * @returns function that adds argument to end of chain
     */
    ArgumentAsDeviceState(arg: DeviceStateArgument, atMeetCondition: boolean, atMeetConditionTimeout: number, comparison?: ConditionsTypes): AddOrEditArgument;
    /**
     * Function creates argument of type ArgumentAsSceneExecuted - this argument waits until given scene will be executed, then returns 'true' and allow to execute check rest of arguments in chain.
     * @param arg
     */
    ArgumentAsSceneExecuted(arg: ISequenceInfo): AddOrEditArgument;
    protected GenerateDeviceStateArgument(arg: DeviceStateArgument): LeftArgumentDeviceStateRequestData;
    protected MapResponseTypeToDeviceStateType(responseType: DeviceResponseType): DeviceStateType;
    /**
     * Function adds argument to the end of argument chain
     * @returns Functions that coud create another argument, function that coud commit argument chain, current argument data.
     */
    protected AddSequence(): Commit;
    protected EditSequence(sequenceGuid: string): Commit;
    RemoveSequenceByGuid(sequenceGuid: string): Commit;
    /**
     * Functions commits modifications of arguments chain
     * @returns
     */
    Commit(): AddOrRemoveTasks;
    protected DeviceTask(task: IDeviceTask): AddOrEditTask;
    private ParseDeviceTask;
    protected DelayTask(delay: DelayTask): AddOrEditTask;
    protected NotifyTask(notification: NotifyTask): AddOrEditTask;
    protected LockExecutionTask(lockTask: LockExecutionTask): AddOrEditTask;
    private AddTask;
    protected EditTask(taskId: string): AddOrRemoveTasks;
    protected RemoveTask(taskId: string): void;
    protected MapTaskTypeToControlFeature(taskType: DeviceTaskType): DeviceControlFeature;
    protected GetSupportedTaskTypesAsync(): Promise<SupportedTaskTypes[]>;
    /**
     * Function builds SequenceRequestData object, this obj. can be send via API to controller to modify or add sequence
     * SequenceRequestData should be pass to EditSequenceAsync(sequence: SequenceRequestData) or CreateSequenceAsync(sequence: SequenceRequestData) methods in ScenesService;
     * @returns
     */
    protected Build(): SequenceRequestData;
    private FindArgumentWithGuid;
    /**
     * Function returns allowed arguments for current context
     */
    GetAllowedArguments(): ArgumentParams[];
    /**
     * Function validate entire sequence and returns validation result
     * If sequence is invalid or needs to be optimized, we can fix it by TryFix() method or ignore validation by Ignore() method
    */
    protected ValidateScene(): SceneValidation;
    private TryFix;
}
export type EditSequence = {
    GetNext: () => ISequence | null;
    GetPrevious: () => ISequence | null;
    GetByGuid: (sequenceGuid: string) => ISequence | null;
    GetAllowedArguments: () => ArgumentParams[];
    RemoveSequence: (sequenceGuid: string) => Commit;
    ArgumentAsAstronomicalClockWithOffset: (arg: AstronomicalClockWithOffsetArgument, atMeetCondition: boolean, comparasion?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsDaysOfWeek: (arg: DayOfWeekArgument[], atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsTimeSpan: (arg: SimpleTimeSpanArgument, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsTime: (arg: TimeArgument, atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsDeviceState: (arg: DeviceStateArgument, atMeetCondition: boolean, atMeetConditionTimeout: number, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsSceneExecuted: (arg: ISequenceInfo) => AddOrEditArgument;
    RemoveTask: (taskGuid: string) => void;
};
export type AddOrEditArgument = {
    AddArgument: () => Commit;
    EditArgument: (sequenceArgumentGuid: string) => Commit;
};
export type Commit = {
    SequenceData: ISequence | null;
    GetNext: () => ISequence | null;
    GetPrevious: () => ISequence | null;
    GetByGuid: (sequenceGuid: string) => ISequence | null;
    GetAllowedArguments: () => ArgumentParams[];
    RemoveSequenceByGuid: (sequenceGuid: string) => Commit;
    Commit: () => AddOrRemoveTasks;
    ArgumentAsActionWithEmptyCondition: () => AddOrEditArgument;
    ArgumentAsAstronomicalClockWithOffset: (arg: AstronomicalClockWithOffsetArgument, atMeetCondition: boolean, comparasion?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsDaysOfWeek: (arg: DayOfWeekArgument[], atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsTimeSpan: (arg: SimpleTimeSpanArgument, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsTime: (arg: TimeArgument, atMeetCondition: boolean, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsDeviceState: (arg: DeviceStateArgument, atMeetCondition: boolean, atMeetConditionTimeout: number, comparison?: ConditionsTypes) => AddOrEditArgument;
    ArgumentAsSceneExecuted: (arg: ISequenceInfo) => AddOrEditArgument;
};
export type AddOrRemoveTasks = {
    GetSupportedTypesOfTasks: () => Promise<SupportedTaskTypes[]>;
    DeviceTask: (task: IDeviceTask) => AddOrEditTask;
    DelayTask: (delay: DelayTask) => AddOrEditTask;
    NotifyTask: (notification: NotifyTask) => AddOrEditTask;
    LockExecutionTask: (lockTask: LockExecutionTask) => AddOrEditTask;
    RemoveTask: (taskId: string) => void;
    ValidateScene: () => SceneValidation;
    Build: () => SequenceRequestData;
    BuildToISequence: () => ISequence;
};
export type SceneValidation = {
    IsValid: boolean;
    Errors: ValidationErrors[];
    TryFix: () => AddOrRemoveTasks;
    Ignore: () => AddOrRemoveTasks;
};
export declare enum ValidationErrors {
    OptimizeDayOfWeekArgument = "OptimizeDayOfWeekArgument",
    OptimizeAtInDayOfWeekArgument = "OptimizeAtInDayOfWeekArgument"
}
export declare class ArgumentParams {
    ArgumentType: SupportedArgumentTypes;
    InitialAtMeetConditionValue: boolean;
    ChangableAtMeetCondition: boolean;
}
export declare enum SupportedArgumentTypes {
    Unknown = "Unknown",
    ArgumentAsAstronomicalClockWithOffset = "ArgumentAsAstronomicalClockWithOffset",
    ArgumentAsDaysOfWeek = "ArgumentAsDaysOfWeek",
    ArgumentAsTimeSpan = "ArgumentAsTimeSpan",
    ArgumentAsTime = "ArgumentAsTime",
    ArgumentAsDeviceState = "ArgumentAsDeviceState",
    ArgumentAsSceneExecuted = "ArgumentAsSceneExecuted"
}
export type AddOrEditTask = {
    AddTask: () => AddOrRemoveTasks;
    EditTask: (taskGuid: string) => AddOrRemoveTasks;
    TaskId: string;
};
export declare class SequenceRequestData {
    Tasks: TasksRequestData;
    Guid: string;
    ObjectType: number;
    Name: string;
    Icon: string;
    AtMeetCondition: boolean;
    ExecuteOnce: boolean;
    IsDisabled: boolean;
    HandledType: HandledType;
    ConditionType: ConditionsTypes;
    ConditionTimeout: number;
    LeftArgumentType: ArgumentTypeNum;
    RightArgumentType: ArgumentTypeNum;
    LeftArgument: LeftArgumentRequestData;
    RightArgument: SequenceRequestData | EmptySequenceRequestData;
}
declare class EmptySequenceRequestData {
    HandledType: number;
    Argument: null;
}
declare class LeftArgumentRequestData {
    constructor(argument: any, handledType: ArgumentTypeNum);
    Argument: any;
    HandledType: ArgumentTypeNum;
}
declare class LeftArgumentDeviceStateRequestData {
    DeviceStateType: DeviceStateType;
    Channel: number;
    DeviceGuid: string;
    ComparisonMethod: DeviceStateComparisonMethod;
    ComparisonParams: any;
    CheckedDeviceState: any;
}
declare class TasksRequestData {
    ControllerTasks: ControllerTaskRequestData[];
    DevicesTasks: DeviceTaskRequestData[];
}
declare class ControllerTaskRequestData {
    Guid: string;
    RunParallel: boolean;
    TaskType: SceneTaskTypeNum;
}
declare class DeviceTaskRequestData extends ControllerTaskRequestData {
    TaskType: SceneTaskTypeNum;
    DeviceGuid: string;
    Channel: number;
    ControlFeature: DeviceControlFeature;
    Data: any;
}
declare enum ArgumentTypeNum {
    Null = 0,
    Condition = 1,
    ConditionGroup = 2,
    ArgumentAsInt = 3,
    ArgumentAsTimeSpan = 4,
    ArgumentAsBoolean = 5,
    ArgumentAsTimeout = 6,
    ArgumentAsDayOfWeek = 7,
    ArgumentAsDaysOfWeek = 8,
    ArgumentAsAstronomicalClock = 9,
    ArgumentAsTime = 10,
    ArgumentAsDeviceState = 11,
    ArgumentAsNumber = 12,
    ArgumentAsAstronomicalClockWithOffset = 13,
    ArgumentAsConditionInfo = 14
}
export declare class BadParametersScenesBuilderException extends Error {
    message: string;
    constructor(message: string);
}
export declare class SequenceNotFoundScenesBuilderException extends Error {
    message: string;
    constructor(message: string);
}
export declare class TaskNotFoundScenesBuilderException extends Error {
    message: string;
    constructor(message: string);
}
export declare class UnsupportedArgumentScenesBuilderException extends Error {
    message: string;
    constructor(message: string);
}
export {};