// Generated by dts-bundle v0.7.3
// Dependencies for this module:
//   ../../../../chai
//   ../../../../Engine/Core/CoreTypes
//   ../../../../Engine/Form/Form
//   ../../../../puppeteer
//   ../../../../selenium-webdriver

import { expect } from "chai";
import { CandyErrorLog } from "Engine/Core/CoreTypes";
import { ReuisitesInfo } from "Engine/Form/Form";
import { Page } from "puppeteer";
import { WebDriver } from "selenium-webdriver";

export { expect };

type Func<TArgs extends any[], TR> = (...args: TArgs) => TR;

export declare type ExtendedPromise<T> = Promise<T> & {
    __recall: () => Promise<T>;
} & {
        [P in keyof T]:
            T[P] extends ExtendedPromise<infer TArgs>
                ? ExtendedPromise<TArgs> :
            T[P] extends Func<infer TArgs, Promise<infer TR>>
                ? Func<TArgs, ExtendedPromise<TR>> :
            T[P] extends Func<infer TArgs2, infer TR2>
                ? Func<TArgs2, ExtendedPromise<TR2>>
                : ExtendedPromise<T[P]>
    };

export declare function extendPromise<T>(promise: Promise<T> | (() => Promise<T>)): ExtendedPromise<T>;

export declare function controlOf<T, TArg1>(controlConsructor: ControlConsructor<T, [TArg1]>, arg1: TArg1): ControlConsructor<T>;
export declare function controlOf<T, TArg1, TArg2>(controlConsructor: ControlConsructor<T, [TArg1, TArg2]>, arg1: TArg1, arg2: TArg2): ControlConsructor<T>;

declare class FluentDecoractors<T> {
    constructor(controlConsructor: ControlConsructor<T>);
    tid(tidString: string): PropertyDecorator;
    prop(name: string, value: string): PropertyDecorator;
    bindingPath(bindingPath: string): PropertyDecorator;
    as(selector: string, searchEnchancer?: (x: FluentControlInstanceBuilder<T>) => FluentControlInstanceBuilder<T>): PropertyDecorator;
    asRoot(): PropertyDecorator;
    asIs(): PropertyDecorator;
    id(id: string): PropertyDecorator;
}
export declare function control<T>(controlConsructor: ControlConsructor<T>): FluentDecoractors<T>;
export {};

export declare class DomSelector implements ISelector {
    constructor(selectorString: string);
    internalSetSelectorString(newSelectorString: string): void;
    internalGetSelectorString(): string;
    execute(context: ISearchContext): Promise<ReactSelectorResultHandle>;
    getDescription(context: ISearchContext): string;
}

export interface ISearchContext {
    readonly rootPage: CandyBrowserPage;
    readonly rootPageWrapper: BrowserPageWrapper;
    getSelectorResultForChildSearch(): Promise<ReactSelectorResultHandle>;
    getSelectorDescription(): string;
}

export interface ISelector {
    execute(context: ISearchContext): Promise<ReactSelectorResultHandle>;
    getDescription(context: ISearchContext): string;
}

export declare class ReactSelector implements ISelector {
    constructor(selectorString: string, props?: PropsFilter);
    internalSetPropsFilter(props?: PropsFilter): void;
    internalGetPropsFilter(): undefined | PropsFilter;
    execute(context: ISearchContext): Promise<ReactSelectorResultHandle>;
    getDescription(context: ISearchContext): string;
}

interface FufAsJson {
    [key: string]: FufAsJson & FufAsJson[] & string;
}
export declare class CandyPageWithNavigationBase extends PageBase {
    showMenuButton: ButtonControl;
    navigationPanel: NavigationPanel;
    menu: ButtonControl;
    expandNavigationPanel(): Promise<void>;
    collapseNavigationPanel(): Promise<void>;
    runCheck(): Promise<EmbeddedLogControl>;
    checkFuf(expectedFufContentPart: {} | ((fuf: FufAsJson) => Promise<void> | void)): Promise<void>;
    ensureAllDataSaved(): Promise<void>;
}
export {};

export declare class UIMigrationTestBase {
    protected form: UITestFormPageWrapper;
    protected createForm(fuf: undefined | Buffer, requisites: undefined | ReuisitesInfo, settings: undefined | Partial<FormSettings>, errorLog: undefined | CandyErrorLog): Promise<void>;
    after(): Promise<void>;
}

export declare class UITestFormPageWrapper {
    constructor(page: Page);
    wait(tm: number): Promise<void>;
    getValueFromControl(inNodePath: string, inStatePath: string): Promise<string>;
    setValueToControl(inNodePath: string, inStatePath: string, inValue?: string): Promise<void>;
    setValueToModel(inNodePath: string, inFieldName: string, inValue: string): Promise<void>;
    getValueFromModel(inNodePath: string, inFieldName: string): Promise<string>;
    close(): Promise<void>;
}

