@redhat-developer/page-objects 1.0.0

package/out/components/sidebar/ViewTitlePart.d.ts

@@ -0,0 +1,35 @@
+import { ElementWithContexMenu } from "../ElementWithContextMenu";
+import { AbstractElement } from "../AbstractElement";
+import { By, SideBarView } from "../..";
+/**
+ * Page object representing the top (title) part of a side bar view
+ */
+export declare class ViewTitlePart extends ElementWithContexMenu {
+    constructor(view?: SideBarView);
+    /**
+     * Returns the displayed title of the view
+     * @returns Promise resolving to displayed title
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Finds action buttons inside the view title part
+     * @returns Promise resolving to array of TitleActionButton objects
+     */
+    getActions(): Promise<TitleActionButton[]>;
+    /**
+     * Finds an action button by title
+     * @param title title of the button to search for
+     * @returns Promise resolving to TitleActionButton object
+     */
+    getAction(title: string): Promise<TitleActionButton>;
+}
+/**
+ * Page object representing a button inside the view title part
+ */
+export declare class TitleActionButton extends AbstractElement {
+    constructor(actionConstructor: By, viewTitle: ViewTitlePart);
+    /**
+     * Get title of the button
+     */
+    getTitle(): Promise<string>;
+}

package/out/components/sidebar/ViewTitlePart.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TitleActionButton = exports.ViewTitlePart = void 0;
+const ElementWithContextMenu_1 = require("../ElementWithContextMenu");
+const AbstractElement_1 = require("../AbstractElement");
+const __1 = require("../..");
+/**
+ * Page object representing the top (title) part of a side bar view
+ */
+class ViewTitlePart extends ElementWithContextMenu_1.ElementWithContexMenu {
+    constructor(view = new __1.SideBarView()) {
+        super(ViewTitlePart.locators.ViewTitlePart.constructor, view);
+    }
+    /**
+     * Returns the displayed title of the view
+     * @returns Promise resolving to displayed title
+     */
+    async getTitle() {
+        return await this.findElement(ViewTitlePart.locators.ViewTitlePart.title).getText();
+    }
+    /**
+     * Finds action buttons inside the view title part
+     * @returns Promise resolving to array of TitleActionButton objects
+     */
+    async getActions() {
+        const actions = [];
+        const elements = await this.findElements(ViewTitlePart.locators.ViewTitlePart.action);
+        for (const element of elements) {
+            const title = await element.getAttribute(ViewTitlePart.locators.ViewTitlePart.actionLabel);
+            actions.push(await new TitleActionButton(TitleActionButton.locators.ViewTitlePart.actionConstructor(title), this).wait());
+        }
+        return actions;
+    }
+    /**
+     * Finds an action button by title
+     * @param title title of the button to search for
+     * @returns Promise resolving to TitleActionButton object
+     */
+    async getAction(title) {
+        return new TitleActionButton(TitleActionButton.locators.ViewTitlePart.actionConstructor(title), this);
+    }
+}
+exports.ViewTitlePart = ViewTitlePart;
+/**
+ * Page object representing a button inside the view title part
+ */
+class TitleActionButton extends AbstractElement_1.AbstractElement {
+    constructor(actionConstructor, viewTitle) {
+        super(actionConstructor, viewTitle);
+    }
+    /**
+     * Get title of the button
+     */
+    async getTitle() {
+        return await this.getAttribute(TitleActionButton.locators.ViewTitlePart.actionLabel);
+    }
+}
+exports.TitleActionButton = TitleActionButton;
+//# sourceMappingURL=ViewTitlePart.js.map

package/out/components/sidebar/WelcomeContent.d.ts

