import * as i0 from '@angular/core';
import { AfterViewInit, EventEmitter, ElementRef, ChangeDetectorRef, OnChanges, OnInit, OnDestroy, NgZone, SimpleChanges, PipeTransform, ViewContainerRef } from '@angular/core';
import * as i34 from 'ng-zorro-antd/select';
import { NzSelectComponent } from 'ng-zorro-antd/select';
import { HttpErrorResponse, HttpClient, HttpResponse } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable, Subject, Subscription } from 'rxjs';
import * as i41 from 'ng-zorro-antd/code-editor';
import { EditorOptions } from 'ng-zorro-antd/code-editor';
import * as i36 from 'ng-zorro-antd/modal';
import { NzModalService, NzModalRef } from 'ng-zorro-antd/modal';
import { NzNotificationService } from 'ng-zorro-antd/notification';
import * as i28 from 'ng-zorro-antd/button';
import { NzButtonType } from 'ng-zorro-antd/button';
import * as i27 from 'ng-zorro-antd/table';
import { NzTableComponent } from 'ng-zorro-antd/table';
import { NzConfigService } from 'ng-zorro-antd/core/config';
import * as i38 from 'ng-zorro-antd/graph';
import { NzGraphData, NzRankDirection, NzGraphComponent, NzGraphZoomDirective, NzGraphLayoutConfig } from 'ng-zorro-antd/graph';
import * as i24 from '@angular/forms';
import { FormGroup, ControlValueAccessor, FormBuilder } from '@angular/forms';
import { OnChangeType, OnTouchedType } from 'ng-zorro-antd/core/types';
import * as i40 from 'ng-zorro-antd/collapse';
import { NzCollapsePanelComponent } from 'ng-zorro-antd/collapse';
import * as i23 from '@angular/common';
import * as i12 from '@angular/router';
import { ActivatedRoute, Router } from '@angular/router';
import * as i26 from '@swimlane/ngx-charts';
import * as i29 from 'ng-zorro-antd/space';
import * as i30 from 'ng-zorro-antd/icon';
import * as i31 from 'ng-zorro-antd/divider';
import * as i32 from 'ng-zorro-antd/dropdown';
import * as i33 from 'ng-zorro-antd/input';
import * as i35 from 'ng-zorro-antd/auto-complete';
import * as i37 from 'ng-zorro-antd/grid';
import * as i39 from 'ng-zorro-antd/alert';
import * as i42 from 'ng-zorro-antd/form';
import * as i43 from 'ng-zorro-antd/checkbox';
import * as i44 from 'ng-zorro-antd/spin';
import * as i45 from 'ng-zorro-antd/descriptions';
import * as i46 from 'ng-zorro-antd/tooltip';
import * as i47 from 'ng-zorro-antd/comment';
import * as i48 from 'ng-zorro-antd/avatar';
import * as i49 from 'ng-zorro-antd/list';
import * as i50 from 'ng-zorro-antd/switch';
import * as i51 from 'ng-zorro-antd/page-header';
import * as i52 from 'ng-zorro-antd/result';