interface IntegrationTestOptions {
    externSession?: boolean;
}
export declare class CandyFarmIntegrationTestBase implements IMochaTestContextContainer {
    readonly mochaContext: Mocha.Context;
    protected candyServiceContext: CandyServiceTestContext;
    protected e2eTestContext: CandyE2ETestContext;
    protected browserPage: BrowserPageWrapper;
    constructor(options: IntegrationTestOptions);
    before(): Promise<void>;
    after(): Promise<void>;
}
export {};

export declare class TestFarmIntegrationTestBase {
    readonly mochaContext: Mocha.Context;
    protected candyServiceContext: CandyServiceTestContext;
    protected e2eTestContext: CandyE2ETestContext;
    protected browserPage: BrowserPageWrapper;
    before(): Promise<void>;
    after(): Promise<void>;
    protected openPageByGfvWithDefaultDraft<TPage>(pageContructor: ControlConsructor<TPage>, gfv: string): Promise<TPage>;
}

export declare function createDefaultClientRequisites(): ClientRequisites;
export declare const defaultFormsClientInfo: ClientInfo;
export declare function createDefaultFormsClientInfo(): ClientInfo;

export function runCandyApiForTests(farmRootDirectory: string): void;

export function runFarmTests(farmRootDirectory: string): void;

export declare class UnitBase<T = {}> extends CompoundControl<T> {
    static defaultElementSelector: string;
    scrollTo(): Promise<void>;
}

export declare class CompoundControl<T = {}> extends ControlBase {
    setValues(values: EditableControlValues<T>): Promise<void>;
    expectValues(values: ExpectableControlValues<T>): Promise<void>;
}
declare type EditableControlValues<T> = {
    [P in keyof T]?: T[P] extends InputControl ? string : never;
};
declare type ExpectableControlValues<T> = {
    [P in keyof T]?: T[P] extends InputControl ? string : T[P] extends TextControl ? string : never;
};
export {};

export declare class ButtonControl extends ControlBase {
    static defaultElementSelector: string;
    click(): Promise<void>;
    readonly text: ExtendedPromise<string>;
    readonly disabled: ExtendedPromise<boolean>;
}

export declare class CheckboxControl extends ControlBase {
    static defaultElementSelector: string;
    click(checkState?: boolean): Promise<void>;
    readonly text: Promise<string>;
    readonly checked: ExtendedPromise<boolean>;
}

export declare class ClickableAreaControl extends ControlBase {
    click(): Promise<void>;
    getText(): Promise<string>;
}

export declare class ComboboxControl extends ControlBase {
    static defaultElementSelector: string;
    constructor(context: ISearchContext, selector: ISelector);
    readonly text: ExtendedPromise<string>;
    clearAndType(text: string): ExtendedPromise<void>;
    readonly errorMessage: Promise<undefined | string>;
    selectValueByIndex(index: number): ExtendedPromise<void>;
    click(): ExtendedPromise<void>;
    typeValueAndSelectSingle(searchValue: string): ExtendedPromise<void>;
    getDropdown<TContent>(contentClass: ControlConsructor<TContent>): Promise<DropdownControl<TContent>>;
}
export declare class ComboboxItemControl extends CompoundControl {
    click(): Promise<void>;
    readonly text: Promise<string>;
}
export declare class ComboboxDropdownContent extends CompoundControl {
    items: ControlList<ComboboxItemControl>;
    textRenderTotalCount: LabelControl;
}

export declare class ControlList<TItem> extends ControlBase {
    constructor(context: ISearchContext, selector: ISelector, childSelector: ISelector, childFactory: ControlConsructor<TItem>);
    static of<T>(instanceBuilder: FluentControlInstanceBuilder<T>): ControlConsructor<ControlList<T>>;
    getCount(): ExtendedPromise<number>;
    itemAt(index: number): ExtendedPromise<TItem>;
    getItems(): Promise<TItem[]>;
}

export declare class DatePickerControl extends ControlBase {
    static defaultElementSelector: string;
    type(text: string): Promise<void>;
    readonly value: ExtendedPromise<string>;
    clear(): Promise<void>;
    blur(): Promise<void>;
    clearAndType(text: string): Promise<void>;
    focus(): Promise<void>;
    click(): Promise<void>;
}

export declare class DatePickerNewControl extends ControlBase {
    static defaultElementSelector: string;
    type(text: string): Promise<void>;
    readonly value: Promise<string>;
    clear(): Promise<void>;
    blur(): Promise<void>;
    clearAndType(text: string): Promise<void>;
    clearAndTypeAndBlur(text: string): Promise<void>;
    focus(): Promise<void>;
    click(): Promise<void>;
}

