@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service.d.ts

@@ -9,11 +9,28 @@ import { WebviewInput } from "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6
 import { WebviewIconManager, WebviewIcons } from "@codingame/monaco-vscode-7f39b6f1-3542-5430-8760-0f404d7a7cee-common/vscode/vs/workbench/contrib/webviewPanel/browser/webviewIconManager";
 import { IWebViewShowOptions, WebviewResolver } from "@codingame/monaco-vscode-7f39b6f1-3542-5430-8760-0f404d7a7cee-common/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService";
 export declare const IWebviewWorkbenchService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWebviewWorkbenchService>;
+/**
+* Service responsible for showing and managing webview editors in the workbench.
+*/
 export interface IWebviewWorkbenchService {
     readonly _serviceBrand: undefined;
+    /**
+    * Manages setting the icons show for a given webview.
+    */
     readonly iconManager: WebviewIconManager;
+    /**
+    * Event fired when focus switches to a different webview editor.
+    *
+    * Fires `undefined` if focus switches to a non-webview editor.
+    */
     readonly onDidChangeActiveWebviewEditor: Event<WebviewInput | undefined>;
+    /**
+    * Create a new webview editor and open it in the workbench.
+    */
     openWebview(webviewInitInfo: WebviewInitInfo, viewType: string, title: string, showOptions: IWebViewShowOptions): WebviewInput;
+    /**
+    * Open a webview that is being restored from serialization.
+    */
     openRevivedWebview(options: {
         webviewInitInfo: WebviewInitInfo;
         viewType: string;
@@ -22,8 +39,22 @@ export interface IWebviewWorkbenchService {
         state: any;
         group: number | undefined;
     }): WebviewInput;
+    /**
+    * Reveal an already opened webview editor in the workbench.
+    */
     revealWebview(webview: WebviewInput, group: IEditorGroup | GroupIdentifier | ACTIVE_GROUP_TYPE | SIDE_GROUP_TYPE, preserveFocus: boolean): void;
+    /**
+    * Register a new {@link WebviewResolver}.
+    *
+    * If there are any webviews awaiting revival that this resolver can handle, they will be resolved by it.
+    */
     registerResolver(resolver: WebviewResolver): IDisposable;
+    /**
+    * Check if a webview should be serialized across window reloads.
+    */
     shouldPersist(input: WebviewInput): boolean;
+    /**
+    * Try to resolve a webview. This will block until a resolver is registered for the webview.
+    */
     resolveWebview(webview: WebviewInput, token: CancellationToken): Promise<void>;
 }

package/vscode/src/vs/workbench/contrib/webviewView/browser/webviewViewService.service.d.ts

@@ -5,9 +5,19 @@ import { IWebviewViewResolver, WebviewView } from "@codingame/monaco-vscode-view
 export declare const IWebviewViewService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWebviewViewService>;
 export interface IWebviewViewService {
     readonly _serviceBrand: undefined;
+    /**
+    * Fired when a resolver has been registered
+    */
     readonly onNewResolverRegistered: Event<{
         readonly viewType: string;
     }>;
+    /**
+    * Register a new {@link IWebviewViewResolver webview view resolver}.
+    */
     register(viewType: string, resolver: IWebviewViewResolver): IDisposable;
+    /**
+    * Try to resolve a webview view. The promise will not resolve until a resolver for the webview has been registered
+    * and run
+    */
     resolve(viewType: string, webview: WebviewView, cancellation: CancellationToken): Promise<void>;
 }

package/vscode/src/vs/workbench/services/activity/common/activity.service.d.ts

@@ -5,11 +5,32 @@ import { IActivity } from "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0
 export declare const IActivityService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IActivityService>;
 export interface IActivityService {
     readonly _serviceBrand: undefined;
+    /**
+    * Emitted when activity changes for a view container or when the activity of the global actions change.
+    */
     readonly onDidChangeActivity: Event<string | ViewContainer>;
+    /**
+    * Show activity for the given view container
+    */
     showViewContainerActivity(viewContainerId: string, badge: IActivity): IDisposable;
+    /**
+    * Returns the activity for the given view container
+    */
     getViewContainerActivities(viewContainerId: string): IActivity[];
+    /**
+    * Show activity for the given view
+    */
     showViewActivity(viewId: string, badge: IActivity): IDisposable;
+    /**
+    * Show accounts activity
+    */
     showAccountsActivity(activity: IActivity): IDisposable;
+    /**
+    * Show global activity
+    */
     showGlobalActivity(activity: IActivity): IDisposable;
+    /**
+    * Return the activity for the given action
+    */
     getActivity(id: string): IActivity[];
 }

package/vscode/src/vs/workbench/services/authentication/browser/authenticationAccessService.service.d.ts

@@ -7,6 +7,14 @@ export interface IAuthenticationAccessService {
         providerId: string;
         accountName: string;
     }>;
+    /**
+    * Check extension access to an account
+    * @param providerId The id of the authentication provider
+    * @param accountName The account name that access is checked for
+    * @param extensionId The id of the extension requesting access
+    * @returns Returns true or false if the user has opted to permanently grant or disallow access, and undefined
+    * if they haven't made a choice yet
+    */
     isAccessAllowed(providerId: string, accountName: string, extensionId: string): boolean | undefined;
     readAllowedExtensions(providerId: string, accountName: string): AllowedExtension[];
     updateAllowedExtensions(providerId: string, accountName: string, extensions: AllowedExtension[]): void;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpAccessService.service.d.ts

@@ -7,6 +7,14 @@ export interface IAuthenticationMcpAccessService {
         providerId: string;
         accountName: string;
     }>;
+    /**
+    * Check MCP server access to an account
+    * @param providerId The id of the authentication provider
+    * @param accountName The account name that access is checked for
+    * @param mcpServerId The id of the MCP server requesting access
+    * @returns Returns true or false if the user has opted to permanently grant or disallow access, and undefined
+    * if they haven't made a choice yet
+    */
     isAccessAllowed(providerId: string, accountName: string, mcpServerId: string): boolean | undefined;
     readAllowedMcpServers(providerId: string, accountName: string): AllowedMcpServer[];
     updateAllowedMcpServers(providerId: string, accountName: string, mcpServers: AllowedMcpServer[]): void;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpService.service.d.ts

@@ -3,15 +3,56 @@ import { AuthenticationSessionAccount, AuthenticationSession } from "../common/a
 export declare const IAuthenticationMcpService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationMcpService>;
 export interface IAuthenticationMcpService {
     readonly _serviceBrand: undefined;
+    /**
+    * Fires when an account preference for a specific provider has changed for the specified MCP servers. Does not fire when:
+    * * An account preference is removed
+    * * A session preference is changed (because it's deprecated)
+    * * A session preference is removed (because it's deprecated)
+    */
     onDidChangeAccountPreference: Event<{
         mcpServerIds: string[];
         providerId: string;
     }>;
+    /**
+    * Returns the accountName (also known as account.label) to pair with `IAuthenticationMCPServerAccessService` to get the account preference
+    * @param providerId The authentication provider id
+    * @param mcpServerId The MCP server id to get the preference for
+    * @returns The accountName of the preference, or undefined if there is no preference set
+    */
     getAccountPreference(mcpServerId: string, providerId: string): string | undefined;
+    /**
+    * Sets the account preference for the given provider and MCP server
+    * @param providerId The authentication provider id
+    * @param mcpServerId The MCP server id to set the preference for
+    * @param account The account to set the preference to
+    */
     updateAccountPreference(mcpServerId: string, providerId: string, account: AuthenticationSessionAccount): void;
+    /**
+    * Removes the account preference for the given provider and MCP server
+    * @param providerId The authentication provider id
+    * @param mcpServerId The MCP server id to remove the preference for
+    */
     removeAccountPreference(mcpServerId: string, providerId: string): void;
+    /**
+    * @deprecated Sets the session preference for the given provider and MCP server
+    * @param providerId
+    * @param mcpServerId
+    * @param session
+    */
     updateSessionPreference(providerId: string, mcpServerId: string, session: AuthenticationSession): void;
+    /**
+    * @deprecated Gets the session preference for the given provider and MCP server
+    * @param providerId
+    * @param mcpServerId
+    * @param scopes
+    */
     getSessionPreference(providerId: string, mcpServerId: string, scopes: string[]): string | undefined;
+    /**
+    * @deprecated Removes the session preference for the given provider and MCP server
+    * @param providerId
+    * @param mcpServerId
+    * @param scopes
+    */
     removeSessionPreference(providerId: string, mcpServerId: string, scopes: string[]): void;
     selectSession(providerId: string, mcpServerId: string, mcpServerName: string, scopes: string[], possibleSessions: readonly AuthenticationSession[]): Promise<AuthenticationSession>;
     requestSessionAccess(providerId: string, mcpServerId: string, mcpServerName: string, scopes: string[], possibleSessions: readonly AuthenticationSession[]): void;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpUsageService.service.d.ts

@@ -2,9 +2,33 @@ import { IAuthenticationMcpUsage } from "@codingame/monaco-vscode-mcp-service-ov
 export declare const IAuthenticationMcpUsageService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationMcpUsageService>;
 export interface IAuthenticationMcpUsageService {
     readonly _serviceBrand: undefined;
+    /**
+    * Initializes the cache of MCP servers that use authentication. Ideally used in a contribution that can be run eventually after the workspace is loaded.
+    */
     initializeUsageCache(): Promise<void>;
+    /**
+    * Checks if an MCP server uses authentication
+    * @param mcpServerId The id of the MCP server to check
+    */
     hasUsedAuth(mcpServerId: string): Promise<boolean>;
+    /**
+    * Reads the usages for an account
+    * @param providerId The id of the authentication provider to get usages for
+    * @param accountName The name of the account to get usages for
+    */
     readAccountUsages(providerId: string, accountName: string): IAuthenticationMcpUsage[];
+    /**
+    *
+    * @param providerId The id of the authentication provider to get usages for
+    * @param accountName The name of the account to get usages for
+    */
     removeAccountUsage(providerId: string, accountName: string): void;
+    /**
+    * Adds a usage for an account
+    * @param providerId The id of the authentication provider to get usages for
+    * @param accountName The name of the account to get usages for
+    * @param mcpServerId The id of the MCP server to add a usage for
+    * @param mcpServerName The name of the MCP server to add a usage for
+    */
     addAccountUsage(providerId: string, accountName: string, scopes: ReadonlyArray<string>, mcpServerId: string, mcpServerName: string): void;
 }

package/vscode/src/vs/workbench/services/authentication/browser/authenticationUsageService.service.d.ts

@@ -2,9 +2,33 @@ import { IAccountUsage } from "@codingame/monaco-vscode-authentication-service-o
 export declare const IAuthenticationUsageService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationUsageService>;
 export interface IAuthenticationUsageService {
     readonly _serviceBrand: undefined;
+    /**
+    * Initializes the cache of extensions that use authentication. Ideally used in a contribution that can be run eventually after the workspace is loaded.
+    */
     initializeExtensionUsageCache(): Promise<void>;
+    /**
+    * Checks if an extension uses authentication
+    * @param extensionId The id of the extension to check
+    */
     extensionUsesAuth(extensionId: string): Promise<boolean>;
+    /**
+    * Reads the usages for an account
+    * @param providerId The id of the authentication provider to get usages for
+    * @param accountName The name of the account to get usages for
+    */
     readAccountUsages(providerId: string, accountName: string): IAccountUsage[];
+    /**
+    *
+    * @param providerId The id of the authentication provider to get usages for
+    * @param accountName The name of the account to get usages for
+    */
     removeAccountUsage(providerId: string, accountName: string): void;
+    /**
+    * Adds a usage for an account
+    * @param providerId The id of the authentication provider to get usages for
+    * @param accountName The name of the account to get usages for
+    * @param extensionId The id of the extension to add a usage for
+    * @param extensionName The name of the extension to add a usage for
+    */
     addAccountUsage(providerId: string, accountName: string, scopes: ReadonlyArray<string>, extensionId: string, extensionName: string): void;
 }

package/vscode/src/vs/workbench/services/authentication/common/authentication.d.ts

@@ -1,6 +1,9 @@
 import { Event } from "../../../../base/common/event.js";
 import { IAuthorizationProtectedResourceMetadata, IAuthorizationServerMetadata } from "../../../../base/common/oauth.js";
 import { URI } from "../../../../base/common/uri.js";
+/**
+ * Use this if you don't want the onDidChangeSessions event to fire in the extension host
+ */
 export declare const INTERNAL_AUTH_PROVIDER_PREFIX = "__";
 export interface AuthenticationSessionAccount {
     label: string;
@@ -23,42 +26,146 @@ export interface AuthenticationProviderInformation {
     label: string;
     authorizationServerGlobs?: ReadonlyArray<string>;
 }
+/**
+ * Options for creating an authentication session via the service.
+ */
 export interface IAuthenticationCreateSessionOptions {
     activateImmediate?: boolean;
+    /**
+     * The account that is being asked about. If this is passed in, the provider should
+     * attempt to return the sessions that are only related to this account.
+     */
     account?: AuthenticationSessionAccount;
+    /**
+     * The authorization server URI to use for this creation request. If passed in, first we validate that
+     * the provider can use this authorization server, then it is passed down to the auth provider.
+     */
     authorizationServer?: URI;
+    /**
+     * Allows the authentication provider to take in additional parameters.
+     * It is up to the provider to define what these parameters are and handle them.
+     * This is useful for passing in additional information that is specific to the provider
+     * and not part of the standard authentication flow.
+     */
     [key: string]: any;
 }
+/**
+ * Options for getting authentication sessions via the service.
+ */
 export interface IAuthenticationGetSessionsOptions {
+    /**
+     * The account that is being asked about. If this is passed in, the provider should
+     * attempt to return the sessions that are only related to this account.
+     */
     account?: AuthenticationSessionAccount;
+    /**
+     * The authorization server URI to use for this request. If passed in, first we validate that
+     * the provider can use this authorization server, then it is passed down to the auth provider.
+     */
     authorizationServer?: URI;
+    /**
+     * Allows the authentication provider to take in additional parameters.
+     * It is up to the provider to define what these parameters are and handle them.
+     * This is useful for passing in additional information that is specific to the provider
+     * and not part of the standard authentication flow.
+     */
     [key: string]: any;
 }
 export interface AllowedExtension {
     id: string;
     name: string;
+    /**
+     * If true or undefined, the extension is allowed to use the account
+     * If false, the extension is not allowed to use the account
+     * TODO: undefined shouldn't be a valid value, but it is for now
+     */
     allowed?: boolean;
     lastUsed?: number;
     trusted?: boolean;
 }
 export interface IAuthenticationProviderHostDelegate {
+    /** Priority for this delegate, delegates are tested in descending priority order */
     readonly priority: number;
     create(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resource: IAuthorizationProtectedResourceMetadata | undefined): Promise<string>;
 }
 export declare function isAuthenticationSession(thing: unknown): thing is AuthenticationSession;
+/**
+ * Options passed to the authentication provider when asking for sessions.
+ */
 export interface IAuthenticationProviderSessionOptions {
+    /**
+     * The account that is being asked about. If this is passed in, the provider should
+     * attempt to return the sessions that are only related to this account.
+     */
     account?: AuthenticationSessionAccount;
+    /**
+     * The authorization server that is being asked about. If this is passed in, the provider should
+     * attempt to return sessions that are only related to this authorization server.
+     */
     authorizationServer?: URI;
+    /**
+     * Allows the authentication provider to take in additional parameters.
+     * It is up to the provider to define what these parameters are and handle them.
+     * This is useful for passing in additional information that is specific to the provider
+     * and not part of the standard authentication flow.
+     */
     [key: string]: any;
 }
+/**
+ * Represents an authentication provider.
+ */
 export interface IAuthenticationProvider {
+    /**
+     * The unique identifier of the authentication provider.
+     */
     readonly id: string;
+    /**
+     * The display label of the authentication provider.
+     */
     readonly label: string;
+    /**
+     * The resolved authorization servers. These can still contain globs, but should be concrete URIs
+     */
     readonly authorizationServers?: ReadonlyArray<URI>;
+    /**
+     * Indicates whether the authentication provider supports multiple accounts.
+     */
     readonly supportsMultipleAccounts: boolean;
+    /**
+     * Optional function to provide a custom confirmation message for authentication prompts.
+     * If not implemented, the default confirmation messages will be used.
+     * @param extensionName - The name of the extension requesting authentication.
+     * @param recreatingSession - Whether this is recreating an existing session.
+     * @returns A custom confirmation message or undefined to use the default message.
+     */
     readonly confirmation?: (extensionName: string, recreatingSession: boolean) => string | undefined;
+    /**
+     * An {@link Event} which fires when the array of sessions has changed, or data
+     * within a session has changed.
+     */
     readonly onDidChangeSessions: Event<AuthenticationSessionsChangeEvent>;
+    /**
+     * Retrieves a list of authentication sessions.
+     * @param scopes - An optional list of scopes. If provided, the sessions returned should match these permissions, otherwise all sessions should be returned.
+     * @param options - Additional options for getting sessions.
+     * @returns A promise that resolves to an array of authentication sessions.
+     */
     getSessions(scopes: string[] | undefined, options: IAuthenticationProviderSessionOptions): Promise<readonly AuthenticationSession[]>;
+    /**
+     * Prompts the user to log in.
+     * If login is successful, the `onDidChangeSessions` event should be fired.
+     * If login fails, a rejected promise should be returned.
+     * If the provider does not support multiple accounts, this method should not be called if there is already an existing session matching the provided scopes.
+     * @param scopes - A list of scopes that the new session should be created with.
+     * @param options - Additional options for creating the session.
+     * @returns A promise that resolves to an authentication session.
+     */
     createSession(scopes: string[], options: IAuthenticationProviderSessionOptions): Promise<AuthenticationSession>;
+    /**
+     * Removes the session corresponding to the specified session ID.
+     * If the removal is successful, the `onDidChangeSessions` event should be fired.
+     * If a session cannot be removed, the provider should reject with an error message.
+     * @param sessionId - The ID of the session to remove.
+     */
     removeSession(sessionId: string): Promise<void>;
 }

package/vscode/src/vs/workbench/services/authentication/common/authentication.service.d.ts

@@ -6,43 +6,167 @@ import { AuthenticationProviderInformation, AuthenticationSessionsChangeEvent, I
 export declare const IAuthenticationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationService>;
 export interface IAuthenticationService {
     readonly _serviceBrand: undefined;
+    /**
+    * Fires when an authentication provider has been registered
+    */
     readonly onDidRegisterAuthenticationProvider: Event<AuthenticationProviderInformation>;
+    /**
+    * Fires when an authentication provider has been unregistered
+    */
     readonly onDidUnregisterAuthenticationProvider: Event<AuthenticationProviderInformation>;
+    /**
+    * Fires when the list of sessions for a provider has been added, removed or changed
+    */
     readonly onDidChangeSessions: Event<{
         providerId: string;
         label: string;
         event: AuthenticationSessionsChangeEvent;
     }>;
+    /**
+    * Fires when the list of declaredProviders has changed
+    */
     readonly onDidChangeDeclaredProviders: Event<void>;
+    /**
+    * All providers that have been statically declared by extensions. These may not actually be registered or active yet.
+    */
     readonly declaredProviders: AuthenticationProviderInformation[];
+    /**
+    * Registers that an extension has declared an authentication provider in their package.json
+    * @param provider The provider information to register
+    */
     registerDeclaredAuthenticationProvider(provider: AuthenticationProviderInformation): void;
+    /**
+    * Unregisters a declared authentication provider
+    * @param id The id of the provider to unregister
+    */
     unregisterDeclaredAuthenticationProvider(id: string): void;
+    /**
+    * Checks if an authentication provider has been registered
+    * @param id The id of the provider to check
+    */
     isAuthenticationProviderRegistered(id: string): boolean;
+    /**
+    * Checks if an authentication provider is dynamic
+    * @param id The id of the provider to check
+    */
     isDynamicAuthenticationProvider(id: string): boolean;
+    /**
+    * Registers an authentication provider
+    * @param id The id of the provider
+    * @param provider The implementation of the provider
+    */
     registerAuthenticationProvider(id: string, provider: IAuthenticationProvider): void;
+    /**
+    * Unregisters an authentication provider
+    * @param id The id of the provider to unregister
+    */
     unregisterAuthenticationProvider(id: string): void;
+    /**
+    * Gets the provider ids of all registered authentication providers
+    */
     getProviderIds(): string[];
+    /**
+    * Gets the provider with the given id.
+    * @param id The id of the provider to get
+    * @throws if the provider is not registered
+    */
     getProvider(id: string): IAuthenticationProvider;
+    /**
+    * Gets all accounts that are currently logged in across all sessions
+    * @param id The id of the provider to ask for accounts
+    * @returns A promise that resolves to an array of accounts
+    */
     getAccounts(id: string): Promise<ReadonlyArray<AuthenticationSessionAccount>>;
+    /**
+    * Gets all sessions that satisfy the given scopes from the provider with the given id
+    * @param id The id of the provider to ask for a session
+    * @param scopes The scopes for the session
+    * @param options Additional options for getting sessions
+    * @param activateImmediate If true, the provider should activate immediately if it is not already
+    */
     getSessions(id: string, scopes?: string[], options?: IAuthenticationGetSessionsOptions, activateImmediate?: boolean): Promise<ReadonlyArray<AuthenticationSession>>;
+    /**
+    * Creates an AuthenticationSession with the given provider and scopes
+    * @param providerId The id of the provider
+    * @param scopes The scopes to request
+    * @param options Additional options for creating the session
+    */
     createSession(providerId: string, scopes: string[], options?: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
+    /**
+    * Removes the session with the given id from the provider with the given id
+    * @param providerId The id of the provider
+    * @param sessionId The id of the session to remove
+    */
     removeSession(providerId: string, sessionId: string): Promise<void>;
+    /**
+    * Gets a provider id for a specified authorization server
+    * @param authorizationServer The authorization server url that this provider is responsible for
+    */
     getOrActivateProviderIdForServer(authorizationServer: URI): Promise<string | undefined>;
+    /**
+    * Allows the ability register a delegate that will be used to start authentication providers
+    * @param delegate The delegate to register
+    */
     registerAuthenticationProviderHostDelegate(delegate: IAuthenticationProviderHostDelegate): IDisposable;
+    /**
+    * Creates a dynamic authentication provider for the given server metadata
+    * @param serverMetadata The metadata for the server that is being authenticated against
+    */
     createDynamicAuthenticationProvider(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resourceMetadata: IAuthorizationProtectedResourceMetadata | undefined): Promise<IAuthenticationProvider | undefined>;
 }
 export declare const IAuthenticationExtensionsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationExtensionsService>;
 export interface IAuthenticationExtensionsService {
     readonly _serviceBrand: undefined;
+    /**
+    * Fires when an account preference for a specific provider has changed for the specified extensions. Does not fire when:
+    * * An account preference is removed
+    * * A session preference is changed (because it's deprecated)
+    * * A session preference is removed (because it's deprecated)
+    */
     onDidChangeAccountPreference: Event<{
         extensionIds: string[];
         providerId: string;
     }>;
+    /**
+    * Returns the accountName (also known as account.label) to pair with `IAuthenticationAccessService` to get the account preference
+    * @param providerId The authentication provider id
+    * @param extensionId The extension id to get the preference for
+    * @returns The accountName of the preference, or undefined if there is no preference set
+    */
     getAccountPreference(extensionId: string, providerId: string): string | undefined;
+    /**
+    * Sets the account preference for the given provider and extension
+    * @param providerId The authentication provider id
+    * @param extensionId The extension id to set the preference for
+    * @param account The account to set the preference to
+    */
     updateAccountPreference(extensionId: string, providerId: string, account: AuthenticationSessionAccount): void;
+    /**
+    * Removes the account preference for the given provider and extension
+    * @param providerId The authentication provider id
+    * @param extensionId The extension id to remove the preference for
+    */
     removeAccountPreference(extensionId: string, providerId: string): void;
+    /**
+    * @deprecated Sets the session preference for the given provider and extension
+    * @param providerId
+    * @param extensionId
+    * @param session
+    */
     updateSessionPreference(providerId: string, extensionId: string, session: AuthenticationSession): void;
+    /**
+    * @deprecated Gets the session preference for the given provider and extension
+    * @param providerId
+    * @param extensionId
+    * @param scopes
+    */
     getSessionPreference(providerId: string, extensionId: string, scopes: string[]): string | undefined;
+    /**
+    * @deprecated Removes the session preference for the given provider and extension
+    * @param providerId
+    * @param extensionId
+    * @param scopes
+    */
     removeSessionPreference(providerId: string, extensionId: string, scopes: string[]): void;
     selectSession(providerId: string, extensionId: string, extensionName: string, scopes: string[], possibleSessions: readonly AuthenticationSession[]): Promise<AuthenticationSession>;
     requestSessionAccess(providerId: string, extensionId: string, extensionName: string, scopes: string[], possibleSessions: readonly AuthenticationSession[]): void;