@codingame/monaco-vscode-api 13.1.7 → 14.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorInput.d.ts

@@ -0,0 +1,57 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { ThemeIcon } from "../../../../base/common/themables.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { EditorInputCapabilities, IEditorSerializer, IUntypedEditorInput } from "../../../common/editor.js";
+import { EditorInput } from "../../../common/editor/editorInput.js";
+import type { IChatEditorOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/chatEditor";
+import { IChatModel } from "../common/chatModel.js";
+import { IChatService } from "../common/chatService.service.js";
+export declare class ChatEditorInput extends EditorInput {
+    readonly resource: URI;
+    readonly options: IChatEditorOptions;
+    private readonly chatService;
+    static readonly countsInUse: Set<number>;
+    static readonly TypeID: string;
+    static readonly EditorID: string;
+    private readonly inputCount;
+    sessionId: string | undefined;
+    private model;
+    static getNewEditorUri(): URI;
+    static getNextCount(): number;
+    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService);
+    get editorId(): string | undefined;
+    get capabilities(): EditorInputCapabilities;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    get typeId(): string;
+    getName(): string;
+    getIcon(): ThemeIcon;
+    resolve(): Promise<ChatEditorModel | null>;
+    dispose(): void;
+}
+export declare class ChatEditorModel extends Disposable {
+    readonly model: IChatModel;
+    private _onWillDispose;
+    readonly onWillDispose: import("../../../../base/common/event.js").Event<void>;
+    private _isDisposed;
+    private _isResolved;
+    constructor(model: IChatModel);
+    resolve(): Promise<void>;
+    isResolved(): boolean;
+    isDisposed(): boolean;
+    dispose(): void;
+}
+export declare namespace ChatUri {
+    const scheme = "vscode-chat-editor";
+    function generate(handle: number): URI;
+    function parse(resource: URI): {
+        handle: number;
+    } | undefined;
+}
+export declare class ChatEditorInputSerializer implements IEditorSerializer {
+    canSerialize(input: EditorInput): input is ChatEditorInput & {
+        readonly sessionId: string;
+    };
+    serialize(input: EditorInput): string | undefined;
+    deserialize(instantiationService: IInstantiationService, serializedEditor: string): EditorInput | undefined;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorInput.js

@@ -0,0 +1,169 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { toDisposable, Disposable } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localize } from '../../../../nls.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { EditorInputCapabilities } from '../../../common/editor.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { ChatAgentLocation } from '../common/chatAgents.js';
+import { IChatService } from '../common/chatService.service.js';
+
+var ChatEditorInput_1;
+const ChatEditorIcon = registerIcon('chat-editor-label-icon', Codicon.commentDiscussion, ( localize(4522, 'Icon of the chat editor label.')));
+let ChatEditorInput = class ChatEditorInput extends EditorInput {
+    static { ChatEditorInput_1 = this; }
+    static { this.countsInUse = ( new Set()); }
+    static { this.TypeID = 'workbench.input.chatSession'; }
+    static { this.EditorID = 'workbench.editor.chatSession'; }
+    static getNewEditorUri() {
+        const handle = Math.floor(Math.random() * 1e9);
+        return ChatUri.generate(handle);
+    }
+    static getNextCount() {
+        let count = 0;
+        while (( ChatEditorInput_1.countsInUse.has(count))) {
+            count++;
+        }
+        return count;
+    }
+    constructor(resource, options, chatService) {
+        super();
+        this.resource = resource;
+        this.options = options;
+        this.chatService = chatService;
+        const parsed = ChatUri.parse(resource);
+        if (typeof parsed?.handle !== 'number') {
+            throw ( new Error('Invalid chat URI'));
+        }
+        this.sessionId = (options.target && 'sessionId' in options.target) ?
+            options.target.sessionId :
+            undefined;
+        this.inputCount = ChatEditorInput_1.getNextCount();
+        ChatEditorInput_1.countsInUse.add(this.inputCount);
+        this._register(toDisposable(() => ChatEditorInput_1.countsInUse.delete(this.inputCount)));
+    }
+    get editorId() {
+        return ChatEditorInput_1.EditorID;
+    }
+    get capabilities() {
+        return super.capabilities | EditorInputCapabilities.Singleton;
+    }
+    matches(otherInput) {
+        return otherInput instanceof ChatEditorInput_1 && ( otherInput.resource.toString()) === ( this.resource.toString());
+    }
+    get typeId() {
+        return ChatEditorInput_1.TypeID;
+    }
+    getName() {
+        return this.model?.title || ( localize(4523, "Chat")) + (this.inputCount > 0 ? ` ${this.inputCount + 1}` : '');
+    }
+    getIcon() {
+        return ChatEditorIcon;
+    }
+    async resolve() {
+        if (typeof this.sessionId === 'string') {
+            this.model = this.chatService.getOrRestoreSession(this.sessionId);
+        }
+        else if (!this.options.target) {
+            this.model = this.chatService.startSession(ChatAgentLocation.Panel, CancellationToken.None);
+        }
+        else if ('data' in this.options.target) {
+            this.model = this.chatService.loadSessionFromContent(this.options.target.data);
+        }
+        if (!this.model) {
+            return null;
+        }
+        this.sessionId = this.model.sessionId;
+        this._register(this.model.onDidChange(() => this._onDidChangeLabel.fire()));
+        return this._register(( new ChatEditorModel(this.model)));
+    }
+    dispose() {
+        super.dispose();
+        if (this.sessionId) {
+            this.chatService.clearSession(this.sessionId);
+        }
+    }
+};
+ChatEditorInput = ChatEditorInput_1 = ( __decorate([
+    ( __param(2, IChatService))
+], ChatEditorInput));
+class ChatEditorModel extends Disposable {
+    constructor(model) {
+        super();
+        this.model = model;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this._isDisposed = false;
+        this._isResolved = false;
+    }
+    async resolve() {
+        this._isResolved = true;
+    }
+    isResolved() {
+        return this._isResolved;
+    }
+    isDisposed() {
+        return this._isDisposed;
+    }
+    dispose() {
+        super.dispose();
+        this._isDisposed = true;
+    }
+}
+var ChatUri;
+(function (ChatUri) {
+    ChatUri.scheme = Schemas.vscodeChatSesssion;
+    function generate(handle) {
+        return ( URI.from({ scheme: ChatUri.scheme, path: `chat-${handle}` }));
+    }
+    ChatUri.generate = generate;
+    function parse(resource) {
+        if (resource.scheme !== ChatUri.scheme) {
+            return undefined;
+        }
+        const match = resource.path.match(/chat-(\d+)/);
+        const handleStr = match?.[1];
+        if (typeof handleStr !== 'string') {
+            return undefined;
+        }
+        const handle = parseInt(handleStr);
+        if (isNaN(handle)) {
+            return undefined;
+        }
+        return { handle };
+    }
+    ChatUri.parse = parse;
+})(ChatUri || (ChatUri = {}));
+class ChatEditorInputSerializer {
+    canSerialize(input) {
+        return input instanceof ChatEditorInput && typeof input.sessionId === 'string';
+    }
+    serialize(input) {
+        if (!this.canSerialize(input)) {
+            return undefined;
+        }
+        const obj = {
+            options: input.options,
+            sessionId: input.sessionId,
+            resource: input.resource
+        };
+        return JSON.stringify(obj);
+    }
+    deserialize(instantiationService, serializedEditor) {
+        try {
+            const parsed = JSON.parse(serializedEditor);
+            const resource = URI.revive(parsed.resource);
+            return instantiationService.createInstance(ChatEditorInput, resource, { ...parsed.options, target: { sessionId: parsed.sessionId } });
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+}
+
+export { ChatEditorInput, ChatEditorInputSerializer, ChatEditorModel, ChatUri };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorOverlay.d.ts

@@ -0,0 +1,20 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { ICodeEditor } from "../../../../editor/browser/editorBrowser.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { IChatEditingSession, IModifiedFileEntry } from "../common/chatEditingService.js";
+import { IEditorContribution } from "../../../../editor/common/editorCommon.js";
+export declare class ChatEditorOverlayController implements IEditorContribution {
+    private readonly _editor;
+    private readonly _instaService;
+    static readonly ID = "editor.contrib.chatEditorOverlayController";
+    static get(editor: ICodeEditor): ChatEditorOverlayController | undefined;
+    private readonly _overlayWidget;
+    constructor(_editor: ICodeEditor, _instaService: IInstantiationService);
+    dispose(): void;
+    showRequest(session: IChatEditingSession): void;
+    showEntry(session: IChatEditingSession, activeEntry: IModifiedFileEntry, next: IModifiedFileEntry, indicies: {
+        entryIndex: IObservable<number | undefined>;
+        changeIndex: IObservable<number | undefined>;
+    }): void;
+    hide(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorOverlay.js

@@ -0,0 +1,296 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
+import '../../../../base/common/arrays.js';
+import '../../../../base/common/event.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/cancellation.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { OverlayWidgetPositionPreference } from '../../../../editor/browser/editorBrowser.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../platform/actions/browser/toolbar.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { append, $, addDisposableGenericMouseMoveListener, reset } from '../../../../base/browser/dom.js';
+import { renderIcon } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { assertType } from '../../../../base/common/types.js';
+import { localize } from '../../../../nls.js';
+import { navigationBearingFakeActionId, AcceptAction, RejectAction } from './chatEditorActions.js';
+import { ChatEditorController } from './chatEditorController.js';
+import './media/chatEditorOverlay.css.js';
+import { findDiffEditorContainingCodeEditor } from '../../../../editor/browser/widget/diffEditor/commands.js';
+import { IChatService } from '../common/chatService.service.js';
+import { rcut } from '../../../../base/common/strings.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
+import { Lazy } from '../../../../base/common/lazy.js';
+
+var ChatEditorOverlayController_1;
+let ChatEditorOverlayWidget = class ChatEditorOverlayWidget {
+    constructor(_editor, editorService, _hoverService, _chatService, _instaService) {
+        this._editor = _editor;
+        this._hoverService = _hoverService;
+        this._chatService = _chatService;
+        this._instaService = _instaService;
+        this.allowEditorOverflow = true;
+        this._isAdded = false;
+        this._showStore = ( new DisposableStore());
+        this._entry = observableValue(this, undefined);
+        this._navigationBearings = observableValue(this, { changeCount: -1, activeIdx: -1, entriesCount: -1 });
+        this._domNode = document.createElement('div');
+        this._domNode.classList.add('chat-editor-overlay-widget');
+        const progressNode = document.createElement('div');
+        progressNode.classList.add('chat-editor-overlay-progress');
+        append(progressNode, renderIcon(ThemeIcon.modify(Codicon.loading, 'spin')));
+        this._progressNode = append(progressNode, $('SPAN.busy-label'));
+        this._domNode.appendChild(progressNode);
+        const toolbarNode = document.createElement('div');
+        toolbarNode.classList.add('chat-editor-overlay-toolbar');
+        this._domNode.appendChild(toolbarNode);
+        this._toolbar = _instaService.createInstance(MenuWorkbenchToolBar, toolbarNode, MenuId.ChatEditingEditorContent, {
+            telemetrySource: 'chatEditor.overlayToolbar',
+            hiddenItemStrategy: HiddenItemStrategy.Ignore,
+            toolbarOptions: {
+                primaryGroup: () => true,
+                useSeparatorsInPrimaryActions: true
+            },
+            menuOptions: { renderShortTitle: true },
+            actionViewItemProvider: (action, options) => {
+                const that = this;
+                if (action.id === navigationBearingFakeActionId) {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: false, label: true, keybindingNotRenderedWithLabel: true });
+                        }
+                        render(container) {
+                            super.render(container);
+                            container.classList.add('label-item');
+                            this._store.add(autorun(r => {
+                                assertType(this.label);
+                                const { changeCount, activeIdx } = that._navigationBearings.read(r);
+                                const n = activeIdx === -1 ? '?' : `${activeIdx + 1}`;
+                                const m = changeCount === -1 ? '?' : `${changeCount}`;
+                                this.label.innerText = ( localize(4524, "{0} of {1}", n, m));
+                                this.updateTooltip();
+                            }));
+                        }
+                        getTooltip() {
+                            const { changeCount, entriesCount } = that._navigationBearings.get();
+                            if (changeCount === -1 || entriesCount === -1) {
+                                return undefined;
+                            }
+                            else if (changeCount === 1 && entriesCount === 1) {
+                                return localize(4525, "1 change in 1 file");
+                            }
+                            else if (changeCount === 1) {
+                                return localize(4526, "1 change in {0} files", entriesCount);
+                            }
+                            else if (entriesCount === 1) {
+                                return localize(4527, "{0} changes in 1 file", changeCount);
+                            }
+                            else {
+                                return localize(4528, "{0} changes in {1} files", changeCount, entriesCount);
+                            }
+                        }
+                        onClick(event, preserveFocus) {
+                            ChatEditorController.get(that._editor)?.unlockScroll();
+                        }
+                    });
+                }
+                if (action.id === AcceptAction.ID || action.id === RejectAction.ID) {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: false, label: true, keybindingNotRenderedWithLabel: true });
+                            this._reveal = this._store.add(( new MutableDisposable()));
+                        }
+                        render(container) {
+                            super.render(container);
+                            if (action.id === AcceptAction.ID) {
+                                const listener = this._store.add(( new MutableDisposable()));
+                                this._store.add(autorun(r => {
+                                    assertType(this.label);
+                                    assertType(this.element);
+                                    const ctrl = that._entry.read(r)?.entry.autoAcceptController.read(r);
+                                    if (ctrl) {
+                                        const r = -100 * (ctrl.remaining / ctrl.total);
+                                        this.element.style.setProperty('--vscode-action-item-auto-timeout', `${r}%`);
+                                        this.element.classList.toggle('auto', true);
+                                        listener.value = addDisposableGenericMouseMoveListener(this.element, () => ctrl.cancel());
+                                    }
+                                    else {
+                                        this.element.classList.toggle('auto', false);
+                                        listener.clear();
+                                    }
+                                }));
+                            }
+                        }
+                        set actionRunner(actionRunner) {
+                            super.actionRunner = actionRunner;
+                            const store = ( new DisposableStore());
+                            store.add(actionRunner.onWillRun(_e => {
+                                that._editor.focus();
+                            }));
+                            store.add(actionRunner.onDidRun(e => {
+                                if (e.action !== this.action) {
+                                    return;
+                                }
+                                const d = that._entry.get();
+                                if (!d || d.entry === d.next) {
+                                    return;
+                                }
+                                const change = d.next.diffInfo.get().changes.at(0);
+                                return editorService.openEditor({
+                                    resource: d.next.modifiedURI,
+                                    options: {
+                                        selection: change && Range.fromPositions({ lineNumber: change.original.startLineNumber, column: 1 }),
+                                        revealIfOpened: false,
+                                        revealIfVisible: false,
+                                    }
+                                }, ACTIVE_GROUP);
+                            }));
+                            this._reveal.value = store;
+                        }
+                        get actionRunner() {
+                            return super.actionRunner;
+                        }
+                    });
+                }
+                return undefined;
+            }
+        });
+    }
+    dispose() {
+        this.hide();
+        this._showStore.dispose();
+        this._toolbar.dispose();
+    }
+    getId() {
+        return 'chatEditorOverlayWidget';
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return { preference: OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER };
+    }
+    showRequest(session) {
+        this._showStore.clear();
+        const chatModel = this._chatService.getSession(session.chatSessionId);
+        const chatRequest = chatModel?.getRequests().at(-1);
+        if (!chatRequest || !chatRequest.response) {
+            this.hide();
+            return;
+        }
+        this._domNode.classList.toggle('busy', true);
+        const message = rcut(chatRequest.message.text, 47);
+        reset(this._progressNode, message);
+        this._showStore.add(this._hoverService.setupDelayedHover(this._progressNode, {
+            content: chatRequest.message.text,
+            appearance: { showPointer: true }
+        }));
+        this._show();
+    }
+    showEntry(session, activeEntry, next, indicies) {
+        this._showStore.clear();
+        this._entry.set({ entry: activeEntry, next }, undefined);
+        this._showStore.add(autorun(r => {
+            const busy = activeEntry.isCurrentlyBeingModified.read(r);
+            this._domNode.classList.toggle('busy', busy);
+        }));
+        this._showStore.add(autorun(r => {
+            const value = activeEntry.rewriteRatio.read(r);
+            reset(this._progressNode, (value === 0
+                ? ( localize(4529, "Generating Edits"))
+                : ( localize(4530, "{0}% Applying Edits", Math.round(value * 100)))));
+        }));
+        this._showStore.add(autorun(r => {
+            const entryIndex = indicies.entryIndex.read(r);
+            const changeIndex = indicies.changeIndex.read(r);
+            const entries = session.entries.read(r);
+            let activeIdx = entryIndex !== undefined && changeIndex !== undefined
+                ? changeIndex
+                : -1;
+            let changes = 0;
+            for (let i = 0; i < entries.length; i++) {
+                const diffInfo = entries[i].diffInfo.read(r);
+                changes += diffInfo.changes.length;
+                if (entryIndex !== undefined && i < entryIndex) {
+                    activeIdx += diffInfo.changes.length;
+                }
+            }
+            this._navigationBearings.set({ changeCount: changes, activeIdx, entriesCount: entries.length }, undefined);
+        }));
+        this._show();
+    }
+    _show() {
+        const editorWidthObs = observableFromEvent(this._editor.onDidLayoutChange, () => {
+            const diffEditor = this._instaService.invokeFunction(findDiffEditorContainingCodeEditor, this._editor);
+            return diffEditor
+                ? diffEditor.getOriginalEditor().getLayoutInfo().contentWidth + diffEditor.getModifiedEditor().getLayoutInfo().contentWidth
+                : this._editor.getLayoutInfo().contentWidth;
+        });
+        this._showStore.add(autorun(r => {
+            const width = editorWidthObs.read(r);
+            this._domNode.style.maxWidth = `${width - 20}px`;
+        }));
+        if (!this._isAdded) {
+            this._editor.addOverlayWidget(this);
+            this._isAdded = true;
+        }
+    }
+    hide() {
+        transaction(tx => {
+            this._entry.set(undefined, tx);
+            this._navigationBearings.set({ changeCount: -1, activeIdx: -1, entriesCount: -1 }, tx);
+        });
+        if (this._isAdded) {
+            this._editor.removeOverlayWidget(this);
+            this._isAdded = false;
+            this._showStore.clear();
+        }
+    }
+};
+ChatEditorOverlayWidget = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, IHoverService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IInstantiationService))
+], ChatEditorOverlayWidget));
+let ChatEditorOverlayController = class ChatEditorOverlayController {
+    static { ChatEditorOverlayController_1 = this; }
+    static { this.ID = 'editor.contrib.chatEditorOverlayController'; }
+    static get(editor) {
+        return editor.getContribution(ChatEditorOverlayController_1.ID) ?? undefined;
+    }
+    constructor(_editor, _instaService) {
+        this._editor = _editor;
+        this._instaService = _instaService;
+        this._overlayWidget = ( new Lazy(
+            () => this._instaService.createInstance(ChatEditorOverlayWidget, this._editor)
+        ));
+    }
+    dispose() {
+        this.hide();
+        this._overlayWidget.rawValue?.dispose();
+    }
+    showRequest(session) {
+        this._overlayWidget.value.showRequest(session);
+    }
+    showEntry(session, activeEntry, next, indicies) {
+        this._overlayWidget.value.showEntry(session, activeEntry, next, indicies);
+    }
+    hide() {
+        this._overlayWidget.rawValue?.hide();
+    }
+};
+ChatEditorOverlayController = ChatEditorOverlayController_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ChatEditorOverlayController));
+
+export { ChatEditorOverlayController };