export declare class DropdownControl<TContent> extends ControlBase {
    readonly content: TContent;
    readonly disabled: ExtendedPromise<boolean>;
    readonly text: ExtendedPromise<string>;
    static defaultElementSelector: string;
    constructor(context: ISearchContext, selector: ISelector, contentConrol: ControlConsructor<TContent>);
    static withMenus<T>(menus: ControlConsructor<T>): ControlConsructor<DropdownControl<T>>;
    open(): Promise<void>;
}

export declare class DropdownMenuControl<TContent> extends ControlBase {
    readonly content: TContent;
    constructor(context: ISearchContext, selector: ISelector, contentConrol: ControlConsructor<TContent>);
    static of<T>(contentConrol: ControlConsructor<T>): ControlConsructor<DropdownMenuControl<T>>;
    open(): Promise<void>;
}

declare class ErrorItemControl extends CompoundControl {
    sourceLinkControl: LabelControl;
    description: LabelControl;
    isTouched(): Promise<boolean>;
}
export declare class ErrorListControl extends CompoundControl {
    items: ControlList<ErrorItemControl>;
}
export declare class EmbeddedLogControl extends CompoundControl {
    header: LabelControl;
    errorList: ErrorListControl;
    loader: LoaderControl;
    tooltip: TooltipContentBaseControl;
    printErrorLog: ButtonControl;
    readonly isLoading: ExtendedPromise<boolean>;
}
export {};

declare class ViewFileRemoveTooltip extends TooltipContentBaseControl {
    removeButton: ButtonControl;
}
declare class ViewFileControl extends CompoundControl {
    progressBar: ControlBase;
    fileName: LabelControl;
    removeArea: ClickableAreaControl;
    removeToolip: ViewFileRemoveTooltip;
    remove(): Promise<void>;
}
export declare class FileLoaderControl extends CompoundControl {
    static defaultElementSelector: string;
    addButton: ButtonControl;
    replaceButton: ButtonControl;
    files: ControlList<ViewFileControl>;
    addFile(fileName: string, content: Buffer | string): Promise<void>;
    replaceFile(fileName: string, content: Buffer | string): Promise<void>;
}
export {};

export declare class IconControl extends ControlBase {
    click(): Promise<void>;
}

export declare class InputControl extends ControlBase {
    static defaultElementSelector: string;
    type(text: string): Promise<void>;
    readonly value: Promise<string>;
    readonly isDisabled: Promise<boolean>;
    readonly isValid: Promise<boolean>;
    readonly isFocused: Promise<boolean>;
    readonly errorMessage: Promise<undefined | string>;
    clearAndType(text: string): Promise<void>;
    focus(): Promise<void>;
    blur(): Promise<void>;
    click(): Promise<void>;
    readonly placeholder: Promise<string>;
}

export declare class LabelControl extends ControlBase {
    readonly text: ExtendedPromise<string>;
    click(): Promise<void>;
}

export declare class LinkControl extends ControlBase {
    static defaultElementSelector: string;
    click(): Promise<void>;
    readonly text: Promise<string>;
}

export declare class LoaderControl extends ControlBase {
    readonly isActive: ExtendedPromise<boolean>;
}

export declare class MenuItemControl extends ControlBase {
    readonly disabled: ExtendedPromise<boolean>;
    readonly text: ExtendedPromise<string>;
    static defaultElementSelector: string;
    click(): Promise<void>;
}

export declare class MultilineControl<TRow> extends CompoundControl {
    rows: ControlList<TRow>;
    constructor(context: ISearchContext, selector: ISelector, contentConrol: ControlConsructor<TRow>);
    static of<T>(contentConrol: ControlConsructor<T>): ControlConsructor<MultilineControl<T>>;
}

export declare class MultilineFieldControl<TRow> extends CompoundControl {
    static defaultElementSelector: string;
    items: ControlList<MultilineFieldItemBase<TRow>>;
    moreItemsLink: LinkControl;
    constructor(context: ISearchContext, selector: ISelector, childFactory: ControlConsructor<TRow>);
    static of<T>(childFactory: ControlConsructor<T>): ControlConsructor<MultilineFieldControl<T>>;
    addItem(): Promise<void>;
}
declare class MultilineFieldItemBase<TRow> extends CompoundControl {
    value: TRow;
    addButton: IconControl;
    removeButton: IconControl;
    constructor(context: ISearchContext, selector: ISelector, rowConsructor: ControlConsructor<TRow>);
}
export {};

export declare class NavigationPanelActionList extends CompoundControl {
    clickDownloadButton(): Promise<void>;
}
export declare class NavigationPanel extends CompoundControl {
    static defaultElementSelector: string;
    actionList: NavigationPanelActionList;
    runTourButton: ButtonControl;
    checkButton: ButtonControl;
    formSaveStatus: ClickableAreaControl;
    pin: ClickableAreaControl;
    embeddedLog: EmbeddedLogControl;
    unitAdder1: LabelControl;
    unitAdder2: LabelControl;
    ensureAllDataSaved(): Promise<void>;
}