@@ -0,0 +1,47 @@
+import { WebElement } from "selenium-webdriver";
+import { AbstractElement } from "../AbstractElement";
+import { ViewSection } from "../..";
+/**
+ * A button that appears in the welcome content and can be clicked to execute a command.
+ *
+ * To execute the command bound to this button simply run: `await button.click();`.
+ */
+export declare class WelcomeContentButton extends AbstractElement {
+    /**
+     * @param panel  The panel containing the button in the welcome section
+     * @param welcomeSection  The enclosing welcome section
+     */
+    constructor(panel: WebElement, welcomeSection: WelcomeContentSection);
+    /** Return the title displayed on this button */
+    getTitle(): Promise<string>;
+}
+/**
+ * A section in an empty custom view, see:
+ * https://code.visualstudio.com/api/extension-guides/tree-view#welcome-content
+ *
+ * The welcome section contains two types of elements: text entries and buttons that can be bound to commands.
+ * The text sections can be accessed via [[getTextSections]], the buttons on the
+ * other hand via [[getButtons]].
+ * This however looses the information of the order of the buttons and lines
+ * with respect to each other. This can be remedied by using [[getContents]],
+ * which returns both in the order that they are found (at the expense, that you
+ * now must use typechecks to find out what you got).
+ */
+export declare class WelcomeContentSection extends AbstractElement {
+    /**
+     * @param panel  The panel containing the welcome content.
+     * @param parent  The webelement in which the welcome content is embedded.
+     */
+    constructor(panel: WebElement, parent: ViewSection);
+    /**
+     * Combination of [[getButtons]] and [[getTextSections]]: returns all entries in the welcome view in the order that they appear.
+     */
+    getContents(): Promise<(WelcomeContentButton | string)[]>;
+    /** Finds all buttons in the welcome content */
+    getButtons(): Promise<WelcomeContentButton[]>;
+    /**
+     * Finds all text entries in the welcome content and returns each line as an
+     * element in an array.
+     */
+    getTextSections(): Promise<string[]>;
+}

package/out/components/sidebar/WelcomeContent.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WelcomeContentSection = exports.WelcomeContentButton = void 0;
+const AbstractElement_1 = require("../AbstractElement");
+/**
+ * A button that appears in the welcome content and can be clicked to execute a command.
+ *
+ * To execute the command bound to this button simply run: `await button.click();`.
+ */
+class WelcomeContentButton extends AbstractElement_1.AbstractElement {
+    /**
+     * @param panel  The panel containing the button in the welcome section
+     * @param welcomeSection  The enclosing welcome section
+     */
+    constructor(panel, welcomeSection) {
+        super(panel, welcomeSection);
+    }
+    /** Return the title displayed on this button */
+    async getTitle() {
+        return await this.getText();
+    }
+}
+exports.WelcomeContentButton = WelcomeContentButton;
+/**
+ * A section in an empty custom view, see:
+ * https://code.visualstudio.com/api/extension-guides/tree-view#welcome-content
+ *
+ * The welcome section contains two types of elements: text entries and buttons that can be bound to commands.
+ * The text sections can be accessed via [[getTextSections]], the buttons on the
+ * other hand via [[getButtons]].
+ * This however looses the information of the order of the buttons and lines
+ * with respect to each other. This can be remedied by using [[getContents]],
+ * which returns both in the order that they are found (at the expense, that you
+ * now must use typechecks to find out what you got).
+ */
+class WelcomeContentSection extends AbstractElement_1.AbstractElement {
+    /**
+     * @param panel  The panel containing the welcome content.
+     * @param parent  The webelement in which the welcome content is embedded.
+     */
+    constructor(panel, parent) {
+        super(panel, parent);
+    }
+    /**
+     * Combination of [[getButtons]] and [[getTextSections]]: returns all entries in the welcome view in the order that they appear.
+     */
+    async getContents() {
+        const elements = await this.findElements(WelcomeContentSection.locators.WelcomeContent.buttonOrText);
+        return Promise.all(elements.map(async (e) => {
+            const tagName = await e.getTagName();
+            if (tagName === "p") {
+                return await e.getText();
+            }
+            else {
+                return new WelcomeContentButton(e, this);
+            }
+        }));
+    }
+    /** Finds all buttons in the welcome content */
+    async getButtons() {
+        return (await this.findElements(WelcomeContentSection.locators.WelcomeContent.button)).map((elem) => new WelcomeContentButton(elem, this));
+    }
+    /**
+     * Finds all text entries in the welcome content and returns each line as an
+     * element in an array.
+     */
+    async getTextSections() {
+        return await Promise.all((await this.findElements(WelcomeContentSection.locators.WelcomeContent.text)).map(async (elem) => await elem.getText()));
+    }
+}
+exports.WelcomeContentSection = WelcomeContentSection;
+//# sourceMappingURL=WelcomeContent.js.map

package/out/components/sidebar/debug/DebugView.d.ts