declare class InputTagsComponent implements AfterViewInit {
    private _cd;
    rawTags: string[];
    set value(values: string[]);
    placeholder: string;
    update: EventEmitter<Array<string>>;
    selectComponent: NzSelectComponent;
    inputTag: ElementRef;
    filteredTags: string[];
    currentTag: string;
    inputTagValid: boolean;
    values: string[];
    constructor(_cd: ChangeDetectorRef);
    addItem(): void;
    onSelectedTagsChange(data: Array<string>): void;
    emitValuesChanged(): void;
    onSelectOpen(state: boolean): void;
    onChangeTagInput(value: string): void;
    updateInputTagValidity(): void;
    onKeyDownTagInput(e: KeyboardEvent): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputTagsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputTagsComponent, "lib-utask-input-tags", never, { "rawTags": { "alias": "rawTags"; "required": false; }; "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "update": "update"; }, never, never, false, never>;
}

declare class ErrorMessageComponent implements OnChanges {
    private _cd;
    data: HttpErrorResponse | string;
    text: string;
    constructor(_cd: ChangeDetectorRef);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorMessageComponent, "lib-utask-error-message", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LoaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "utask-loader", never, {}, {}, never, never, false, never>;
}

declare class VMTaskState {
    label: string;
    color: string;
    value: number;
    key: string;
}
declare class ChartTaskStatesComponent implements OnChanges {
    data: VMTaskState[];
    dataset: any[];
    view: any[];
    colorScheme: {
        domain: any[];
    };
    constructor();
    ngOnChanges(): void;
    generateChart(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartTaskStatesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChartTaskStatesComponent, "lib-utask-chart-task-states", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Template {
    name: string;
    description: string;
    long_description: string;
    blocked: boolean;
    auto_runnable: boolean;
    allow_all_resolver_usernames: boolean;
    allow_task_start_over: boolean;
    allowed_resolver_usernames: string[];
    allowed_resolver_groups: string[];
    doc_link: string;
    inputs: any[];
    resolver_inputs: any[];
    steps?: any[];
}

declare class ResolutionStep {
    action: any;
    children: any[];
    children_steps: string[];
    children_steps_map: {
        [map: string]: boolean;
    };
    conditions: any[];
    custom_states: string[];
    dependencies: string[];
    description: string;
    error: string;
    foreach: string;
    idempotent: boolean;
    json_schema: any[];
    last_run: Date;
    max_retries: number;
    name: string;
    resources: string[];
    retry_pattern: string;
    state: string;
    tags: {
        [tag: string]: boolean;
    };
    try_count: number;
}
declare enum TaskType {
    all = "all",
    own = "own",
    resolvable = "resolvable"
}
declare enum TaskState {
    BLOCKED = "BLOCKED",
    CANCELLED = "CANCELLED",
    DONE = "DONE",
    RUNNING = "RUNNING",
    TODO = "TODO",
    WONTFIX = "WONTFIX",
    WAITING = "WAITING",
    DELAYED = "DELAYED"
}
declare class Comment {
    content: string;
    created: Date;
    id: string;
    updated: Date;
    username: string;
}
declare class Error {
    error: string;
    step: string;
}
declare class ResolverInput {
    name: string;
    description: string;
    regex: string;
    legal_values: any[];
    collection: boolean;
    type: string;
    optional: boolean;
    default: any;
}
declare class Task {
    batch: string;
    comments: Comment[];
    created: Date;
    errors: Error[];
    id: string;
    input: any;
    last_activity: Date;
    last_start: Date;
    last_stop: Date;
    requester_username: string;
    resolver_usernames: string[];
    resolver_groups: string[];
    resolution: string;
    resolver_username: string;
    result: any;
    state: string;
    steps_done: number;
    steps_total: number;
    template_name: string;
    title: string;
    watcher_usernames: string[];
    watcher_groups: string[];
    tags: {
        [key: string]: string;
    };
    resolver_inputs: ResolverInput[];
    constructor(init?: Partial<Task>);
}
declare class Stats {
    task_states: {
        [state: string]: number;
    };
}

declare class Function$1 {
    name: string;
    action: any;
    pre_hook: any;
    conditions: any;
    custom_states: any;
}

declare class Meta {
    application_name: string;
    user_is_admin: boolean;
    username: string;
    user_groups: string[];
    constructor(init?: Partial<Meta>);
}

declare class ParamsListTasks {
    page_size?: number;
    tag?: string[];
    type: TaskType;
    last?: string;
    state?: TaskState;
    template?: string;
    static equals(a: ParamsListTasks, b: ParamsListTasks): boolean;
}
declare class NewTask {
    comment: string;
    delay: string;
    input: any;
    tags: {
        [key: string]: string;
    };
    template_name: string;
    watcher_usernames: string[];
    watcher_groups: string[];
}
declare class UpdatedTask {
    input: any;
    tags: {
        [key: string]: string;
    };
    watcher_usernames: string[];
    watcher_groups: string[];
}
declare class ApiServiceComment {
    private _http;
    private _base;
    constructor(_http: HttpClient, _base: string);
    add(taskId: string, content: string): Observable<Comment>;
}
declare class ApiServiceTask {
    private http;
    private base;
    comment: ApiServiceComment;
    constructor(http: HttpClient, base: string);
    list(params: ParamsListTasks): Observable<HttpResponse<Array<Task>>>;
    add(body: NewTask): Observable<Object>;
    update(id: string, body: UpdatedTask): Observable<Object>;
    updateAsYaml(id: string, yaml: string): Observable<string>;
    delete(id: string): Observable<Object>;
    reject(id: string): Observable<Object>;
    get(id: string): Observable<Task>;
    getAsYaml(id: string): Observable<string>;
}
declare class ParamsListTemplates {
    page_size?: number;
    last?: string;
}
declare class ApiServiceTemplate {
    private _http;
    private _base;
    constructor(_http: HttpClient, _base: string);
    list(params: ParamsListTemplates): Observable<HttpResponse<Template[]>>;
    get(name: string): Observable<Template>;
    getYAML(name: string): Observable<string>;
}
declare class ParamsListFunctions {
    page_size?: number;
    last?: string;
}
declare class ApiServiceFunction {
    private _http;
    private _base;
    constructor(_http: HttpClient, _base: string);
    list(params: ParamsListFunctions): Observable<HttpResponse<Function$1[]>>;
    get(name: string): Observable<Function$1>;
    getYAML(name: string): Observable<string>;
}
declare class ApiServiceMeta {
    private _http;
    private _base;
    constructor(_http: HttpClient, _base: string);
    get(): Observable<Meta>;
}
declare class ApiServiceStats {
    private _http;
    private _base;
    constructor(_http: HttpClient, _base: string);
    get(): Observable<Stats>;
}
declare class NewResolution {
    resolver_inputs: any;
    task_id: string;
}
declare class UpdatedResolution {
    resolver_inputs: any;
    steps: {
        [step: string]: ResolutionStep;
    };
}
declare class ApiServiceResolution {
    private http;
    private base;
    constructor(http: HttpClient, base: string);
    pause(id: string): Observable<Object>;
    extend(id: string): Observable<Object>;
    run(id: string): Observable<Object>;
    cancel(id: string): Observable<Object>;
    get(id: string): Observable<Object>;
    getAsYaml(id: string): Observable<string>;
    update(id: string, resolution: UpdatedResolution): Observable<Object>;
    updateStepState(id: string, stepName: string, stepState: string): Observable<Object>;
    updateStepAsYaml(id: string, stepName: string, yaml: string): Observable<string>;
    getStep(id: string, stepName: string): Observable<Object>;
    getStepAsYaml(id: string, stepName: string): Observable<string>;
    updateAsYaml(id: string, yaml: string): Observable<string>;
    add(resolution: NewResolution): Observable<Object>;
}
declare class UTaskLibOptions {
    apiBaseUrl: string;
    uiBaseUrl: string;
    refresh: UtaskLibOptionsRefresh;
    constructor(apiBaseUrl: string, uiBaseUrl: string, refresh: UtaskLibOptionsRefresh);
    static ɵfac: i0.ɵɵFactoryDeclaration<UTaskLibOptions, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UTaskLibOptions>;
}
declare class UtaskLibOptionsRefresh {
    home: {
        tasks: number;
        task: number;
    };
    task: number;
}
declare class ApiService {
    private _http;
    private _options;
    meta: ApiServiceMeta;
    task: ApiServiceTask;
    resolution: ApiServiceResolution;
    stats: ApiServiceStats;
    template: ApiServiceTemplate;
    function: ApiServiceFunction;
    private apiBaseUrl;
    constructor(_http: HttpClient, _options: UTaskLibOptions);
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
}

declare class TemplateDetailsComponent implements OnInit {
    private _api;
    private _cd;
    templateName: string;
    error: any;
    loading: boolean;
    template: Template;
    templateYAML: string;
    constructor(_api: ApiService, _cd: ChangeDetectorRef);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateDetailsComponent, "lib-utask-template-details", never, { "templateName": { "alias": "templateName"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StepState {
    key: string;
    color: string;
    fontColor: string;
    shape: string;
    isFinal: boolean;
    icon: string;
    error: boolean;
}

declare class WorkflowService {
    shapes: any[];
    states: StepState[];
    defaultState: any;
    getState(key: string): StepState;
    getArrayStates(): StepState[];
    getMapStates(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WorkflowService>;
}

declare class Step {
    name: string;
    description: string;
    idempotent: boolean;
    action: any;
    output: any;
    metadata: any;
    state: string;
    try_count: number;
    max_retries: number;
    last_run: Date;
    dependencies: string[];
    conditions: any[];
    foreach: string;
    resources: string[];
    tags: {
        [key: string]: string;
    };
    children: string[];
    children_steps: string[];
    children_steps_map: {
        [key: string]: boolean;
    };
    custom_states: string[];
    error: string;
    execution_delay: string;
    foreach_stategy: string;
    json_schema: any;
    pre_hook: any;
    retry_pattern: string;
}

declare class ModalService {
    private _modal;
    constructor(_modal: NzModalService);
    confirmAll<T>(title: string, content: string, okBtnType: NzButtonType, okBtnDanger: boolean, ...actions: Array<Observable<T>>): Promise<Array<T>>;
    confirm<T>(title: string, content: string, okBtnType: NzButtonType, okBtnDanger: boolean, action: Observable<T>): Promise<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}

declare class ResolutionService {
    private modal;
    private _modalService;
    private api;
    constructor(modal: NzModalService, _modalService: ModalService, api: ApiService);
    pause(resolutionId: string): Promise<Object>;
    pauseAll(resolutionIds: string[]): Promise<Object[]>;
    cancel(resolutionId: string): Promise<any>;
    cancelAll(resolutionIds: string[]): Promise<Object[]>;
    extend(resolutionId: string): Promise<Object>;
    extendAll(resolutionIds: string[]): Promise<Object[]>;
    run(resolutionId: string): Promise<Object>;
    runAll(resolutionIds: string[]): Promise<Object[]>;
    edit(resolution: any): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolutionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolutionService>;
}

declare class TaskService {
    private _modalService;
    private api;
    private localStorageTags;
    private tagsRaw;
    tags: Subject<string[]>;
    constructor(_modalService: ModalService, api: ApiService);
    getTagsRaw(): Array<string>;
    registerTags(task: Task): void;
    delete(taskId: string): Promise<any>;
    deleteAll(taskIds: string[]): Promise<Object[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TaskService>;
}

declare class TaskActions {
    delete: boolean;
    cancel: boolean;
    run: boolean;
    pause: boolean;
    extend: boolean;
    more: boolean;
    constructor(t: Task, m: Meta);
    static mergeTaskActions(tas: Array<TaskActions>): TaskActions;
}
declare class TasksListComponentOptions {
    refreshTasks: number;
    refreshTask: number;
    routingTaskPath: string;
    disableBulk: boolean;
    constructor(init?: Partial<TasksListComponentOptions>, options?: UTaskLibOptions);
}
declare class TasksListComponent implements OnInit, OnDestroy, OnChanges, AfterViewInit {
    private _api;
    private _resolutionService;
    private _taskService;
    private _cd;
    private _zone;
    nzTableComponent?: NzTableComponent<Task>;
    set params(data: ParamsListTasks);
    get params(): ParamsListTasks;
    _params: ParamsListTasks;
    meta: Meta;
    options?: TasksListComponentOptions;
    event: EventEmitter<any>;
    tasks: Task[];
    tasksActions: TaskActions[];
    loadingTasks: boolean;
    firstLoad: boolean;
    hasMore: boolean;
    intervalLoadNewTasks: Subscription;
    newTasks: Task[];
    intervalRefreshTasks: Subscription;
    tasksToRefresh: {
        [key: string]: number;
    };
    bulkAllSelected: boolean;
    bulkSelection: {
        [key: string]: boolean;
    };
    bulkActions: TaskActions;
    errors: {
        [key: string]: any;
    };
    scroll: Subject<void>;
    scrollSub: Subscription;
    registrerScroll: Subject<ParamsListTasks>;
    objectKeys: {
        (o: object): string[];
        (o: {}): string[];
    };
    titleWidth: string;
    constructor(_api: ApiService, _resolutionService: ResolutionService, _taskService: TaskService, _cd: ChangeDetectorRef, _zone: NgZone);
    ngAfterViewInit(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(): void;
    clickCheckAll(checked: boolean): void;
    clickCheckTask(taskID: number, checked: boolean): void;
    refreshCheckAllState(): void;
    registerInfiniteScroll(): Promise<void>;
    cancelScrollSub(): void;
    loadMore(skipCheckScroll?: boolean): Promise<void>;
    loadTasks(paramLast?: string): Observable<Array<Task>>;
    clickShowMore(): void;
    trackInput(index: number, task: Task): string;
    initLoadNewTasks(): void;
    fetchNewTasks(lastActivity: Date): Promise<void>;
    cancelLoadNewTasks(): void;
    clickShowNewTasks(): void;
    initRefreshTasks(): void;
    cancelRefreshTasks(): void;
    refreshTasks(): Promise<void>;
    computeTaskActions(): void;
    cancelResolution(resolutionId: string, taskId: string): void;
    cancelAll(): void;
    pauseResolution(resolutionId: string, taskId: string): void;
    pauseAll(): void;
    extendResolution(resolutionId: string, taskId: string): void;
    extendAll(): void;
    deleteTask(id: string): void;
    deleteAll(): void;
    runResolution(resolutionId: string, taskId: string): void;
    runAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TasksListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TasksListComponent, "lib-utask-tasks-list", never, { "params": { "alias": "params"; "required": false; }; "meta": { "alias": "meta"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "event": "event"; }, never, never, false, never>;
}

declare class StepsListComponent implements OnChanges {
    private _options;
    private _modal;
    private _workflowService;
    private _notif;
    private _api;
    resolution: any;
    selectedStep: string;
    stepChanged: EventEmitter<Step>;
    options?: TasksListComponentOptions;
    displayDetails: {
        [key: string]: boolean;
    };
    filter: any;
    editorConfigPayload: EditorOptions;
    editorConfigError: EditorOptions;
    editorConfigChildren: EditorOptions;
    filteredStepNames: string[];
    states: any;
    JSON: JSON;
    presentStates: string[];
    defaultState: any;
    constructor(_options: UTaskLibOptions, _modal: NzModalService, _workflowService: WorkflowService, _notif: NzNotificationService, _api: ApiService);
    ngOnChanges(changes: SimpleChanges): void;
    preview(title: string, item: any): void;
    updateStepState(step: Step): void;
    updateStep(step: Step): void;
    setPresentStates(): void;
    getIcon(state: string): string;
    filterSteps(): void;
    lineStyle(stepName: string): {
        color: any;
        'background-color': any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<StepsListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepsListComponent, "lib-utask-steps-list", never, { "resolution": { "alias": "resolution"; "required": false; }; "selectedStep": { "alias": "selectedStep"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "stepChanged": "stepChanged"; }, never, never, false, never>;
}

declare class EditorComponent implements OnInit, OnChanges {
    private _el;
    private _nzConfigService;
    set config(c: EditorOptions);
    _config: EditorOptions;
    ngModel: string;
    ngModelChange: EventEmitter<string>;
    constructor(_el: ElementRef, _nzConfigService: NzConfigService);
    ngOnInit(): void;
    ngOnChanges(): void;
    computeTheme(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "lib-utask-editor", never, { "config": { "alias": "config"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; }, { "ngModelChange": "ngModelChange"; }, never, never, false, never>;
}

declare class StepNodeComponent implements OnInit, OnChanges {
    div: ElementRef;
    step: Step;
    key: string;
    click: EventEmitter<string>;
    styleClass: string;
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    clickNode(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepNodeComponent, "lib-utask-step-node", never, { "step": { "alias": "step"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, { "click": "click"; }, never, never, false, never>;
}

declare class Resolution {
    id: string;
    resolver_username: string;
    state: string;
    instance_id: number;
    last_start: Date;
    last_stop: Date;
    next_retry: Date;
    run_count: number;
    run_max: number;
    base_configurations: any;
    task_id: string;
    task_title: string;
    resolver_inputs?: {
        [key: string]: any;
    };
    steps: {
        [key: string]: Step;
    };
}

declare class StepsViewerComponent implements OnChanges {
    private _cd;
    resolution: Resolution;
    select: EventEmitter<any>;
    selectedStep: string;
    graphData: NzGraphData;
    rankDirection: NzRankDirection;
    nzGraphComponent: NzGraphComponent;
    zoomController: NzGraphZoomDirective;
    layoutConfig: NzGraphLayoutConfig;
    zoom: number;
    constructor(_cd: ChangeDetectorRef);
    ngOnChanges(): void;
    clear(): void;
    graphInitialized(_ele: NzGraphComponent): void;
    fit(): void;
    selectNode(step: any): void;
    draw(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepsViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepsViewerComponent, "lib-utask-steps-viewer", never, { "resolution": { "alias": "resolution"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

declare class InputsFormComponent {
    inputs: Array<ResolverInput>;
    formGroup: FormGroup;
    static getInputs(values: any): any;
    trackInput(index: number, input: ResolverInput): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputsFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputsFormComponent, "lib-utask-inputs-form", never, { "inputs": { "alias": "inputs"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, {}, never, never, false, never>;
}

declare class InputEditorComponent implements ControlValueAccessor, OnInit {
    private _cd;
    private _el;
    private _nzConfigService;
    set config(c: EditorOptions);
    _config: EditorOptions;
    onChange: OnChangeType;
    onTouched: OnTouchedType;
    code: string;
    constructor(_cd: ChangeDetectorRef, _el: ElementRef, _nzConfigService: NzConfigService);
    ngOnInit(): void;
    writeValue(code: string): void;
    registerOnChange(fn: OnChangeType): void;
    registerOnTouched(fn: OnTouchedType): void;
    changeCode(code: string): void;
    computeHeight(code: string): void;
    computeTheme(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputEditorComponent, "lib-utask-input-editor", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TaskStatusComponent implements OnChanges {
    private _cd;
    task: Task;
    percentage: number;
    constructor(_cd: ChangeDetectorRef);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaskStatusComponent, "lib-utask-task-status", never, { "task": { "alias": "task"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HeaderConfig {
    init: boolean;
    openable: boolean;
    class: string;
    color: string;
    fontColor: string;
}
declare class BoxComponent implements OnChanges {
    panel: NzCollapsePanelComponent;
    header: HeaderConfig;
    display: boolean;
    headerConfig: HeaderConfig;
    customStyle: any;
    customStylePanel: any;
    customStyleHeader: any;
    constructor();
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BoxComponent, "lib-utask-box", never, { "header": { "alias": "header"; "required": false; }; }, {}, never, ["[app-box-content]", "[app-box-header]", "[app-box-header-extra]"], false, never>;
}

declare class FromNowPipe implements PipeTransform {
    transform(value: any, params?: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FromNowPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FromNowPipe, "utaskFromNow", false>;
}

interface IModalData$2 {
    apiCall: any;
}
declare class ModalApiYamlComponent implements OnInit {
    modal: NzModalRef;
    text: string;
    loading: boolean;
    error: any;
    readonly nzModalData: IModalData$2;
    constructor(modal: NzModalRef);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalApiYamlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalApiYamlComponent, "lib-utask-modal-yaml-preview", never, {}, {}, never, never, false, never>;
}

interface IModalData$1 {
    step: Step;
    resolution: Resolution;
}
declare class ModalEditResolutionStepStateComponent implements OnInit {
    modal: NzModalRef;
    private api;
    private fb;
    modalForm: FormGroup;
    states: string[];
    result: string;
    loaders: {
        [key: string]: boolean;
    };
    errors: {
        [key: string]: any;
    };
    readonly nzModalData: IModalData$1;
    constructor(modal: NzModalRef, api: ApiService, fb: FormBuilder);
    ngOnInit(): void;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalEditResolutionStepStateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalEditResolutionStepStateComponent, "lib-utask-modal-edit-resolution-step-state", never, {}, {}, never, never, false, never>;
}

interface IModalData {
    apiCall: any;
    apiCallSubmit: any;
}
declare class ModalApiYamlEditComponent implements OnInit {
    modal: NzModalRef;
    text: string;
    loaders: {
        [key: string]: boolean;
    };
    errors: {
        [key: string]: any;
    };
    result: any;
    readonly nzModalData: IModalData;
    constructor(modal: NzModalRef);
    ngOnInit(): void;
    submit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalApiYamlEditComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalApiYamlEditComponent, "lib-utask-modal-yaml-preview", never, {}, {}, never, never, false, never>;
}

declare class NzModalContentWithErrorComponent {
    content?: string;
    errors?: Array<any>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalContentWithErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalContentWithErrorComponent, "lib-modal-content-with-error", never, { "content": { "alias": "content"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RequestService {
    private modal;
    private api;
    constructor(modal: NzModalService, api: ApiService);
    edit(task: Task): Promise<unknown>;
    isResolvable(task: Task, meta: Meta, template: Template): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequestService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RequestService>;
}

declare class AutofocusDirective implements OnInit {
    private el;
    private focus;
    constructor(el: ElementRef);
    ngOnInit(): void;
    set autofocus(condition: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<AutofocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutofocusDirective, "[autofocus]", never, { "autofocus": { "alias": "autofocus"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FullHeightDirective implements AfterViewInit, OnDestroy {
    myElement: any;
    subscriptionResize: any;
    constructor(myElement: ElementRef);
    ngAfterViewInit(): void;
    setHeight(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FullHeightDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FullHeightDirective, "[fullHeight]", never, {}, {}, never, never, false, never>;
}

declare class NsAutoHeightTableDirective {
    private element;
    private table;
    private cd;
    offset: number;
    constructor(element: ElementRef, table: NzTableComponent<any>, cd: ChangeDetectorRef);
    onResize(event: any): void;
    ngAfterViewInit(): void;
    private doAutoSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<NsAutoHeightTableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NsAutoHeightTableDirective, "[nsAutoHeightTable]", never, { "offset": { "alias": "nsAutoHeightTable"; "required": false; }; }, {}, never, never, false, never>;
}

declare class UTaskLibModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UTaskLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UTaskLibModule, [typeof BoxComponent, typeof ChartTaskStatesComponent, typeof EditorComponent, typeof ErrorMessageComponent, typeof InputEditorComponent, typeof InputsFormComponent, typeof InputTagsComponent, typeof LoaderComponent, typeof ModalApiYamlComponent, typeof ModalEditResolutionStepStateComponent, typeof ModalApiYamlEditComponent, typeof NzModalContentWithErrorComponent, typeof StepNodeComponent, typeof StepsListComponent, typeof StepsViewerComponent, typeof TasksListComponent, typeof TaskStatusComponent, typeof TemplateDetailsComponent, typeof FromNowPipe, typeof NsAutoHeightTableDirective, typeof FullHeightDirective, typeof AutofocusDirective], [typeof i23.CommonModule, typeof i24.FormsModule, typeof i24.ReactiveFormsModule, typeof i12.RouterModule, typeof i26.ChartCommonModule, typeof i26.PieChartModule, typeof i27.NzTableModule, typeof i28.NzButtonModule, typeof i29.NzSpaceModule, typeof i30.NzIconModule, typeof i31.NzDividerModule, typeof i32.NzDropDownModule, typeof i33.NzInputModule, typeof i34.NzSelectModule, typeof i35.NzAutocompleteModule, typeof i36.NzModalModule, typeof i37.NzGridModule, typeof i38.NzGraphModule, typeof i39.NzAlertModule, typeof i40.NzCollapseModule, typeof i41.NzCodeEditorModule, typeof i42.NzFormModule, typeof i43.NzCheckboxModule, typeof i44.NzSpinModule, typeof i45.NzDescriptionsModule, typeof i46.NzTooltipModule, typeof i47.NzCommentModule, typeof i48.NzAvatarModule, typeof i49.NzListModule, typeof i50.NzSwitchModule, typeof i51.NzPageHeaderModule, typeof i52.NzResultModule], [typeof BoxComponent, typeof ChartTaskStatesComponent, typeof EditorComponent, typeof ErrorMessageComponent, typeof InputEditorComponent, typeof InputsFormComponent, typeof InputTagsComponent, typeof LoaderComponent, typeof ModalApiYamlComponent, typeof ModalEditResolutionStepStateComponent, typeof ModalApiYamlEditComponent, typeof NzModalContentWithErrorComponent, typeof StepNodeComponent, typeof StepsListComponent, typeof StepsViewerComponent, typeof TasksListComponent, typeof TaskStatusComponent, typeof TemplateDetailsComponent, typeof FromNowPipe, typeof NsAutoHeightTableDirective, typeof FullHeightDirective, typeof AutofocusDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UTaskLibModule>;
}
declare function UTaskLibOptionsFactory(apiBaseUrl: string, uiBaseUrl: string, refresh: UtaskLibOptionsRefresh): any;

declare class TasksComponent implements OnInit {
    private _activateRoute;
    private router;
    private taskService;
    private _cd;
    private _notif;
    private _options;
    tags: string[];
    meta: Meta;
    pagination: ParamsListTasks;
    listOptions: TasksListComponentOptions;
    templates: Template[];
    constructor(_activateRoute: ActivatedRoute, router: Router, taskService: TaskService, _cd: ChangeDetectorRef, _notif: NzNotificationService, _options: UTaskLibOptions);
    ngOnInit(): void;
    routeTo(taskId: string): void;
    toastError(message: string): void;
    toastInfo(message: string): void;
    search(replaceUrl?: boolean): void;
    queryToSearchTask(queryParams: any): ParamsListTasks;
    paginationTypeChange(type: TaskType): void;
    paginationStateChange(state: TaskState): void;
    paginationTemplateChange(name: string): void;
    inputTagsChanged(tags: Array<string>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TasksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TasksComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class TaskComponent implements OnInit, OnDestroy {
    private api;
    private route;
    private resolutionService;
    private requestService;
    private taskService;
    private router;
    private _fb;
    private modal;
    private viewContainerRef;
    private _notif;
    private _options;
    private _meta$;
    readonly meta$: rxjs.Observable<Meta>;
    private _task$;
    readonly task$: rxjs.Observable<Task>;
    readonly template$: rxjs.Observable<Template>;
    private _resolution$;
    readonly resolution$: rxjs.Observable<Resolution>;
    private _isResolver$;
    readonly canStartOver$: rxjs.Observable<boolean>;
    readonly canRun$: rxjs.Observable<boolean>;
    readonly canPause$: rxjs.Observable<boolean>;
    readonly canExtend$: rxjs.Observable<boolean>;
    readonly canCancel$: rxjs.Observable<boolean>;
    readonly canEdit$: rxjs.Observable<boolean>;
    readonly canEditRequest$: rxjs.Observable<boolean>;
    readonly canDeleteRequest$: rxjs.Observable<boolean>;
    validateResolveForm: FormGroup;
    validateRejectForm: FormGroup;
    inputControls: Array<string>;
    objectKeys: {
        (o: object): string[];
        (o: {}): string[];
    };
    loaders: {
        [key: string]: boolean;
    };
    haveAtLeastOneChilTask: boolean;
    errors: {
        [key: string]: any;
    };
    display: {
        [key: string]: boolean;
    };
    confirm: {
        [key: string]: boolean;
    };
    refreshes: {
        [key: string]: Subscription;
    };
    textarea: {
        [key: string]: boolean;
    };
    item: any;
    taskJson: string;
    taskIsResolvable: boolean;
    taskId: string;
    selectedStep: string;
    resolverInputs: Array<ResolverInput>;
    JSON: JSON;
    template: Template;
    comment: any;
    autorefresh: any;
    uiBaseUrl: string;
    listOptions: TasksListComponentOptions;
    constructor(api: ApiService, route: ActivatedRoute, resolutionService: ResolutionService, requestService: RequestService, taskService: TaskService, router: Router, _fb: FormBuilder, modal: NzModalService, viewContainerRef: ViewContainerRef, _notif: NzNotificationService, _options: UTaskLibOptions);
    ngOnDestroy(): void;
    ngOnInit(): void;
    addComment(): void;
    previewTask(): void;
    previewResolution(): void;
    editRequest(): void;
    editResolution(resolution: any): void;
    runResolution(resolution: any): void;
    pauseResolution(resolution: any): void;
    cancelResolution(resolution: any): void;
    extendResolution(resolution: any): void;
    deleteTask(): void;
    rejectTask(): void;
    resolveTask(): void;
    selectStepFromViewer(step: any): void;
    getTemplate(templateName: any): Promise<Template>;
    taskChanged(): void;
    loadTask(refresh?: boolean): Promise<void>;
    loadResolution(resolutionId: string): any;
    eventUtask(event: any): void;
    restartTask(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TaskComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TaskComponent, "lib-utask-task", never, {}, {}, never, never, false, never>;
}

declare class NewComponent implements OnInit {
    private _api;
    private _activatedRoute;
    private _router;
    private _fb;
    private _cd;
    private _options;
    validateForm: FormGroup;
    loaders: {
        [key: string]: boolean;
    };
    errors: {
        [key: string]: any;
    };
    templates: Template[];
    selectedTemplate: Template;
    inputControls: Array<string>;
    constructor(_api: ApiService, _activatedRoute: ActivatedRoute, _router: Router, _fb: FormBuilder, _cd: ChangeDetectorRef, _options: UTaskLibOptions);
    ngOnInit(): void;
    templateChange(t: Template): void;
    formValuesToNewTask(values: any): NewTask;
    submitForm(): void;
    saveFormInQueryParams(item: NewTask): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NewComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class TemplatesComponent implements OnInit {
    private _route;
    private _options;
    uiBaseUrl: string;
    templates: Template[];
    constructor(_route: ActivatedRoute, _options: UTaskLibOptions);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TemplatesComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class TemplateComponent implements OnInit {
    private _route;
    templateName: string;
    constructor(_route: ActivatedRoute);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class FunctionsComponent implements OnInit {
    private _route;
    private _options;
    uiBaseUrl: string;
    functions: Function[];
    constructor(_route: ActivatedRoute, _options: UTaskLibOptions);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FunctionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FunctionsComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class FunctionComponent implements OnInit {
    private _route;
    private _api;
    private _cd;
    functionName: string;
    loading: boolean;
    error: any;
    function: string;
    constructor(_route: ActivatedRoute, _api: ApiService, _cd: ChangeDetectorRef);
    ngOnInit(): void;
    load(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FunctionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FunctionComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class StatsComponent implements OnInit {
    private _route;
    private _options;
    taskStates: VMTaskState[];
    uiBaseUrl: string;
    constructor(_route: ActivatedRoute, _options: UTaskLibOptions);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatsComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class ErrorComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class UTaskLibRoutingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UTaskLibRoutingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UTaskLibRoutingModule, [typeof TasksComponent, typeof TaskComponent, typeof NewComponent, typeof TemplatesComponent, typeof TemplateComponent, typeof FunctionsComponent, typeof FunctionComponent, typeof StatsComponent, typeof ErrorComponent], [typeof i23.CommonModule, typeof i24.FormsModule, typeof i24.ReactiveFormsModule, typeof i12.RouterModule, typeof i26.ChartCommonModule, typeof i26.PieChartModule, typeof i27.NzTableModule, typeof i28.NzButtonModule, typeof i29.NzSpaceModule, typeof i30.NzIconModule, typeof i31.NzDividerModule, typeof i32.NzDropDownModule, typeof i33.NzInputModule, typeof i34.NzSelectModule, typeof i35.NzAutocompleteModule, typeof i36.NzModalModule, typeof i37.NzGridModule, typeof i39.NzAlertModule, typeof i40.NzCollapseModule, typeof i41.NzCodeEditorModule, typeof i42.NzFormModule, typeof i38.NzGraphModule, typeof i43.NzCheckboxModule, typeof i44.NzSpinModule, typeof i45.NzDescriptionsModule, typeof i46.NzTooltipModule, typeof i47.NzCommentModule, typeof i48.NzAvatarModule, typeof i49.NzListModule, typeof i50.NzSwitchModule, typeof i51.NzPageHeaderModule, typeof i52.NzResultModule, typeof UTaskLibModule, typeof i12.RouterModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UTaskLibRoutingModule>;
}

export { ApiService, ApiServiceComment, ApiServiceFunction, ApiServiceMeta, ApiServiceResolution, ApiServiceStats, ApiServiceTask, ApiServiceTemplate, AutofocusDirective, BoxComponent, ChartTaskStatesComponent, Comment, EditorComponent, Error, ErrorMessageComponent, FromNowPipe, FullHeightDirective, Function$1 as Function, InputEditorComponent, InputTagsComponent, InputsFormComponent, LoaderComponent, Meta, ModalApiYamlComponent, ModalApiYamlEditComponent, ModalEditResolutionStepStateComponent, ModalService, NewResolution, NewTask, NsAutoHeightTableDirective, NzModalContentWithErrorComponent, ParamsListFunctions, ParamsListTasks, ParamsListTemplates, RequestService, Resolution, ResolutionService, ResolutionStep, ResolverInput, Stats, Step, StepNodeComponent, StepState, StepsListComponent, StepsViewerComponent, Task, TaskActions, TaskService, TaskState, TaskStatusComponent, TaskType, TasksListComponent, TasksListComponentOptions, Template, TemplateDetailsComponent, UTaskLibModule, UTaskLibOptions, UTaskLibOptionsFactory, UTaskLibRoutingModule, UpdatedResolution, UpdatedTask, UtaskLibOptionsRefresh, VMTaskState, WorkflowService };