export declare class PageLinkControl extends CompoundControl {
    link: LinkControl;
    readonly disabled: ExtendedPromise<boolean>;
    click(): ExtendedPromise<void>;
    readonly present: ExtendedPromise<boolean>;
}

export declare class PagerControl extends CompoundControl {
    pageLinks: ControlList<PageLinkControl>;
    previousLink: LinkControl;
    nextLink: LinkControl;
    readonly empty: ExtendedPromise<boolean>;
    readonly currentPage: ExtendedPromise<boolean>;
}

export declare class PencilControl extends CompoundControl {
    editIcon: IconControl;
    readonly isOpened: ExtendedPromise<boolean>;
    click(): Promise<void>;
}

export declare class PopupMenuControl<TContent> extends ControlBase {
    readonly content: TContent;
    constructor(context: ISearchContext, selector: ISelector, contentConrol: ControlConsructor<TContent>);
    static withContent<T>(contentConrol: ControlConsructor<T>): ControlConsructor<PopupMenuControl<T>>;
    open(): Promise<void>;
}

export declare class RadioControl extends ControlBase {
    static defaultElementSelector: string;
    click(): Promise<void>;
}

declare class RemoveButton extends CompoundControl {
    click(): Promise<void>;
}
declare class RowMenuContent extends CompoundControl {
    copyButton: ButtonControl;
    copyToEndButton: ButtonControl;
    removeButton: ButtonControl;
}
declare class RowMenu extends CompoundControl {
    menu: PopupMenuControl<RowMenuContent>;
    click(): Promise<void>;
}
declare class StickyTableSideBar extends CompoundControl {
    rowsMenu: ControlList<RowMenu>;
    removeRowButtons: ControlList<RemoveButton>;
}
export declare class StickyTableSideBarWithRows<TRow> extends CompoundControl {
    rows: ControlList<TRow>;
    constructor(context: ISearchContext, selector: ISelector, childFactory: ControlConsructor<TRow>);
    static of<T>(rowFactory: ControlConsructor<T>): ControlConsructor<StickyTableSideBarWithRows<T>>;
}
export declare class StickyTableControl<TRow> extends CompoundControl {
    static defaultElementSelector: string;
    rows: ControlList<TRow>;
    addButton: ButtonControl;
    pager: PagerControl;
    sideBar: StickyTableSideBar;
    scollToRightArrow: ClickableAreaControl;
    scollToLeftArrow: ClickableAreaControl;
    constructor(context: ISearchContext, selector: ISelector, childFactory: ControlConsructor<TRow>);
    static withRow<T>(childFactory: ControlConsructor<T>): ControlConsructor<StickyTableControl<T>>;
    addRow(): Promise<void>;
    getMultilineByPath<T>(bindingPath: string, row: ControlConsructor<T>): MultilineControl<T>;
    getSidebarByPath<T>(bindingPath: string, rowFactory: ControlConsructor<T>): StickyTableSideBarWithRows<T>;
    getPagerByPath<T>(bindingPath: string): PagerControl;
}
export {};

export declare class TableCellPencilControl extends ClickableAreaControl {
}

export declare class TooltipContentBaseControl extends ControlBase {
    constructor(context: ISearchContext, selector: ISelector);
    getSelectorResultForChildSearch(): Promise<ReactSelectorResultHandle>;
}

declare class ModalTourStepControl extends CompoundControl {
    getContentAs<T>(content: ControlConsructor<T>): T;
}
declare class TooltipTourStepControl extends CompoundControl {
    getContentAs<T>(content: ControlConsructor<T>): T;
}
export declare class TourControl extends CompoundControl {
    currentTooltipStep: TooltipTourStepControl;
    currentModalStep: ModalTourStepControl;
}
export declare class TourStepContentBase extends CompoundControl {
    prevButton: ButtonControl;
    nextButton: ButtonControl;
}
export {};

export declare class FxInputControl extends InputControl {
    static defaultElementSelector: string;
    readonly isValid: Promise<boolean>;
    readonly errorMessage: Promise<undefined | string>;
    readonly fxState: Promise<FxState>;
}
export declare enum FxState {
    Auto = "Auto",
    Manual = "Manual"
}

export declare class RadioGroupControl extends CompoundControl {
    static defaultElementSelector: string;
    readonly value: ExtendedPromise<string>;
    readonly currentValueCaption: ExtendedPromise<undefined | string>;
    selectValueByIndex(index: number): Promise<void>;
    selectValueByValue(value: string): Promise<void>;
}