@@ -0,0 +1,33 @@
+import { SideBarView } from "../SideBarView";
+import { DebugBreakpointSection } from "../tree/debug/DebugBreakpointSection";
+import { DebugVariableSection } from "../tree/debug/DebugVariablesSection";
+/**
+ * Page object representing the Run/Debug view in the side bar
+ */
+export declare class DebugView extends SideBarView {
+    /**
+     * Get the title of the selected launch configuration
+     * @returns Promise resolving to the title
+     */
+    getLaunchConfiguration(): Promise<string>;
+    /**
+     * Get titles of all available launch configurations
+     * @returns Promise resolving to list of titles
+     */
+    getLaunchConfigurations(): Promise<string[]>;
+    getVariablesSection(): Promise<DebugVariableSection>;
+    /**
+     * Get section which holds information about breakpoints.
+     * @returns DebugBreakpointSection page object
+     */
+    getBreakpointSection(): Promise<DebugBreakpointSection>;
+    /**
+     * Select a given launch configuration
+     * @param title title of the configuration to select
+     */
+    selectLaunchConfiguration(title: string): Promise<void>;
+    /**
+     * Start Debugging using the current launch configuration
+     */
+    start(): Promise<void>;
+}

package/out/components/sidebar/debug/DebugView.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugView = void 0;
+const SideBarView_1 = require("../SideBarView");
+const DebugBreakpointSection_1 = require("../tree/debug/DebugBreakpointSection");
+const DebugVariablesSection_1 = require("../tree/debug/DebugVariablesSection");
+/**
+ * Page object representing the Run/Debug view in the side bar
+ */
+class DebugView extends SideBarView_1.SideBarView {
+    /**
+     * Get the title of the selected launch configuration
+     * @returns Promise resolving to the title
+     */
+    async getLaunchConfiguration() {
+        if (DebugView.versionInfo.version >= '1.87.0' && process.platform !== 'darwin') {
+            throw Error(`The 'DebugView.getLaunchConfiguration' method is broken! Read more information in 'Known Issues > Limitations in testing with VS Code 1.87+' - https://github.com/microsoft/vscode/issues/206897.`);
+        }
+        const action = await this.getTitlePart().findElement(DebugView.locators.DebugView.launchCombo);
+        const combo = await action.findElement(DebugView.locators.DebugView.launchSelect);
+        return await combo.getAttribute('title');
+    }
+    /**
+     * Get titles of all available launch configurations
+     * @returns Promise resolving to list of titles
+     */
+    async getLaunchConfigurations() {
+        const action = await this.getTitlePart().findElement(DebugView.locators.DebugView.launchCombo);
+        const combo = await action.findElement(DebugView.locators.DebugView.launchSelect);
+        const configs = [];
+        const options = await combo.findElements(DebugView.locators.DebugView.launchOption);
+        for (const option of options) {
+            if (await option.isEnabled()) {
+                configs.push(await option.getAttribute('value'));
+            }
+        }
+        return configs;
+    }
+    async getVariablesSection() {
+        const content = this.getContent();
+        return content.getSection(DebugVariablesSection_1.DebugVariableSection.locators.DebugVariableSection.predicate, DebugVariablesSection_1.DebugVariableSection);
+    }
+    /**
+     * Get section which holds information about breakpoints.
+     * @returns DebugBreakpointSection page object
+     */
+    async getBreakpointSection() {
+        const content = this.getContent();
+        return content.getSection(DebugBreakpointSection_1.DebugBreakpointSection.locators.DebugBreakpointSection.predicate, DebugBreakpointSection_1.DebugBreakpointSection);
+    }
+    /**
+     * Select a given launch configuration
+     * @param title title of the configuration to select
+     */
+    async selectLaunchConfiguration(title) {
+        const action = await this.getTitlePart().findElement(DebugView.locators.DebugView.launchCombo);
+        const combo = await action.findElement(DebugView.locators.DebugView.launchSelect);
+        const option = await combo.findElement(DebugView.locators.DebugView.optionByName(title));
+        await option.click();
+    }
+    /**
+     * Start Debugging using the current launch configuration
+     */
+    async start() {
+        const action = await this.getTitlePart().findElement(DebugView.locators.DebugView.launchCombo);
+        await action.findElement(DebugView.locators.DebugView.startButton).click();
+    }
+}
+exports.DebugView = DebugView;
+//# sourceMappingURL=DebugView.js.map