package/vscode/src/vs/workbench/contrib/chat/browser/chatQuotasService.d.ts

@@ -0,0 +1,41 @@
+import { Event } from "../../../../base/common/event.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IWorkbenchContribution } from "../../../common/contributions.js";
+import { IStatusbarService } from "../../../services/statusbar/browser/statusbar.service.js";
+import { IChatQuotasService } from "./chatQuotasService.service.js";
+export interface IChatQuotas {
+    chatQuotaExceeded: boolean;
+    completionsQuotaExceeded: boolean;
+    quotaResetDate: Date | undefined;
+}
+export declare const OPEN_CHAT_QUOTA_EXCEEDED_DIALOG = "workbench.action.chat.openQuotaExceededDialog";
+export declare class ChatQuotasService extends Disposable implements IChatQuotasService {
+    private readonly contextKeyService;
+    _serviceBrand: undefined;
+    private readonly _onDidChangeQuotas;
+    readonly onDidChangeQuotas: Event<void>;
+    private _quotas;
+    get quotas(): IChatQuotas;
+    private readonly chatQuotaExceededContextKey;
+    private readonly completionsQuotaExceededContextKey;
+    private ExtensionQuotaContextKeys;
+    constructor(contextKeyService: IContextKeyService);
+    private registerListeners;
+    private registerActions;
+    acceptQuotas(quotas: IChatQuotas): void;
+    clearQuotas(): void;
+    private updateContextKeys;
+}
+export declare class ChatQuotasStatusBarEntry extends Disposable implements IWorkbenchContribution {
+    private readonly statusbarService;
+    private readonly chatQuotasService;
+    static readonly ID = "chat.quotasStatusBarEntry";
+    private readonly entry;
+    constructor(statusbarService: IStatusbarService, chatQuotasService: IChatQuotasService);
+    private updateStatusbarEntry;
+}
+export declare function quotaToButtonMessage({ chatQuotaExceeded, completionsQuotaExceeded }: {
+    chatQuotaExceeded: boolean;
+    completionsQuotaExceeded: boolean;
+}): string;