declare class ModalControl<T> extends CompoundControl {
    constructor(context: ISearchContext, selector: ISelector, contentControl: ControlConsructor<T>);
    readonly content: T;
}
export declare class PicklistControl extends ControlBase {
    static defaultElementSelector: string;
    input: InputControl;
    openButton: ButtonControl;
    open(): Promise<void>;
    readonly text: Promise<string>;
    getModal<TContent>(contentClass: ControlConsructor<TContent>): Promise<ModalControl<TContent>>;
}
export {};

declare class PicklistItemControl extends CompoundControl {
    captions: ControlList<LabelControl>;
    getFieldByIndex(index: number): ExtendedPromise<string>;
    click(): Promise<void>;
}
export declare class PicklistModalContent extends CompoundControl {
    title: LabelControl;
    searchInput: InputControl;
    items: ControlList<PicklistItemControl>;
    checkableItems: ControlList<PicklistItemControl>;
    textRenderTotalCount: LabelControl;
}
export {};

export declare class TextControl extends ControlBase {
    static defaultElementSelector: string;
    readonly text: Promise<string>;
    readonly isValid: Promise<boolean>;
}

export interface ControlConsructor<TControl, TArgs extends any[] = []> {
    defaultElementSelector?: string;
    new (context: ISearchContext, selector: ISelector, ...rest: TArgs): TControl;
    as<T>(this: ControlConsructor<T>, selector?: string): FluentControlInstanceBuilder<T>;
    asRoot<T>(this: ControlConsructor<T>): FluentControlInstanceBuilder<T>;
    with<T>(this: ControlConsructor<T>): FluentControlInstanceBuilder<T>;
    find<T>(this: ControlConsructor<T>, context: ISearchContext): T;
}
interface DownloadedFilesInfo {
    content: string;
    contentType: undefined | string;
    filename: string;
}
export interface ClientSideTestingOptions {
    enableGlobalTestingMode: boolean;
    screenshotsTestingMode: boolean;
}
export declare class BrowserPageWrapper implements ISearchContext {
    readonly rootPage: CandyBrowserPage;
    readonly rootPageWrapper: BrowserPageWrapper;
    constructor(page: CandyBrowserPage, clientSideTestingOptions: ClientSideTestingOptions);
    close(): Promise<void>;
    loadSimplePage(url: string): Promise<void>;
    loadPage<TPage>(pageContructor: ControlConsructor<TPage>, url: string): Promise<TPage>;
    authenticateWithSid(sid: string, domain?: string): Promise<void>;
    authenticateWithExternSession(externSession: string, domain?: string): Promise<void>;
    getSelectorResultForChildSearch(): Promise<ReactSelectorResultHandle>;
    getSelectorDescription(): string;
    expectDownloadedFile(filter: (x: DownloadedFilesInfo) => boolean, timeout?: number): Promise<string>;
    enableTestingModeViaCookies(): Promise<void>;
    takePageScreenshot(): Promise<Buffer>;
}
export {};

export declare class FluentControlInstanceBuilder<T> {
    controlContructor: ControlConsructor<T>;
    selector?: ISelector;
    constructor(controlContructor: ControlConsructor<T>, selector?: ISelector);
    getSelectorStrict(): ISelector;
    reactElement(reactSelector: string): FluentControlInstanceBuilder<T>;
    cssSelector(selector: string): FluentControlInstanceBuilder<T>;
    with(): FluentControlInstanceBuilder<T>;
    bindingPath(bindingPath: string): FluentControlInstanceBuilder<T>;
    id(idValue: string): FluentControlInstanceBuilder<T>;
    prop(propName: string, propValue: number | string | string[]): FluentControlInstanceBuilder<T>;
    find(searchContext: ISearchContext): T;
    tid(tidString: string): FluentControlInstanceBuilder<T>;
}

export declare type ReactSelectorResultHandle = CandyBroserSideObjectHandle1<ReactSelectorResult>;
export declare function evaluateHandler<TR, TA extends Array<ExecuteScriptArgs<any>>>(page: CandyBrowserPage, script: ((...args: ExtractHandleTypes<TA>) => TR), ...args: TA): Promise<CandyBroserSideObjectHandle1<TR>>;