package/out/components/sidebar/extensions/ExtensionsViewItem.d.ts

@@ -0,0 +1,48 @@
+import { ViewItem } from "../ViewItem";
+import { WebElement } from "selenium-webdriver";
+import { ContextMenu } from "../../menu/ContextMenu";
+import { ExtensionsViewSection } from "./ExtensionsViewSection";
+/**
+ * Page object representing an extension in the extensions view
+ */
+export declare class ExtensionsViewItem extends ViewItem {
+    constructor(extensionElement: WebElement, section: ExtensionsViewSection);
+    /**
+     * Get title of the extension
+     */
+    getTitle(): Promise<string>;
+    /**
+     * Get version of the extension
+     * @returns Promise resolving to version string
+     */
+    getVersion(): Promise<string>;
+    /**
+     * Get the author of the extension
+     * @returns Promise resolving to displayed author
+     */
+    getAuthor(): Promise<string>;
+    /**
+     * Get the description of the extension
+     * @returns Promise resolving to description
+     */
+    getDescription(): Promise<string>;
+    /**
+     * Find if the extension is installed
+     * @returns Promise resolving to true/false
+     */
+    isInstalled(): Promise<boolean>;
+    /**
+     * Open the management context menu if the extension is installed
+     * @returns Promise resolving to ContextMenu object
+     */
+    manage(): Promise<ContextMenu>;
+    /**
+     * Install the extension if not installed already.
+     *
+     * Will wait for the extension to finish installing. To skip the wait, set timeout to 0.
+     *
+     * @param timeout timeout to wait for the installation in milliseconds, default unlimited, set to 0 to skip waiting
+     * @returns Promise resolving when the installation finishes or is skipped
+     */
+    install(timeout?: number): Promise<void>;
+}