export interface DownloadedFilesInfo {
    content: string;
    contentType: undefined | string;
    filename: string;
}
export declare class CandyBrowserPage {
    pressCtrlA(): Promise<void>;
    down(key: string): Promise<void>;
    press(key: string): Promise<void>;
    up(key: string): Promise<void>;
    goto(url: string): Promise<void>;
    scrollTo(x: number, y: number): Promise<void>;
    changeZoom(zoomValue: string): Promise<void>;
    moveMouseTo(x: number, y: number): Promise<void>;
    release(): Promise<void>;
    expectDownloadedFile(filter: (x: DownloadedFilesInfo) => boolean, timeout?: number): Promise<string>;
    evaluateScript(script: string): Promise<void>;
    evaluatePromisedExpression(script: string): Promise<void>;
    evaluateExpressionAsHandle(script: string): Promise<CandyBroserSideObjectHandle>;
    evaluateFunctionAsHandle<TR, TA extends Array<ExecuteScriptArgs<any>>>(script: ((...args: ExtractHandleTypes<TA>) => TR), ...args: TA): Promise<CandyBroserSideObjectHandle1<TR>>;
    setCookie(...cookies: CandyCookie[]): Promise<void>;
    url(): Promise<string>;
    takePageScreenshot(): Promise<Buffer>;
    setWindowSize(width: number, height: number): Promise<void>;
    dangerouslyGetWebDriverInstance(): WebDriver;
    uploadFileIntoInputFileElement(elementHandle: CandyWebElementHandle, fileName: string): Promise<void>;
    goToNextTab(): Promise<void>;
}
export interface CandyBroserSideObjectHandle1<T> extends CandyBroserSideObjectHandle {
    jsonValue(): Promise<T>;
}
export declare type ExecuteScriptArgs<T> = CandyBroserSideObjectHandle1<T> | CandyWebElementHandle | T;
export declare type ExtractHandleTypes<T> = {
    [P in keyof T]: T[P] extends CandyBroserSideObjectHandle1<infer U> ? U : T[P] extends CandyWebElementHandle ? HTMLElement : T[P];
};
export interface CandyCookie {
    name: string;
    value: string;
    domain?: string;
}

export declare class PageBase extends CompoundControl {
    constructor(context: ISearchContext, selector: ISelector);
    refresh<T extends PageBase>(this: T): ExtendedPromise<T>;
    protected refreshInternal<TPage>(pageContructor: ControlConsructor<TPage>): ExtendedPromise<TPage>;
}

export interface FormSettings {
    setModalContext?: boolean;
    doNotValidateFormOnStart?: boolean;
    resourceHash?: string;
    abonId?: string;
    orgId?: string;
    userId?: string;
    nsUrl?: string;
    draftId: string;
    gfv: string;
    navigationQueryPath?: string;
    navigationPath?: string;
    draftUrl: string;
    ns?: string;
    isIndividual?: boolean;
    isForeign?: boolean;
    isTestServer?: boolean;
    renderCachingForIE8?: boolean;
    normalizationOnServer?: boolean;
    debug?: boolean;
    printFromEditor?: boolean;
    noLoader?: boolean;
    pathDelimiter: string;
    valueNameDelimiter: string;
    multiplicitySymbol: string;
    parentSymbol: string;
    outerPrefix: string;
    childrenAttribute: string;
    valueAttribute: string;
    existAttribute: string;
    errorsAttribute: string;
    warningsAttribute: string;
    autoflagAttribute: string;
    autovalueAttribute: string;
    navAttribute: string;
    certValueAttribute?: string;
    instanceRegExp: RegExp;
    normalizationAttributes: string[];
    formRoot: string;
    keformsUrl: string;
    showFormContainer: boolean;
    templates?: boolean;
    embeddedLogEnabled: boolean;
    allowsend: boolean;
    printInfo: {
        message?: string;
        available?: boolean;
    };
    regions: string[];
    feedbackEnabled?: boolean;
    isINNEnabled?: boolean;
    prevGfvDraftId?: string;
    model?: {
        [path: string]: unknown;
    };
    normativeUrl?: string;
    isDisabledTour?: boolean;
    kewebUrl: string;
    shownTours?: string[];
    resourceZone?: string;
    lang?: string;
}

export interface E2ETestContextOptions {
    accessOutsideOfCurrentMachine: boolean;
    browserDriver: BrowserDriver;
    clientSideTestOptions: ClientSideTestingOptions;
    saveScreenshotOnFailure?: boolean;
    externSession?: boolean;
}
interface TestUrls {
    testPageUrl: string;
    localDebugUrl: string;
}
export interface CandyEditorUrlOptions {
    embeddedLogEnabled?: boolean;
    lang?: string;
    isIndividual?: boolean;
}
export declare class CandyE2ETestContext {
    readonly browserPage: BrowserPageWrapper;
    readonly candyServiceContext: CandyServiceTestContext;
    host: string;
    constructor(candyServiceContext: CandyServiceTestContext, browserPage: BrowserPageWrapper, browserVendor: undefined | BrowserVendor, host: string);
    static initialize(testInstance: IMochaTestContextContainer, candyServiceContext: CandyServiceTestContext, options: E2ETestContextOptions): Promise<CandyE2ETestContext>;
    getBrowserVendor(): BrowserVendor;
    finalize(): Promise<void>;
    buildUrlsForDraft(draftInfo: CreateDraftResponse, urlOptions?: CandyEditorUrlOptions): TestUrls;
    prepareTestPage(): CandyTestPageBuilder;
}
export {};

export interface Outer {
    [key: string]: number | string | boolean;
}
export interface Presentations {
    outer?: Outer;
    clientRequisites?: ClientRequisites;
    formsClientInfo?: ClientInfo;
}
export declare class CandyServiceTestContext {
    readonly konturApi: IKonturApi;
    readonly candyApi: ICandyApi;
    readonly testUserSid: string;
    readonly externSession?: string;
    constructor(konturApi: IKonturApi, candyApi: ICandyApi, testUserAuthInfo: AuthInfo);
    static initialize(domain?: string, externSession?: boolean): Promise<CandyServiceTestContext>;
    createDefaultDraft(gfv: string): Promise<CreateDraftResponse>;
    createDraftFromFuf(fufContent: Buffer): Promise<CreateDraftResponse>;
    setPresentations(draftInfo: CreateDraftResponse, presentations: Presentations): Promise<void>;
}

export interface IMochaTestContextContainer {
    readonly mochaContext: Mocha.Context;
}

export interface ClientInfo {
    Sender?: SenderInfo;
    Recipient?: RecipientInfo;
    CurrentAccount?: AccountInfo;
}
export declare type RecipientInfo = any;
export interface SenderInfo {
    Type?: AccountType;
    Inn?: string;
    Kpp?: string;
    FullName?: string;
    Signer?: SignerInfo;
}
export interface SignerInfo {
    Type: SignerType;
    Certificate: CertificateInfo;
}
export interface CertificateInfo {
    Inn?: string;
    Fio?: Fio;
    Ogrn?: string;
    OgrnIp?: string;
    OrgName?: string;
    RnsFss?: string;
    Region?: string;
}
export declare type Fio = any;
export declare enum AccountType {
    Organization = 1,
    Individual = 2,
    ForeignOrganization = 3,
    CreditOrganization = 4
}
export declare enum SignerType {
    Unknown = 0,
    Chief = 1,
    Representative = 2
}
interface AccountInfo {
    Type?: AccountType;
    Inn?: string;
    FullName?: string;
    ShortName?: string;
    Ogrn?: string;
    Okato?: string;
    Oktmo?: string;
    Okved?: string;
    Okpo?: string;
    Chief?: EmployeeInfo;
    Phone?: string;
    AddressRegistration?: Address;
    AddressActual?: Address;
    Pfr?: PfrInfo;
    Fss?: FssInfo;
    Fns?: FnsInfo;
    Oms?: OmsInfo;
    Organization?: OrganizationInfo;
    Individual?: IndividualInfo;
}
declare type EmployeeInfo = any;
declare type Address = any;
declare type PfrInfo = any;
declare type FssInfo = any;
declare type FnsInfo = any;
declare type OmsInfo = any;
declare type OrganizationInfo = any;
declare type IndividualInfo = any;
export {};

export interface ClientRequisites {
    senderDescription: SenderDescription;
    organizationInfo: OrganizationInfo;
    recipientDescription: null | RecipientDescription;
    metricsInfo: null | MetricsInfo;
}
export interface SenderDescription {
    inn: string;
    kpp: null | string;
    certInfo: null | string;
    certificateFields: CertificateFields;
    type: string;
    requisites: string;
    signerType: SignerType;
}
export interface CertificateFields {
    inn: null | string;
    fio: null | string;
    regInfo: null | string;
    orgInfo: null | string;
    subjectNameIsValid: null | boolean;
}
export interface OrganizationInfo {
    inn: string;
    kpp: null | string;
    type: string;
    requisites: string;
}
export interface RecipientDescription {
    ifnsCode: null | string;
    mriCode: null | string;
    ifnsFromReqsName: null | string;
}
export interface MetricsInfo {
    abonId: null | ServerGuid;
    userId: null | ServerGuid;
    orgId: null | ServerGuid;
}
export declare type ServerGuid = string;
export declare enum SignerType {
    Chief = "Chief",
    Representative = "Representative"
}