package/out/components/sidebar/extensions/ExtensionsViewItem.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsViewItem = void 0;
+const ViewItem_1 = require("../ViewItem");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * Page object representing an extension in the extensions view
+ */
+class ExtensionsViewItem extends ViewItem_1.ViewItem {
+    constructor(extensionElement, section) {
+        super(extensionElement, section);
+    }
+    /**
+     * Get title of the extension
+     */
+    async getTitle() {
+        const title = await this.findElement(ExtensionsViewItem.locators.ExtensionsViewSection.itemTitle);
+        return await title.getText();
+    }
+    /**
+     * Get version of the extension
+     * @returns Promise resolving to version string
+     */
+    async getVersion() {
+        const version = await this.findElements(ExtensionsViewItem.locators.ExtensionsViewItem.version);
+        if (version.length > 0) {
+            return await version[0].getText();
+        }
+        const label = await this.getAttribute('aria-label');
+        const ver = label.split(',')[1].trim();
+        return ver;
+    }
+    /**
+     * Get the author of the extension
+     * @returns Promise resolving to displayed author
+     */
+    async getAuthor() {
+        const author = await this.findElement(ExtensionsViewItem.locators.ExtensionsViewItem.author);
+        return await author.getText();
+    }
+    /**
+     * Get the description of the extension
+     * @returns Promise resolving to description
+     */
+    async getDescription() {
+        const description = await this.findElement(ExtensionsViewItem.locators.ExtensionsViewItem.description);
+        return await description.getText();
+    }
+    /**
+     * Find if the extension is installed
+     * @returns Promise resolving to true/false
+     */
+    async isInstalled() {
+        const button = await this.findElement(ExtensionsViewItem.locators.ExtensionsViewItem.install);
+        if ((await button.getAttribute('class')).indexOf('disabled') > -1) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Open the management context menu if the extension is installed
+     * @returns Promise resolving to ContextMenu object
+     */
+    async manage() {
+        await this.getDriver().wait(selenium_webdriver_1.until.elementLocated(ExtensionsViewItem.locators.ExtensionsViewItem.manage), 1000);
+        const button = await this.enclosingItem.findElement(ExtensionsViewItem.locators.ExtensionsViewItem.manage);
+        if ((await button.getAttribute('class')).indexOf('disabled') > -1) {
+            throw new Error(`Extension '${await this.getTitle()}' is not installed`);
+        }
+        return await this.openContextMenu();
+    }
+    /**
+     * Install the extension if not installed already.
+     *
+     * Will wait for the extension to finish installing. To skip the wait, set timeout to 0.
+     *
+     * @param timeout timeout to wait for the installation in milliseconds, default unlimited, set to 0 to skip waiting
+     * @returns Promise resolving when the installation finishes or is skipped
+     */
+    async install(timeout = 300000) {
+        if (await this.isInstalled()) {
+            return;
+        }
+        const button = await this.findElement(ExtensionsViewItem.locators.ExtensionsViewItem.install);
+        const manage = await this.findElement(ExtensionsViewItem.locators.ExtensionsViewItem.manage);
+        await button.click();
+        if (timeout > 0) {
+            await this.getDriver().wait(selenium_webdriver_1.until.elementIsVisible(manage), timeout);
+        }
+    }
+}
+exports.ExtensionsViewItem = ExtensionsViewItem;
+//# sourceMappingURL=ExtensionsViewItem.js.map

package/out/components/sidebar/extensions/ExtensionsViewSection.d.ts

@@ -0,0 +1,33 @@
+import { ViewSection } from "../ViewSection";
+import { ExtensionsViewItem } from "./ExtensionsViewItem";
+/**
+ * View section containing extensions
+ */
+export declare class ExtensionsViewSection extends ViewSection {
+    getVisibleItems(): Promise<ExtensionsViewItem[]>;
+    /**
+     * Search for an extension by title. This utilizes the search bar
+     * in the Extensions view, which switches the perspective to the
+     * section representing the chosen category and temporarily hides all other sections.
+     * If you wish to continue working with the initial view section
+     * (i.e. Enabled), use the clearSearch method to reset it back to default
+     *
+     * @param title title to search for in '@category name' format,
+     * e.g '@installed extension'. If no @category is present, marketplace will be searched
+     *
+     * @returns Promise resolving to ExtensionsViewItem if such item exists, undefined otherwise
+     */
+    findItem(title: string): Promise<ExtensionsViewItem | undefined>;
+    /**
+     * Clears the search bar on top of the view
+     * @returns Promise resolving when the search box is cleared
+     */
+    clearSearch(): Promise<void>;
+    /**
+     * Find and open an extension item
+     * @param title title of the extension
+     * @returns Promise resolving when the item is clicked
+     */
+    openItem(title: string): Promise<never[]>;
+    private getSectionForCategory;
+}

package/out/components/sidebar/extensions/ExtensionsViewSection.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsViewSection = void 0;
+const ViewSection_1 = require("../ViewSection");
+const ExtensionsViewItem_1 = require("./ExtensionsViewItem");
+const selenium_webdriver_1 = require("selenium-webdriver");
+/**
+ * Categories of extensions to search for
+ */
+var ExtensionCategory;
+(function (ExtensionCategory) {
+    ExtensionCategory["Installed"] = "@installed";
+    ExtensionCategory["Enabled"] = "@enabled";
+    ExtensionCategory["Disabled"] = "@disabled";
+    ExtensionCategory["Outdated"] = "@outdated";
+    ExtensionCategory["Recommended"] = "@recommended";
+})(ExtensionCategory || (ExtensionCategory = {}));
+/**
+ * View section containing extensions
+ */
+class ExtensionsViewSection extends ViewSection_1.ViewSection {
+    async getVisibleItems() {
+        const extensionTable = await this.findElement(ExtensionsViewSection.locators.ExtensionsViewSection.items);
+        const extensionRows = await extensionTable.findElements(ExtensionsViewSection.locators.ExtensionsViewSection.itemRow);
+        return await Promise.all(extensionRows.map(async (row) => new ExtensionsViewItem_1.ExtensionsViewItem(row, this).wait()));
+    }
+    /**
+     * Search for an extension by title. This utilizes the search bar
+     * in the Extensions view, which switches the perspective to the
+     * section representing the chosen category and temporarily hides all other sections.
+     * If you wish to continue working with the initial view section
+     * (i.e. Enabled), use the clearSearch method to reset it back to default
+     *
+     * @param title title to search for in '@category name' format,
+     * e.g '@installed extension'. If no @category is present, marketplace will be searched
+     *
+     * @returns Promise resolving to ExtensionsViewItem if such item exists, undefined otherwise
+     */
+    async findItem(title) {
+        await this.clearSearch();
+        const progress = await this.enclosingItem.findElement(ExtensionsViewSection.locators.ViewContent.progress);
+        const searchField = await this.enclosingItem.findElement(ExtensionsViewSection.locators.ExtensionsViewSection.searchBox);
+        await searchField.sendKeys(title);
+        try {
+            await this.getDriver().wait(selenium_webdriver_1.until.elementIsVisible(progress), 1000);
+        }
+        catch (err) {
+            if (err.name !== "TimeoutError") {
+                throw err;
+            }
+        }
+        await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(progress));
+        const parent = this.enclosingItem;
+        let sectionTitle = this.getSectionForCategory(title);
+        const section = await parent.getSection(sectionTitle);
+        const titleParts = title.split(' ');
+        if (titleParts[0].startsWith('@')) {
+            title = titleParts.slice(1).join(' ');
+        }
+        const extensions = await section.getVisibleItems();
+        for (const extension of extensions) {
+            if (await extension.getTitle() === title) {
+                return extension;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Clears the search bar on top of the view
+     * @returns Promise resolving when the search box is cleared
+     */
+    async clearSearch() {
+        const progress = await this.enclosingItem.findElement(ExtensionsViewSection.locators.ViewContent.progress);
+        const searchField = await this.enclosingItem.findElement(ExtensionsViewSection.locators.ExtensionsViewSection.searchBox);
+        const textField = await this.enclosingItem.findElement(ExtensionsViewSection.locators.ExtensionsViewSection.textContainer);
+        try {
+            await textField.findElement(ExtensionsViewSection.locators.ExtensionsViewSection.textField);
+            await searchField.sendKeys(selenium_webdriver_1.Key.chord(ExtensionsViewItem_1.ExtensionsViewItem.ctlKey, 'a'), selenium_webdriver_1.Key.BACK_SPACE);
+            await this.getDriver().wait(selenium_webdriver_1.until.elementIsVisible(progress));
+            await this.getDriver().wait(selenium_webdriver_1.until.elementIsNotVisible(progress));
+        }
+        catch (err) {
+            // do nothing, the text field is empty
+        }
+    }
+    /**
+     * Find and open an extension item
+     * @param title title of the extension
+     * @returns Promise resolving when the item is clicked
+     */
+    async openItem(title) {
+        const item = await this.findItem(title);
+        if (item) {
+            await item.click();
+        }
+        return [];
+    }
+    getSectionForCategory(title) {
+        const category = title.split(' ')[0].toLowerCase();
+        switch (category) {
+            case ExtensionCategory.Disabled:
+                return 'Disabled';
+            case ExtensionCategory.Enabled:
+                return 'Enabled';
+            case ExtensionCategory.Installed:
+                return 'Installed';
+            case ExtensionCategory.Outdated:
+                return 'Outdated';
+            case ExtensionCategory.Recommended:
+                return 'Other Recommendations';
+            default:
+                return 'Marketplace';
+        }
+    }
+}
+exports.ExtensionsViewSection = ExtensionsViewSection;
+//# sourceMappingURL=ExtensionsViewSection.js.map

package/out/components/sidebar/scm/NewScmView.d.ts

@@ -0,0 +1,34 @@
+import { ScmView, ScmProvider, ScmChange } from "./ScmView";
+import { ContextMenu } from "../../menu/ContextMenu";
+/**
+ * New SCM view for code 1.47 onwards
+ */
+export declare class NewScmView extends ScmView {
+    getProviders(): Promise<ScmProvider[]>;
+}
+/**
+ * Implementation for a single SCM provider
+ */
+export declare class SingleScmProvider extends ScmProvider {
+    /**
+     * There is no title available for a single provider
+     */
+    getTitle(): Promise<string>;
+    /**
+     * No title available for single provider
+     */
+    getType(): Promise<string>;
+    takeAction(title: string): Promise<boolean>;
+    openMoreActions(): Promise<ContextMenu>;
+    getChanges(staged?: boolean): Promise<ScmChange[]>;
+}
+/**
+ * Implementation of an SCM provider when multiple providers are available
+ */
+export declare class MultiScmProvider extends ScmProvider {
+    takeAction(title: string): Promise<boolean>;
+    openMoreActions(): Promise<ContextMenu>;
+    commitChanges(message: string): Promise<void>;
+    getChanges(staged?: boolean): Promise<ScmChange[]>;
+    getChangeCount(staged?: boolean): Promise<number>;
+}