export declare class ControlBase implements ISearchContext {
    readonly rootPage: CandyBrowserPage;
    readonly rootPageWrapper: BrowserPageWrapper;
    protected readonly selector: ISelector;
    static defaultElementSelector?: string;
    constructor(context: ISearchContext, selector: ISelector);
    static as<T>(this: ControlConsructor<T>, selector?: string): FluentControlInstanceBuilder<T>;
    static asRoot<T>(this: ControlConsructor<T>, selector?: string): FluentControlInstanceBuilder<T>;
    static find<T>(this: ControlConsructor<T>, context: ISearchContext): T;
    static with<T>(this: ControlConsructor<T>): FluentControlInstanceBuilder<T>;
    protected getRootElement(): Promise<CandyWebElementHandle>;
    hover(): Promise<void>;
    getSelectorResultForChildSearch(): Promise<ReactSelectorResultHandle>;
    protected getSelectorResult(): Promise<ReactSelectorResultHandle>;
    getProp<T>(propName: string): ExtendedPromise<T>;
    isPresent(): ExtendedPromise<boolean>;
    getSelectorDescription(): string;
    takeScreenshot(): Promise<string>;
    hide(): Promise<void>;
    show(): Promise<void>;
    goToNextTab(): Promise<void>;
}

export interface CandyBroserSideObjectHandle {
    jsonValue(): Promise<any>;
    asElement(): Promise<undefined | CandyWebElementHandle>;
}

export interface CandyWebElementHandle {
    click(): Promise<void>;
    hover(): Promise<void>;
    focus(): Promise<void>;
    type(text: string): Promise<void>;
    getProperty(name: string): Promise<string | undefined>;
    textContent(): Promise<string>;
    findByCssSelector(span: string): Promise<undefined | CandyWebElementHandle>;
    takeScreenshot(): Promise<string>;
}

export interface CreateDraftResponse {
    ns: string;
    draftId: string;
    gfv: string;
    editorUrl: string;
}
export declare enum DraftPresentationType {
    fuf = "fuf",
    inner = "inner",
    printed = "printed",
    requisites = "requisites",
    errorLog = "errorLog",
    clientRequisites = "clientRequisites",
    clientInfo = "clientInfo",
    hlInner = "hlInner",
    innerFuf = "innerFuf",
    outer = "outer",
    fufWithAttachments = "fufWithAttachments",
    formsClientInfo = "formsClientInfo"
}
export declare type PresentationContent = unknown;
export interface ICandyApi {
    createDraft(ns: string, gfv: string): Promise<CreateDraftResponse>;
    createDraft(ns: string, gfv: undefined, body: Buffer): Promise<CreateDraftResponse>;
    setPresentation(ns: string, draftId: string, presentationType: DraftPresentationType, presentationContent: PresentationContent): Promise<void>;
    checkAlive(): Promise<void>;
}

export declare type BrowserVendor = "chrome" | "firefox" | "internet explorer";
export declare function checkBrowserVendor(input: undefined): undefined;
export declare function checkBrowserVendor(input: string): BrowserVendor;
export declare function checkBrowserVendor(input: undefined | string): undefined | BrowserVendor;

export declare enum BrowserDriver {
    Puppeteer = 0,
    Selenium = 1
}
export declare type BrowserStartOptions = {
    driver: BrowserDriver.Puppeteer;
} | {
    driver: BrowserDriver.Selenium;
    browser: BrowserVendor;
    seleniumServer: string;
    forceReacquireSeleniumAgent: boolean;
};
export declare class CandyBrowserFactory {
    createBrowser(startOptions: BrowserStartOptions): Promise<CandyBrowser>;
}

export interface WindowSize {
    width: number;
    height: number;
}
export declare class CandyTestPageBuilder {
    constructor(e2eTestContext: CandyE2ETestContext);
    withFuf(fufContent: Buffer): CandyTestPageBuilder;
    withDefaultDraft(gfv: string): CandyTestPageBuilder;
    withClientRequisites(clientRequisites: ClientRequisites): CandyTestPageBuilder;
    withInitialWindowSize(windowSize: undefined | WindowSize): CandyTestPageBuilder;
    withUrlOptions(urlOptions: CandyEditorUrlOptions): CandyTestPageBuilder;
    withEmbeddedLog(): CandyTestPageBuilder;
    withIsIndividual(): CandyTestPageBuilder;
    withOuter(outer: Outer): CandyTestPageBuilder;
    andOpenAs<TPage>(pageConstructor: ControlConsructor<TPage>): Promise<TPage>;
    withFormsClientInfo(formsClientInfo: ClientInfo): CandyTestPageBuilder;
}

export interface IKonturApi {
    getAuthInfoFromExternSession(domain: string): Promise<AuthInfo>;
    getAuthInfoFromAuth(login: string, password: string): Promise<AuthInfo>;
    getAuthSid(login: string, password: string): Promise<string>;
}
export interface AuthInfo {
    authSid: string;
    externSession?: string;
}
export declare class KonturApi implements IKonturApi {
    constructor(baseUrl: string);
    getAuthInfoFromExternSession(domain: string): Promise<AuthInfo>;
    getAuthInfoFromAuth(login: string, password: string): Promise<AuthInfo>;
    getAuthSid(login: string, password: string): Promise<string>;
}

export interface CandyBrowser {
    acquireTestPage(): Promise<CandyBrowserPage>;
}