diff --git a/types/azdata/azdata-tests.ts b/types/azdata/azdata-tests.ts new file mode 100644 index 0000000000..1dc88ff2f1 --- /dev/null +++ b/types/azdata/azdata-tests.ts @@ -0,0 +1,16 @@ +import * as azdata from 'azdata'; + +azdata.dataprotocol.registerConnectionProvider({ + providerId: 'MyProvider', + connect(connectionUri: string, connectionInfo: azdata.ConnectionInfo): Thenable { return Promise.resolve(true); }, + disconnect(connectionUri: string): Thenable { return Promise.resolve(true); }, + cancelConnect(connectionUri: string): Thenable { return Promise.resolve(true); }, + listDatabases(connectionUri: string): Thenable { return Promise.resolve({ databaseNames: [] }); }, + changeDatabase(connectionUri: string, newDatabase: string): Thenable { return Promise.resolve(true); }, + rebuildIntelliSenseCache(connectionUri: string): Thenable { return Promise.resolve(); }, + getConnectionString(connectionUri: string, includePassword: boolean): Thenable { return Promise.resolve(''); }, + buildConnectionInfo(connectionString: string): Thenable { return Promise.resolve({ options: {} }); }, + registerOnConnectionComplete(handler: (connSummary: azdata.ConnectionInfoSummary) => any): void { }, + registerOnIntelliSenseCacheComplete(handler: (connectionUri: string) => any): void { }, + registerOnConnectionChanged(handler: (changedConnInfo: azdata.ChangedConnectionInfo) => any): void { } +}); diff --git a/types/azdata/index.d.ts b/types/azdata/index.d.ts new file mode 100644 index 0000000000..71d1766733 --- /dev/null +++ b/types/azdata/index.d.ts @@ -0,0 +1,5252 @@ +// Type definitions for Azure Data Studio 1.15 +// Project: https://github.com/microsoft/azuredatastudio +// Definitions by: Charles Gagnon +// Anthony Dresser: +// Karl Burtram: +// Ken Van Hyning: +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. + * See https://github.com/microsoft/azuredatastudio/blob/master/LICENSE.txt for license information. + *--------------------------------------------------------------------------------------------*/ + +/** + * Type Definition for Azure Data Studio 1.15 Extension API + * See https://docs.microsoft.com/sql/azure-data-studio/extensibility-apis for more information + */ + +declare module 'azdata' { + import * as vscode from 'vscode'; + + // EXPORTED NAMESPACES ///////////////////////////////////////////////// + /** + * Namespace for Data Management Protocol global methods + */ + export namespace dataprotocol { + export function registerConnectionProvider(provider: ConnectionProvider): vscode.Disposable; + + export function registerBackupProvider(provider: BackupProvider): vscode.Disposable; + + export function registerRestoreProvider(provider: RestoreProvider): vscode.Disposable; + + export function registerScriptingProvider(provider: ScriptingProvider): vscode.Disposable; + + export function registerObjectExplorerProvider(provider: ObjectExplorerProvider): vscode.Disposable; + + export function registerObjectExplorerNodeProvider(provider: ObjectExplorerNodeProvider): vscode.Disposable; + + export function registerIconProvider(provider: IconProvider): vscode.Disposable; + + export function registerTaskServicesProvider(provider: TaskServicesProvider): vscode.Disposable; + + export function registerFileBrowserProvider(provider: FileBrowserProvider): vscode.Disposable; + + export function registerProfilerProvider(provider: ProfilerProvider): vscode.Disposable; + + export function registerMetadataProvider(provider: MetadataProvider): vscode.Disposable; + + export function registerQueryProvider(provider: QueryProvider, isLiveShare?: boolean): vscode.Disposable; + + export function registerAdminServicesProvider(provider: AdminServicesProvider): vscode.Disposable; + + export function registerAgentServicesProvider(provider: AgentServicesProvider): vscode.Disposable; + + export function registerCapabilitiesServiceProvider(provider: CapabilitiesProvider): vscode.Disposable; + + /** + * An [event](#Event) which fires when the specific flavor of a language used in DMP + * connections has changed. And example is for a SQL connection, the flavor changes + * to MSSQL + */ + export const onDidChangeLanguageFlavor: vscode.Event; + } + + /** + * Namespace for credentials management global methods, available to all extensions + */ + export namespace credentials { + /** + * Register a credential provider to handle credential requests. + * @param provider The provider to register + * @return Handle to the provider for disposal + */ + export function registerProvider(provider: CredentialProvider): vscode.Disposable; + + /** + * Retrieves a provider from the extension host if one has been registered. Any credentials + * accessed with the returned provider will have the namespaceId appended to credential ID + * to prevent extensions from trampling over each others' credentials. + * @param namespaceId ID that will be appended to credential IDs. + * @return Promise that returns the namespaced provider + */ + export function getProvider(namespaceId: string): Thenable; + } + + /** + * Namespace for connection management + */ + export namespace connection { + /** + * Connection profile primary class + */ + export class ConnectionProfile { + providerId: string; + connectionId: string; + connectionName: string; + serverName: string; + databaseName: string; + userName: string; + password: string; + authenticationType: string; + savePassword: boolean; + groupFullName: string; + groupId: string; + saveProfile: boolean; + azureTenantId?: string; + options: { [name: string]: any }; + + static createFrom(options: { [key: string]: any }): ConnectionProfile; + } + + /** + * Get the current connection based on the active editor or Object Explorer selection + */ + export function getCurrentConnection(): Thenable; + + /** + * Get known connection profiles including active connections, recent connections and saved connections. + * @param activeConnectionsOnly Indicates whether only get the active connections, default value is false. + * @returns array of connections + */ + export function getConnections(activeConnectionsOnly?: boolean): Thenable; + + /** + * Get all active connections + */ + export function getActiveConnections(): Thenable; + + /** + * Get connection string + */ + export function getConnectionString(connectionId: string, includePassword: boolean): Thenable; + + /** + * Get the credentials for an active connection + * @param connectionId The id of the connection + * @returns A dictionary containing the credentials as they would be included in the connection's options dictionary + */ + export function getCredentials(connectionId: string): Thenable<{ [name: string]: string }>; + + /** + * Get ServerInfo for a connectionId + * @param connectionId The id of the connection + * @returns ServerInfo + */ + export function getServerInfo(connectionId: string): Thenable; + + /** + * Interface for representing a connection when working with connection APIs + */ + export interface Connection extends ConnectionInfo { + /** + * The name of the provider managing the connection (e.g. MSSQL) + */ + providerName: string; + + /** + * A unique identifier for the connection + */ + connectionId: string; + } + + /** + * List the databases that can be accessed from the given connection + * @param connectionId The ID of the connection + * @returns An list of names of databases + */ + export function listDatabases(connectionId: string): Thenable; + + /** + * Get a URI corresponding to the given connection so that it can be used with data + * providers and other APIs that require a connection API. + * Note: If the given connection corresponds to multiple URIs this may return any of them + * @param connectionId The ID of the connection + */ + export function getUriForConnection(connectionId: string): Thenable; + + /** + * Opens the connection dialog, calls the callback with the result. If connection was successful + * returns the connection otherwise returns undefined + */ + export function openConnectionDialog(providers?: string[], initialConnectionProfile?: IConnectionProfile, connectionCompletionOptions?: IConnectionCompletionOptions): Thenable; + + /** + * Opens the connection and add it to object explorer and opens the dashboard and returns the ConnectionResult + * @param connectionProfile connection profile + */ + export function connect(connectionProfile: IConnectionProfile, saveConnection?: boolean, showDashboard?: boolean): Thenable; + } + + /** + * Namespace for interacting with Object Explorer + */ + export namespace objectexplorer { + /** + * Get an Object Explorer node corresponding to the given connection and path. If no path + * is given, it returns the top-level node for the given connection. If there is no node at + * the given path, it returns undefined. + * @param connectionId The id of the connection that the node exists on + * @param nodePath The path of the node to get + * @returns The node corresponding to the given connection and path, + * or undefined if no such node exists. + */ + export function getNode(connectionId: string, nodePath?: string): Thenable; + + /** + * Get all active Object Explorer connection nodes + * @returns The Object Explorer nodes for each saved connection + */ + export function getActiveConnectionNodes(): Thenable; + + /** + * Find Object Explorer nodes that match the given information + * @param connectionId The id of the connection that the node exists on + * @param type The type of the object to retrieve + * @param schema The schema of the object, if applicable + * @param name The name of the object + * @param database The database the object exists under, if applicable + * @param parentObjectNames A list of names of parent objects in the tree, ordered from highest to lowest level + * (for example when searching for a table's column, provide the name of its parent table for this argument) + */ + export function findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable; + + /** + * Get connectionProfile from sessionId + * @param sessionId The id of the session that the node exists on + * @returns The IConnecitonProfile for the session + */ + export function getSessionConnectionProfile(sessionId: string): Thenable; + + /** + * Interface for representing and interacting with items in Object Explorer + */ + export interface ObjectExplorerNode extends NodeInfo { + /** + * The id of the connection that the node exists under + */ + connectionId: string; + + /** + * Whether the node is currently expanded in Object Explorer + */ + isExpanded(): Thenable; + + /** + * Set whether the node is expanded or collapsed + * @param expandedState The new state of the node. If 'None', the node will not be changed + */ + setExpandedState(expandedState: vscode.TreeItemCollapsibleState): Thenable; + + /** + * Set whether the node is selected + * @param selected Whether the node should be selected + * @param clearOtherSelections If true, clear any other selections. If false, leave any existing selections. + * Defaults to true when selected is true and false when selected is false. + */ + setSelected(selected: boolean, clearOtherSelections?: boolean): Thenable; + + /** + * Get all the child nodes. Returns an empty list if there are no children. + */ + getChildren(): Thenable; + + /** + * Get the parent node. Returns undefined if there is none. + */ + getParent(): Thenable; + + /** + * Refresh the node, expanding it if it has children + */ + refresh(): Thenable; + } + } + + // EXPORTED INTERFACES ///////////////////////////////////////////////// + export interface ConnectionInfo { + + options: { [name: string]: any }; + } + + // Object Explorer interfaces ----------------------------------------------------------------------- + export interface ObjectExplorerSession { + success: boolean; + sessionId: string; + rootNode: NodeInfo; + errorMessage: string; + } + + /** + * A NodeInfo object represents an element in the Object Explorer tree under + * a connection. + */ + export interface NodeInfo { + nodePath: string; + nodeType: string; + nodeSubType: string; + nodeStatus: string; + label: string; + isLeaf: boolean; + metadata: ObjectMetadata; + errorMessage: string; + /** + * Optional iconType for the object in the tree. Currently this only supports + * an icon name or SqlThemeIcon name, rather than a path to an icon. + * If not defined, the nodeType + nodeStatus / nodeSubType values + * will be used instead. + */ + iconType?: string | SqlThemeIcon; + /** + * Informs who provides the children to a node, used by data explorer tree view api + */ + childProvider?: string; + /** + * Holds the connection profile for nodes, used by data explorer tree view api + */ + payload?: any; + } + + export interface IConnectionProfile extends ConnectionInfo { + connectionName: string; + serverName: string; + databaseName: string; + userName: string; + password: string; + authenticationType: string; + savePassword: boolean; + groupFullName?: string; + groupId: string; + providerName: string; + saveProfile: boolean; + id: string; + azureTenantId?: string; + } + + /** + * Options for the actions that could happen after connecting is complete + */ + export interface IConnectionCompletionOptions { + /** + * Save the connection to MRU and settings (only save to setting if profile.saveProfile is set to true) + * Default is true. + */ + saveConnection: boolean; + + /** + * If true, open the dashboard after connection is complete. + * If undefined / false, dashboard won't be opened after connection completes. + * Default is false. + */ + showDashboard?: boolean; + + /** + * If undefined / true, open the connection dialog if connection fails. + * If false, connection dialog won't be opened even if connection fails. + * Default is true. + */ + showConnectionDialogOnError?: boolean; + + /** + * If undefined / true, open the connection firewall rule dialog if connection fails. + * If false, connection firewall rule dialog won't be opened even if connection fails. + * Default is true. + */ + showFirewallRuleOnError?: boolean; + } + + export interface ConnectionInfoSummary { + + /** + * URI identifying the owner of the connection + */ + ownerUri: string; + + /** + * connection id returned from service host. + */ + connectionId: string; + + /** + * any diagnostic messages return from the service host. + */ + messages: string; + + /** + * Error message returned from the engine, if any. + */ + errorMessage: string; + + /** + * Error number returned from the engine, if any. + */ + errorNumber: number; + /** + * Information about the connected server. + */ + serverInfo: ServerInfo; + /** + * information about the actual connection established + */ + connectionSummary: ConnectionSummary; + } + + /** + * Summary that identifies a unique database connection. + */ + export interface ConnectionSummary { + /** + * server name + */ + serverName: string; + /** + * database name + */ + databaseName: string; + /** + * user name + */ + userName: string; + } + + /** + * Information about a Server instance. + */ + export interface ServerInfo { + /** + * The major version of the instance. + */ + serverMajorVersion: number; + /** + * The minor version of the instance. + */ + serverMinorVersion: number; + /** + * The build of the instance. + */ + serverReleaseVersion: number; + /** + * The ID of the engine edition of the instance. + */ + engineEditionId: number; + /** + * String containing the full server version text. + */ + serverVersion: string; + /** + * String describing the product level of the server. + */ + serverLevel: string; + /** + * The edition of the instance. + */ + serverEdition: string; + /** + * Whether the instance is running in the cloud (Azure) or not. + */ + isCloud: boolean; + /** + * The version of Azure that the instance is running on, if applicable. + */ + azureVersion: number; + /** + * The Operating System version string of the machine running the instance. + */ + osVersion: string; + /** + * options for all new server properties. + */ + options: { [key: string]: any }; + } + + /** + * The possible values of the server engine edition + */ + export enum DatabaseEngineEdition { + Unknown = 0, + Personal = 1, + Standard = 2, + Enterprise = 3, + Express = 4, + SqlDatabase = 5, + SqlDataWarehouse = 6, + SqlStretchDatabase = 7, + SqlManagedInstance = 8, + SqlOnDemand = 11 + } + + export interface DataProvider { + handle?: number; + readonly providerId: string; + } + + export interface ConnectionProvider extends DataProvider { + + connect(connectionUri: string, connectionInfo: ConnectionInfo): Thenable; + + disconnect(connectionUri: string): Thenable; + + cancelConnect(connectionUri: string): Thenable; + + listDatabases(connectionUri: string): Thenable; + + changeDatabase(connectionUri: string, newDatabase: string): Thenable; + + rebuildIntelliSenseCache(connectionUri: string): Thenable; + + getConnectionString(connectionUri: string, includePassword: boolean): Thenable; + + buildConnectionInfo?(connectionString: string): Thenable; + + registerOnConnectionComplete(handler: (connSummary: ConnectionInfoSummary) => any): void; + + registerOnIntelliSenseCacheComplete(handler: (connectionUri: string) => any): void; + + registerOnConnectionChanged(handler: (changedConnInfo: ChangedConnectionInfo) => any): void; + } + + export enum ServiceOptionType { + string = 'string', + multistring = 'multistring', + password = 'password', + number = 'number', + category = 'category', + boolean = 'boolean', + object = 'object' + } + + export enum ConnectionOptionSpecialType { + connectionName = 'connectionName', + serverName = 'serverName', + databaseName = 'databaseName', + authType = 'authType', + userName = 'userName', + password = 'password', + appName = 'appName' + } + + export interface CategoryValue { + displayName: string; + name: string; + } + + export interface ConnectionOption { + name: string; + + displayName: string; + + description: string; + + groupName: string; + + valueType: ServiceOptionType; + + specialValueType: ConnectionOptionSpecialType; + + defaultValue: string; + + categoryValues: CategoryValue[]; + + isIdentity: boolean; + + isRequired: boolean; + } + + export interface ConnectionProviderOptions { + options: ConnectionOption[]; + } + + export interface ServiceOption { + name: string; + + displayName: string; + + description: string; + + groupName: string; + + valueType: ServiceOptionType; + + defaultValue: string; + + objectType: string; + + categoryValues: CategoryValue[]; + + isRequired: boolean; + + isArray: boolean; + } + + export interface AdminServicesOptions { + databaseInfoOptions: ServiceOption[]; + + databaseFileInfoOptions: ServiceOption[]; + + fileGroupInfoOptions: ServiceOption[]; + } + + + // List Databases Request ---------------------------------------------------------------------- + export interface ListDatabasesResult { + databaseNames: Array; + } + + /** + * Information about a connection changed event for a resource represented by a URI + */ + export interface ChangedConnectionInfo { + /** + * Owner URI of the connection that changed. + */ + connectionUri: string; + + /** + * Summary of details containing any connection changes. + */ + connection: ConnectionSummary; + } + + export interface FeatureMetadataProvider { + enabled: boolean; + + featureName: string; + + optionsMetadata: ServiceOption[]; + } + + export interface DataProtocolServerCapabilities { + protocolVersion: string; + + providerName: string; + + providerDisplayName: string; + + connectionProvider: ConnectionProviderOptions; + + adminServicesProvider: AdminServicesOptions; + + features: FeatureMetadataProvider[]; + } + + export interface DataProtocolClientCapabilities { + hostName: string; + + hostVersion: string; + } + + export interface CapabilitiesProvider extends DataProvider { + getServerCapabilities(client: DataProtocolClientCapabilities): Thenable; + } + + export enum MetadataType { + Table = 0, + View = 1, + SProc = 2, + Function = 3 + } + + export interface ObjectMetadata { + metadataType: MetadataType; + + metadataTypeName: string; + + urn: string; + + name: string; + + schema: string; + } + + export interface ColumnMetadata { + + hasExtendedProperties: boolean; + + defaultValue: string; + + /// + /// Escaped identifier for the name of the column + /// + escapedName: string; + + /// + /// Whether or not the column is computed + /// + isComputed: boolean; + + /// + /// Whether or not the column is deterministically computed + /// + isDeterministic: boolean; + + /// + /// Whether or not the column is an identity column + /// + isIdentity: boolean; + + /// + /// The ordinal ID of the column + /// + ordinal: number; + + /// + /// Whether or not the column is calculated on the server side. This could be a computed + /// column or a identity column. + /// + isCalculated: boolean; + + /// + /// Whether or not the column is used in a key to uniquely identify a row + /// + isKey: boolean; + + /// + /// Whether or not the column can be trusted for uniqueness + /// + isTrustworthyForUniqueness: boolean; + } + + export interface TableMetadata { + + columns: ColumnMetadata; + + } + + export interface ProviderMetadata { + objectMetadata: ObjectMetadata[]; + } + + export interface MetadataProvider extends DataProvider { + getMetadata(connectionUri: string): Thenable; + + getDatabases(connectionUri: string): Thenable; + + getTableInfo(connectionUri: string, metadata: ObjectMetadata): Thenable; + + getViewInfo(connectionUri: string, metadata: ObjectMetadata): Thenable; + } + + export enum ScriptOperation { + Select = 0, + Create = 1, + Insert = 2, + Update = 3, + Delete = 4, + Execute = 5, + Alter = 6 + } + + export interface ScriptingResult { + operationId: string; + script: string; + } + + export interface ScriptingParamDetails { + filePath: string; + scriptCompatibilityOption: string; + targetDatabaseEngineEdition: string; + targetDatabaseEngineType: string; + } + + export interface ScriptingProvider extends DataProvider { + + scriptAsOperation(connectionUri: string, operation: ScriptOperation, metadata: ObjectMetadata, paramDetails: ScriptingParamDetails): Thenable; + + registerOnScriptingComplete(handler: (scriptingCompleteResult: ScriptingCompleteResult) => any): void; + } + + export interface ScriptingCompleteResult { + errorDetails: string; + + errorMessage: string; + + hasError: boolean; + + canceled: boolean; + + success: boolean; + + operationId: string; + } + + /** + * Parameters to initialize a connection to a database + */ + export interface Credential { + /** + * Unique ID identifying the credential + */ + credentialId: string; + + /** + * password + */ + password: string; + } + + export interface CredentialProvider { + handle: number; + + saveCredential(credentialId: string, password: string): Thenable; + + readCredential(credentialId: string): Thenable; + + deleteCredential(credentialId: string): Thenable; + } + + export interface DidChangeLanguageFlavorParams { + uri: string; + language: string; + flavor: string; + } + + export interface QueryExecutionOptions { + options: { [option: string]: any; }; + } + + export interface QueryProvider extends DataProvider { + cancelQuery(ownerUri: string): Thenable; + runQuery(ownerUri: string, selection: ISelectionData, runOptions?: ExecutionPlanOptions): Thenable; + runQueryStatement(ownerUri: string, line: number, column: number): Thenable; + runQueryString(ownerUri: string, queryString: string): Thenable; + runQueryAndReturn(ownerUri: string, queryString: string): Thenable; + parseSyntax(ownerUri: string, query: string): Thenable; + getQueryRows(rowData: QueryExecuteSubsetParams): Thenable; + disposeQuery(ownerUri: string): Thenable; + saveResults(requestParams: SaveResultsRequestParams): Thenable; + setQueryExecutionOptions(ownerUri: string, options: QueryExecutionOptions): Thenable; + + // Notifications + registerOnQueryComplete(handler: (result: QueryExecuteCompleteNotificationResult) => any): void; + registerOnBatchStart(handler: (batchInfo: QueryExecuteBatchNotificationParams) => any): void; + registerOnBatchComplete(handler: (batchInfo: QueryExecuteBatchNotificationParams) => any): void; + registerOnResultSetAvailable(handler: (resultSetInfo: QueryExecuteResultSetNotificationParams) => any): void; + registerOnResultSetUpdated(handler: (resultSetInfo: QueryExecuteResultSetNotificationParams) => any): void; + registerOnMessage(handler: (message: QueryExecuteMessageParams) => any): void; + + // Edit Data Requests + commitEdit(ownerUri: string): Thenable; + createRow(ownerUri: string): Thenable; + deleteRow(ownerUri: string, rowId: number): Thenable; + disposeEdit(ownerUri: string): Thenable; + initializeEdit(ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number, queryString: string): Thenable; + revertCell(ownerUri: string, rowId: number, columnId: number): Thenable; + revertRow(ownerUri: string, rowId: number): Thenable; + updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable; + getEditRows(rowData: EditSubsetParams): Thenable; + + // Edit Data Notifications + registerOnEditSessionReady(handler: (ownerUri: string, success: boolean, message: string) => any): void; + } + + export interface IDbColumn { + allowDBNull?: boolean; + baseCatalogName: string; + baseColumnName: string; + baseSchemaName: string; + baseServerName: string; + baseTableName: string; + columnName: string; + columnOrdinal?: number; + columnSize?: number; + isAliased?: boolean; + isAutoIncrement?: boolean; + isExpression?: boolean; + isHidden?: boolean; + isIdentity?: boolean; + isKey?: boolean; + isBytes?: boolean; + isChars?: boolean; + isSqlVariant?: boolean; + isUdt?: boolean; + dataType: string; + isXml?: boolean; + isJson?: boolean; + isLong?: boolean; + isReadOnly?: boolean; + isUnique?: boolean; + numericPrecision?: number; + numericScale?: number; + udtAssemblyQualifiedName: string; + dataTypeName: string; + } + + export interface IGridResultSet { + columns: IDbColumn[]; + rowsUri: string; + numberOfRows: number; + } + + export interface IResultMessage { + batchId?: number; + isError: boolean; + time?: string; + message: string; + } + + export interface ISelectionData { + startLine: number; + startColumn: number; + endLine: number; + endColumn: number; + } + + export interface ResultSetSummary { + id: number; + batchId: number; + rowCount: number; + columnInfo: IDbColumn[]; + complete: boolean; + } + + export interface BatchSummary { + hasError: boolean; + id: number; + selection: ISelectionData; + resultSetSummaries: ResultSetSummary[]; + executionElapsed: string; + executionEnd: string; + executionStart: string; + } + + export enum EditRowState { + clean = 0, + dirtyInsert = 1, + dirtyDelete = 2, + dirtyUpdate = 3 + } + + export interface EditRow { + cells: DbCellValue[]; + id: number; + isDirty: boolean; + state: EditRowState; + } + + export interface EditCell extends DbCellValue { + isDirty: boolean; + } + + export interface QueryExecuteCompleteNotificationResult { + ownerUri: string; + batchSummaries: BatchSummary[]; + } + + export interface ExecutionPlanOptions { + displayEstimatedQueryPlan?: boolean; + displayActualQueryPlan?: boolean; + } + + export interface SimpleExecuteParams { + queryString: string; + ownerUri: string; + } + + export interface SimpleExecuteResult { + rowCount: number; + columnInfo: IDbColumn[]; + rows: DbCellValue[][]; + } + + export interface SyntaxParseParams { + ownerUri: string; + query: string; + } + + export interface SyntaxParseResult { + parseable: boolean; + errors: string[]; + } + + // Query Batch Notification ----------------------------------------------------------------------- + export interface QueryExecuteBatchNotificationParams { + batchSummary: BatchSummary; + ownerUri: string; + } + + + export interface QueryExecuteResultSetNotificationParams { + resultSetSummary: ResultSetSummary; + ownerUri: string; + } + + + export interface QueryExecuteMessageParams { + message: IResultMessage; + ownerUri: string; + } + + export interface QueryExecuteSubsetParams { + ownerUri: string; + batchIndex: number; + resultSetIndex: number; + rowsStartIndex: number; + rowsCount: number; + } + + export interface DbCellValue { + displayValue: string; + isNull: boolean; + invariantCultureDisplayValue: string; + } + + export interface ResultSetSubset { + rowCount: number; + rows: DbCellValue[][]; + } + + export interface QueryExecuteSubsetResult { + message: string; + resultSubset: ResultSetSubset; + } + + export interface QueryCancelResult { + messages: string; + } + + // Save Results =============================================================================== + export interface SaveResultsRequestParams { + /** + * 'csv', 'json', 'excel', 'xml' + */ + resultFormat: string; + ownerUri: string; + filePath: string; + batchIndex: number; + resultSetIndex: number; + rowStartIndex: number; + rowEndIndex: number; + columnStartIndex: number; + columnEndIndex: number; + includeHeaders?: boolean; + delimiter?: string; + lineSeperator?: string; + textIdentifier?: string; + encoding?: string; + formatted?: boolean; + } + + export interface SaveResultRequestResult { + messages: string; + } + + // Edit Data ================================================================================== + // Shared Interfaces -------------------------------------------------------------------------- + export interface IEditSessionOperationParams { + ownerUri: string; + } + + export interface IEditRowOperationParams extends IEditSessionOperationParams { + rowId: number; + } + + export interface EditCellResult { + cell: EditCell; + isRowDirty: boolean; + } + + // edit/commit -------------------------------------------------------------------------------- + export interface EditCommitParams extends IEditSessionOperationParams { } + export interface EditCommitResult { } + + // edit/createRow ----------------------------------------------------------------------------- + export interface EditCreateRowParams extends IEditSessionOperationParams { } + export interface EditCreateRowResult { + defaultValues: string[]; + newRowId: number; + } + + // edit/deleteRow ----------------------------------------------------------------------------- + export interface EditDeleteRowParams extends IEditRowOperationParams { } + export interface EditDeleteRowResult { } + + // edit/dispose ------------------------------------------------------------------------------- + export interface EditDisposeParams extends IEditSessionOperationParams { } + export interface EditDisposeResult { } + + // edit/initialize ---------------------------------------------------------------------------- + export interface EditInitializeFiltering { + LimitResults?: number; + } + + export interface EditInitializeParams extends IEditSessionOperationParams { + filters: EditInitializeFiltering; + objectName: string; + schemaName: string; + objectType: string; + queryString: string; + } + + + export interface EditInitializeResult { } + + // edit/revertCell ---------------------------------------------------------------------------- + export interface EditRevertCellParams extends IEditRowOperationParams { + columnId: number; + } + export interface EditRevertCellResult extends EditCellResult { + } + + // edit/revertRow ----------------------------------------------------------------------------- + export interface EditRevertRowParams extends IEditRowOperationParams { } + export interface EditRevertRowResult { } + + // edit/sessionReady Event -------------------------------------------------------------------- + export interface EditSessionReadyParams { + ownerUri: string; + success: boolean; + message: string; + } + + // edit/updateCell ---------------------------------------------------------------------------- + export interface EditUpdateCellParams extends IEditRowOperationParams { + columnId: number; + newValue: string; + } + + export interface EditUpdateCellResult extends EditCellResult { + } + + // edit/subset -------------------------------------------------------------------------------- + export interface EditSubsetParams extends IEditSessionOperationParams { + rowStartIndex: number; + rowCount: number; + } + export interface EditSubsetResult { + rowCount: number; + subset: EditRow[]; + } + + /** + * A reference to a named icon. Currently only a subset of the SQL icons are available. + * Using a theme icon is preferred over a custom icon as it gives theme authors the possibility to change the icons. + */ + export class SqlThemeIcon { + static readonly Folder: SqlThemeIcon; + static readonly Root: SqlThemeIcon; + static readonly Database: SqlThemeIcon; + static readonly Server: SqlThemeIcon; + static readonly ScalarValuedFunction: SqlThemeIcon; + static readonly TableValuedFunction: SqlThemeIcon; + static readonly AggregateFunction: SqlThemeIcon; + static readonly FileGroup: SqlThemeIcon; + static readonly StoredProcedure: SqlThemeIcon; + static readonly UserDefinedTableType: SqlThemeIcon; + static readonly View: SqlThemeIcon; + static readonly Table: SqlThemeIcon; + static readonly HistoryTable: SqlThemeIcon; + static readonly ServerLevelLinkedServerLogin: SqlThemeIcon; + static readonly ServerLevelServerAudit: SqlThemeIcon; + static readonly ServerLevelCryptographicProvider: SqlThemeIcon; + static readonly ServerLevelCredential: SqlThemeIcon; + static readonly ServerLevelServerRole: SqlThemeIcon; + static readonly ServerLevelLogin: SqlThemeIcon; + static readonly ServerLevelServerAuditSpecification: SqlThemeIcon; + static readonly ServerLevelServerTrigger: SqlThemeIcon; + static readonly ServerLevelLinkedServer: SqlThemeIcon; + static readonly ServerLevelEndpoint: SqlThemeIcon; + static readonly Synonym: SqlThemeIcon; + static readonly DatabaseTrigger: SqlThemeIcon; + static readonly Assembly: SqlThemeIcon; + static readonly MessageType: SqlThemeIcon; + static readonly Contract: SqlThemeIcon; + static readonly Queue: SqlThemeIcon; + static readonly Service: SqlThemeIcon; + static readonly Route: SqlThemeIcon; + static readonly DatabaseAndQueueEventNotification: SqlThemeIcon; + static readonly RemoteServiceBinding: SqlThemeIcon; + static readonly BrokerPriority: SqlThemeIcon; + static readonly FullTextCatalog: SqlThemeIcon; + static readonly FullTextStopList: SqlThemeIcon; + static readonly SqlLogFile: SqlThemeIcon; + static readonly PartitionFunction: SqlThemeIcon; + static readonly PartitionScheme: SqlThemeIcon; + static readonly SearchPropertyList: SqlThemeIcon; + static readonly User: SqlThemeIcon; + static readonly Schema: SqlThemeIcon; + static readonly AsymmetricKey: SqlThemeIcon; + static readonly Certificate: SqlThemeIcon; + static readonly SymmetricKey: SqlThemeIcon; + static readonly DatabaseEncryptionKey: SqlThemeIcon; + static readonly MasterKey: SqlThemeIcon; + static readonly DatabaseAuditSpecification: SqlThemeIcon; + static readonly Column: SqlThemeIcon; + static readonly Key: SqlThemeIcon; + static readonly Constraint: SqlThemeIcon; + static readonly Trigger: SqlThemeIcon; + static readonly Index: SqlThemeIcon; + static readonly Statistic: SqlThemeIcon; + static readonly UserDefinedDataType: SqlThemeIcon; + static readonly UserDefinedType: SqlThemeIcon; + static readonly XmlSchemaCollection: SqlThemeIcon; + static readonly SystemExactNumeric: SqlThemeIcon; + static readonly SystemApproximateNumeric: SqlThemeIcon; + static readonly SystemDateAndTime: SqlThemeIcon; + static readonly SystemCharacterString: SqlThemeIcon; + static readonly SystemUnicodeCharacterString: SqlThemeIcon; + static readonly SystemBinaryString: SqlThemeIcon; + static readonly SystemOtherDataType: SqlThemeIcon; + static readonly SystemClrDataType: SqlThemeIcon; + static readonly SystemSpatialDataType: SqlThemeIcon; + static readonly UserDefinedTableTypeColumn: SqlThemeIcon; + static readonly UserDefinedTableTypeKey: SqlThemeIcon; + static readonly UserDefinedTableTypeConstraint: SqlThemeIcon; + static readonly StoredProcedureParameter: SqlThemeIcon; + static readonly TableValuedFunctionParameter: SqlThemeIcon; + static readonly ScalarValuedFunctionParameter: SqlThemeIcon; + static readonly AggregateFunctionParameter: SqlThemeIcon; + static readonly DatabaseRole: SqlThemeIcon; + static readonly ApplicationRole: SqlThemeIcon; + static readonly FileGroupFile: SqlThemeIcon; + static readonly SystemMessageType: SqlThemeIcon; + static readonly SystemContract: SqlThemeIcon; + static readonly SystemService: SqlThemeIcon; + static readonly SystemQueue: SqlThemeIcon; + static readonly Sequence: SqlThemeIcon; + static readonly SecurityPolicy: SqlThemeIcon; + static readonly DatabaseScopedCredential: SqlThemeIcon; + static readonly ExternalResource: SqlThemeIcon; + static readonly ExternalDataSource: SqlThemeIcon; + static readonly ExternalFileFormat: SqlThemeIcon; + static readonly ExternalTable: SqlThemeIcon; + static readonly ColumnMasterKey: SqlThemeIcon; + static readonly ColumnEncryptionKey: SqlThemeIcon; + + private constructor(id: string); + + /** + * Gets the ID for the theme icon for help in cases where string comparison is needed + */ + public readonly id: string; + } + + export interface ObjectExplorerSessionResponse { + sessionId: string; + } + + export interface ObjectExplorerExpandInfo { + sessionId: string; + nodePath: string; + nodes: NodeInfo[]; + errorMessage: string; + } + + export interface ExpandNodeInfo { + sessionId: string; + nodePath: string; + } + + export interface FindNodesInfo { + sessionId: string; + type: string; + schema: string; + name: string; + database: string; + parentObjectNames: string[]; + } + + export interface ObjectExplorerCloseSessionInfo { + sessionId: string; + } + + export interface ObjectExplorerCloseSessionResponse { + sessionId: string; + success: boolean; + } + + export interface ObjectExplorerFindNodesResponse { + nodes: NodeInfo[]; + } + + export interface ObjectExplorerProviderBase extends DataProvider { + expandNode(nodeInfo: ExpandNodeInfo): Thenable; + + refreshNode(nodeInfo: ExpandNodeInfo): Thenable; + + findNodes(findNodesInfo: FindNodesInfo): Thenable; + + registerOnExpandCompleted(handler: (response: ObjectExplorerExpandInfo) => any): void; + } + + export interface ObjectExplorerProvider extends ObjectExplorerProviderBase { + createNewSession(connInfo: ConnectionInfo): Thenable; + + closeSession(closeSessionInfo: ObjectExplorerCloseSessionInfo): Thenable; + + registerOnSessionCreated(handler: (response: ObjectExplorerSession) => any): void; + + registerOnSessionDisconnected?(handler: (response: ObjectExplorerSession) => any): void; + } + + export interface ObjectExplorerNodeProvider extends ObjectExplorerProviderBase { + /** + * The providerId for whichever type of ObjectExplorer connection this can add folders and objects to + */ + readonly supportedProviderId: string; + + /** + * Optional group name used to sort nodes in the tree. If not defined, the node order will be added in order based on provider ID, with + * nodes from the main ObjectExplorerProvider for this provider type added first + */ + readonly group?: string; + + handleSessionOpen(session: ObjectExplorerSession): Thenable; + + handleSessionClose(closeSessionInfo: ObjectExplorerCloseSessionInfo): void; + } + + export interface IconProvider extends DataProvider { + getConnectionIconId(connection: IConnectionProfile, serverInfo: ServerInfo): Thenable; + } + + // Admin Services interfaces ----------------------------------------------------------------------- + export interface DatabaseInfo { + options: {}; + } + + export interface LoginInfo { + name: string; + } + + export interface CreateDatabaseResponse { + result: boolean; + taskId: number; + } + + export interface CreateLoginResponse { + result: boolean; + taskId: number; + } + + export interface AdminServicesProvider extends DataProvider { + createDatabase(connectionUri: string, database: DatabaseInfo): Thenable; + + createLogin(connectionUri: string, login: LoginInfo): Thenable; + + getDefaultDatabaseInfo(connectionUri: string): Thenable; + + getDatabaseInfo(connectionUri: string): Thenable; + } + + // Agent Services types + export enum WeekDays { + sunday = 1, + monday = 2, + tuesday = 4, + wednesday = 8, + thursday = 16, + friday = 32, + weekDays = 62, + saturday = 64, + weekEnds = 65, + everyDay = 127 + } + + export enum NotifyMethods { + none = 0, + notifyEmail = 1, + pager = 2, + netSend = 4, + notifyAll = 7 + } + + export enum AlertType { + sqlServerEvent = 1, + sqlServerPerformanceCondition = 2, + nonSqlServerEvent = 3, + wmiEvent = 4 + } + + export enum JobCompletionActionCondition { + Never = 0, + OnSuccess = 1, + OnFailure = 2, + Always = 3 + } + + export enum FrequencyTypes { + Unknown, + OneTime = 1 << 1, + Daily = 1 << 2, + Weekly = 1 << 3, + Monthly = 1 << 4, + MonthlyRelative = 1 << 5, + AutoStart = 1 << 6, + OnIdle = 1 << 7 + } + + export enum FrequencySubDayTypes { + Unknown = 0, + Once = 1, + Second = 2, + Minute = 4, + Hour = 8 + } + + export enum FrequencyRelativeIntervals { + First = 1, + Second = 2, + Third = 4, + Fourth = 8, + Last = 16 + } + + export enum JobExecutionStatus { + Executing = 1, + WaitingForWorkerThread = 2, + BetweenRetries = 3, + Idle = 4, + Suspended = 5, + WaitingForStepToFinish = 6, + PerformingCompletionAction = 7 + } + + export interface AgentJobInfo { + name: string; + owner: string; + description: string; + currentExecutionStatus: number; + lastRunOutcome: number; + currentExecutionStep: string; + enabled: boolean; + hasTarget: boolean; + hasSchedule: boolean; + hasStep: boolean; + runnable: boolean; + category: string; + categoryId: number; + categoryType: number; + lastRun: string; + nextRun: string; + jobId: string; + startStepId: number; + emailLevel: JobCompletionActionCondition; + pageLevel: JobCompletionActionCondition; + eventLogLevel: JobCompletionActionCondition; + deleteLevel: JobCompletionActionCondition; + operatorToEmail: string; + operatorToPage: string; + jobSteps: AgentJobStepInfo[]; + jobSchedules: AgentJobScheduleInfo[]; + alerts: AgentAlertInfo[]; + } + + export interface AgentNotebookInfo extends AgentJobInfo { + templateId: number; + targetDatabase: string; + lastRunNotebookError: string; + executeDatabase: string; + } + + export interface AgentNotebookMaterializedInfo { + materializedId: number; + targetDatabase: string; + materializedName: string; + favorite: boolean; + } + + export interface AgentJobScheduleInfo { + id: number; + name: string; + jobName: string; + isEnabled: boolean; + frequencyTypes: FrequencyTypes; + frequencySubDayTypes: FrequencySubDayTypes; + frequencySubDayInterval: number; + frequencyRelativeIntervals: FrequencyRelativeIntervals; + frequencyRecurrenceFactor: number; + frequencyInterval: number; + dateCreated: string; + activeStartTimeOfDay: string; + activeStartDate: string; + activeEndTimeOfDay: string; + jobCount: number; + activeEndDate: string; + scheduleUid: string; + description: string; + } + + export interface AgentJobStep { + jobId: string; + stepId: string; + stepName: string; + message: string; + runDate: string; + runStatus: number; + stepDetails: AgentJobStepInfo; + } + + export enum AgentSubSystem { + TransactSql = 1, + ActiveScripting = 2, + CmdExec = 3, + Snapshot = 4, + LogReader = 5, + Distribution = 6, + Merge = 7, + QueueReader = 8, + AnalysisQuery = 9, + AnalysisCommands = 10, + Ssis = 11, + PowerShell = 12 + } + + export enum StepCompletionAction { + QuitWithSuccess = 1, + QuitWithFailure = 2, + GoToNextStep = 3, + GoToStep = 4 + } + + export interface AgentJobStepInfo { + jobId: string; + jobName: string; + script: string; + scriptName: string; + stepName: string; + subSystem: AgentSubSystem; + id: number; + failureAction: StepCompletionAction; + successAction: StepCompletionAction; + failStepId: number; + successStepId: number; + command: string; + commandExecutionSuccessCode: number; + databaseName: string; + databaseUserName: string; + server: string; + outputFileName: string; + appendToLogFile: boolean; + appendToStepHist: boolean; + writeLogToTable: boolean; + appendLogToTable: boolean; + retryAttempts: number; + retryInterval: number; + proxyName: string; + } + + export interface AgentJobHistoryInfo { + instanceId: number; + sqlMessageId: string; + message: string; + stepId: string; + stepName: string; + sqlSeverity: string; + jobId: string; + jobName: string; + runStatus: number; + runDate: string; + runDuration: string; + operatorEmailed: string; + operatorNetsent: string; + operatorPaged: string; + retriesAttempted: string; + server: string; + steps: AgentJobStep[]; + } + + export interface AgentNotebookHistoryInfo extends AgentJobHistoryInfo { + materializedNotebookId: number; + materializedNotebookName: string; + materializedNotebookPin: boolean; + materializedNotebookErrorInfo: string; + materializedNotebookDeleted: boolean; + } + + export interface AgentProxyInfo { + id: number; + accountName: string; + description: string; + credentialName: string; + credentialIdentity: string; + credentialId: number; + isEnabled: boolean; + } + + export interface AgentAlertInfo { + id: number; + name: string; + delayBetweenResponses: number; + eventDescriptionKeyword: string; + eventSource: string; + hasNotification: number; + includeEventDescription: NotifyMethods; + isEnabled: boolean; + jobId: string; + jobName: string; + lastOccurrenceDate: string; + lastResponseDate: string; + messageId: number; + notificationMessage: string; + occurrenceCount: number; + performanceCondition: string; + severity: number; + databaseName: string; + countResetDate: string; + categoryName: string; + alertType: AlertType; + wmiEventNamespace: string; + wmiEventQuery: string; + } + + export interface AgentOperatorInfo { + name: string; + id: number; + emailAddress: string; + enabled: boolean; + lastEmailDate: string; + lastNetSendDate: string; + lastPagerDate: string; + pagerAddress: string; + categoryName: string; + pagerDays: WeekDays; + saturdayPagerEndTime: string; + saturdayPagerStartTime: string; + sundayPagerEndTime: string; + sundayPagerStartTime: string; + netSendAddress: string; + weekdayPagerStartTime: string; + weekdayPagerEndTime: string; + } + + export interface ResultStatus { + success: boolean; + errorMessage: string; + } + + export interface AgentJobsResult extends ResultStatus { + jobs: AgentJobInfo[]; + } + + export interface AgentJobHistoryResult extends ResultStatus { + histories: AgentJobHistoryInfo[]; + schedules: AgentJobScheduleInfo[]; + alerts: AgentAlertInfo[]; + steps: AgentJobStepInfo[]; + } + + export interface CreateAgentJobResult extends ResultStatus { + job: AgentJobInfo; + } + + export interface UpdateAgentJobResult extends ResultStatus { + job: AgentJobInfo; + } + + export interface AgentJobCategory { + id: string; + name: string; + } + + export interface AgentJobDefaultsResult extends ResultStatus { + owner: string; + categories: AgentJobCategory[]; + } + + export interface AgentNotebooksResult extends ResultStatus { + notebooks: AgentNotebookInfo[]; + } + + export interface AgentJobHistoryResult extends ResultStatus { + histories: AgentJobHistoryInfo[]; + schedules: AgentJobScheduleInfo[]; + alerts: AgentAlertInfo[]; + steps: AgentJobStepInfo[]; + } + + export interface AgentNotebookHistoryResult extends ResultStatus { + histories: AgentNotebookHistoryInfo[]; + schedules: AgentJobScheduleInfo[]; + steps: AgentJobStepInfo[]; + } + + export interface AgentNotebookMaterializedResult extends ResultStatus { + notebookMaterialized: string; + } + + export interface AgentNotebookTemplateResult extends ResultStatus { + notebookTemplate: string; + } + + export interface CreateAgentNotebookResult extends ResultStatus { + notebook: AgentNotebookInfo; + } + + export interface UpdateAgentNotebookResult extends ResultStatus { + notebook: AgentNotebookInfo; + } + + export interface CreateAgentJobStepResult extends ResultStatus { + step: AgentJobStepInfo; + } + + export interface UpdateAgentJobStepResult extends ResultStatus { + step: AgentJobStepInfo; + } + + export interface CreateAgentProxyResult extends ResultStatus { + step: AgentJobStepInfo; + } + + export interface UpdateAgentProxyResult extends ResultStatus { + step: AgentJobStepInfo; + } + + export interface AgentAlertsResult extends ResultStatus { + alerts: AgentAlertInfo[]; + } + + export interface CreateAgentAlertResult extends ResultStatus { + alert: AgentJobStepInfo; + } + + export interface UpdateAgentAlertResult extends ResultStatus { + alert: AgentJobStepInfo; + } + + export interface AgentOperatorsResult extends ResultStatus { + operators: AgentOperatorInfo[]; + } + + export interface CreateAgentOperatorResult extends ResultStatus { + operator: AgentOperatorInfo; + } + + export interface UpdateAgentOperatorResult extends ResultStatus { + operator: AgentOperatorInfo; + } + + export interface AgentProxiesResult extends ResultStatus { + proxies: AgentProxyInfo[]; + } + + export interface CreateAgentProxyResult extends ResultStatus { + proxy: AgentProxyInfo; + } + + export interface UpdateAgentProxyResult extends ResultStatus { + proxy: AgentProxyInfo; + } + + export interface AgentJobSchedulesResult extends ResultStatus { + schedules: AgentJobScheduleInfo[]; + } + + export interface CreateAgentJobScheduleResult extends ResultStatus { + schedule: AgentJobScheduleInfo; + } + + export interface UpdateAgentJobScheduleResult extends ResultStatus { + schedule: AgentJobScheduleInfo; + } + + export interface AgentServicesProvider extends DataProvider { + // Job management methods + getJobs(ownerUri: string): Thenable; + getJobHistory(ownerUri: string, jobId: string, jobName: string): Thenable; + jobAction(ownerUri: string, jobName: string, action: string): Thenable; + createJob(ownerUri: string, jobInfo: AgentJobInfo): Thenable; + updateJob(ownerUri: string, originalJobName: string, jobInfo: AgentJobInfo): Thenable; + deleteJob(ownerUri: string, jobInfo: AgentJobInfo): Thenable; + getJobDefaults(ownerUri: string): Thenable; + + // Notebook management methods + getNotebooks(ownerUri: string): Thenable; + getNotebookHistory(ownerUri: string, jobId: string, jobName: string, targetDatabase: string): Thenable; + getMaterializedNotebook(ownerUri: string, targetDatabase: string, notebookMaterializedId: number): Thenable; + getTemplateNotebook(ownerUri: string, targetDatabase: string, jobId: string): Thenable; + createNotebook(ownerUri: string, notebook: AgentNotebookInfo, templateFilePath: string): Thenable; + deleteNotebook(ownerUri: string, notebook: AgentNotebookInfo): Thenable; + updateNotebook(ownerUri: string, originialNotebookName: string, notebook: AgentNotebookInfo, templateFilePath: string): Thenable; + updateNotebookMaterializedName(ownerUri: string, agentNotebookHistory: AgentNotebookHistoryInfo, targetDatabase: string, name: string): Thenable; + updateNotebookMaterializedPin(ownerUri: string, agentNotebookHistory: AgentNotebookHistoryInfo, targetDatabase: string, pin: boolean): Thenable; + deleteMaterializedNotebook(ownerUri: string, agentNotebookHistory: AgentNotebookHistoryInfo, targetDatabase: string): Thenable; + + // Job Step management methods + createJobStep(ownerUri: string, stepInfo: AgentJobStepInfo): Thenable; + updateJobStep(ownerUri: string, originalJobStepName: string, stepInfo: AgentJobStepInfo): Thenable; + deleteJobStep(ownerUri: string, stepInfo: AgentJobStepInfo): Thenable; + + // Alert management methods + getAlerts(ownerUri: string): Thenable; + createAlert(ownerUri: string, alertInfo: AgentAlertInfo): Thenable; + updateAlert(ownerUri: string, originalAlertName: string, alertInfo: AgentAlertInfo): Thenable; + deleteAlert(ownerUri: string, alertInfo: AgentAlertInfo): Thenable; + + // Operator management methods + getOperators(ownerUri: string): Thenable; + createOperator(ownerUri: string, operatorInfo: AgentOperatorInfo): Thenable; + updateOperator(ownerUri: string, originalOperatorName: string, operatorInfo: AgentOperatorInfo): Thenable; + deleteOperator(ownerUri: string, operatorInfo: AgentOperatorInfo): Thenable; + + // Proxy management methods + getProxies(ownerUri: string): Thenable; + createProxy(ownerUri: string, proxyInfo: AgentProxyInfo): Thenable; + updateProxy(ownerUri: string, originalProxyName: string, proxyInfo: AgentProxyInfo): Thenable; + deleteProxy(ownerUri: string, proxyInfo: AgentProxyInfo): Thenable; + + // Credential method + getCredentials(ownerUri: string): Thenable; + + // Job Schedule management methods + getJobSchedules(ownerUri: string): Thenable; + createJobSchedule(ownerUri: string, scheduleInfo: AgentJobScheduleInfo): Thenable; + updateJobSchedule(ownerUri: string, originalScheduleName: string, scheduleInfo: AgentJobScheduleInfo): Thenable; + deleteJobSchedule(ownerUri: string, scheduleInfo: AgentJobScheduleInfo): Thenable; + + registerOnUpdated(handler: () => any): void; + } + + // DacFx interfaces ----------------------------------------------------------------------- + + + // Security service interfaces ------------------------------------------------------------------------ + export interface CredentialInfo { + id: number; + identity: string; + name: string; + dateLastModified: string; + createDate: string; + providerName: string; + } + + export interface GetCredentialsResult extends ResultStatus { + credentials: CredentialInfo[]; + } + + // Task service interfaces ---------------------------------------------------------------------------- + export enum TaskStatus { + NotStarted = 0, + InProgress = 1, + Succeeded = 2, + SucceededWithWarning = 3, + Failed = 4, + Canceled = 5, + Canceling = 6 + } + + export enum TaskExecutionMode { + execute = 0, + script = 1, + executeAndScript = 2, + } + + export interface ListTasksParams { + listActiveTasksOnly: boolean; + } + + export interface TaskInfo { + connection?: connection.Connection; + taskId: string; + status: TaskStatus; + taskExecutionMode: TaskExecutionMode; + serverName: string; + databaseName: string; + name: string; + description: string; + providerName: string; + isCancelable: boolean; + } + + export interface ListTasksResponse { + tasks: TaskInfo[]; + } + + export interface CancelTaskParams { + taskId: string; + } + + export interface TaskProgressInfo { + taskId: string; + status: TaskStatus; + message: string; + script?: string; + } + + export interface TaskServicesProvider extends DataProvider { + getAllTasks(listTasksParams: ListTasksParams): Thenable; + + cancelTask(cancelTaskParams: CancelTaskParams): Thenable; + + registerOnTaskCreated(handler: (response: TaskInfo) => any): void; + + registerOnTaskStatusChanged(handler: (response: TaskProgressInfo) => any): void; + } + + // Disaster Recovery interfaces ----------------------------------------------------------------------- + + export interface BackupConfigInfo { + recoveryModel: string; + defaultBackupFolder: string; + backupEncryptors: {}; + } + + export interface BackupResponse { + result: boolean; + taskId: number; + } + + export interface BackupProvider extends DataProvider { + backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: TaskExecutionMode): Thenable; + getBackupConfigInfo(connectionUri: string): Thenable; + } + + export interface RestoreProvider extends DataProvider { + getRestorePlan(connectionUri: string, restoreInfo: RestoreInfo): Thenable; + cancelRestorePlan(connectionUri: string, restoreInfo: RestoreInfo): Thenable; + restore(connectionUri: string, restoreInfo: RestoreInfo): Thenable; + getRestoreConfigInfo(connectionUri: string): Thenable; + } + + export interface RestoreInfo { + options: { [key: string]: any }; + taskExecutionMode: TaskExecutionMode; + } + + export interface RestoreDatabaseFileInfo { + fileType: string; + + logicalFileName: string; + + originalFileName: string; + + restoreAsFileName: string; + } + + export interface DatabaseFileInfo { + properties: LocalizedPropertyInfo[]; + id: string; + isSelected: boolean; + } + + export interface LocalizedPropertyInfo { + propertyName: string; + propertyValue: string; + propertyDisplayName: string; + propertyValueDisplayName: string; + } + + export interface RestorePlanDetailInfo { + name: string; + currentValue: any; + isReadOnly: boolean; + isVisible: boolean; + defaultValue: any; + } + + export interface RestorePlanResponse { + sessionId: string; + backupSetsToRestore: DatabaseFileInfo[]; + canRestore: boolean; + errorMessage: string; + dbFiles: RestoreDatabaseFileInfo[]; + databaseNamesFromBackupSets: string[]; + planDetails: { [key: string]: RestorePlanDetailInfo }; + } + + export interface RestoreConfigInfo { + configInfo: { [key: string]: any }; + } + + export interface RestoreResponse { + result: boolean; + taskId: string; + errorMessage: string; + } + + export interface ProfilerProvider extends DataProvider { + createSession(sessionId: string, sessionName: string, template: ProfilerSessionTemplate): Thenable; + startSession(sessionId: string, sessionName: string): Thenable; + stopSession(sessionId: string): Thenable; + pauseSession(sessionId: string): Thenable; + getXEventSessions(sessionId: string): Thenable; + connectSession(sessionId: string): Thenable; + disconnectSession(sessionId: string): Thenable; + + registerOnSessionEventsAvailable(handler: (response: ProfilerSessionEvents) => any): void; + registerOnSessionStopped(handler: (response: ProfilerSessionStoppedParams) => any): void; + registerOnProfilerSessionCreated(handler: (response: ProfilerSessionCreatedParams) => any): void; + } + + export interface IProfilerTableRow { + /** + * Name of the event; known issue this is not camel case, need to figure + * out a better way to determine column id's from rendered column names + */ + EventClass: string; + } + + export interface IProfilerMoreRowsNotificationParams { + uri: string; + rowCount: number; + data: IProfilerTableRow; + } + + /** + * Profiler Event + */ + export interface ProfilerEvent { + /** + * Event class name + */ + name: string; + + /** + * Event timestamp + */ + timestamp: string; + + /** + * Event values + */ + values: {}; + } + + /** + * Profiler Session Template + */ + export interface ProfilerSessionTemplate { + /** + * Template name + */ + name: string; + + /** + * Default view for template + */ + defaultView: string; + + /** + * TSQL for creating a session + */ + createStatement: string; + } + + export interface ProfilerSessionEvents { + sessionId: string; + + events: ProfilerEvent[]; + + eventsLost: boolean; + } + + export interface ProfilerSessionStoppedParams { + + ownerUri: string; + + sessionId: number; + } + + export interface ProfilerSessionCreatedParams { + ownerUri: string; + sessionName: string; + templateName: string; + } + + // File browser interfaces ----------------------------------------------------------------------- + + export interface FileBrowserProvider extends DataProvider { + openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable; + registerOnFileBrowserOpened(handler: (response: FileBrowserOpenedParams) => any): void; + expandFolderNode(ownerUri: string, expandPath: string): Thenable; + registerOnFolderNodeExpanded(handler: (response: FileBrowserExpandedParams) => any): void; + validateFilePaths(ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable; + registerOnFilePathsValidated(handler: (response: FileBrowserValidatedParams) => any): void; + closeFileBrowser(ownerUri: string): Thenable; + } + + export interface FileTreeNode { + children: FileTreeNode[]; + isExpanded: boolean; + isFile: boolean; + name: string; + fullPath: string; + } + + export interface FileTree { + rootNode: FileTreeNode; + selectedNode: FileTreeNode; + } + + export interface FileBrowserOpenedParams { + ownerUri: string; + fileTree: FileTree; + succeeded: boolean; + message: string; + } + + export interface FileBrowserExpandedParams { + ownerUri: string; + expandPath: string; + children: FileTreeNode[]; + succeeded: boolean; + message: string; + } + + export interface FileBrowserValidatedParams { + succeeded: boolean; + message: string; + } + + export interface FileBrowserCloseResponse { + succeeded: boolean; + message: string; + } + + // ACCOUNT MANAGEMENT ////////////////////////////////////////////////// + export namespace accounts { + export function registerAccountProvider(providerMetadata: AccountProviderMetadata, provider: AccountProvider): vscode.Disposable; + + /** + * Launches a flyout dialog that will display the information on how to complete device + * code OAuth login to the user. Only one flyout can be opened at once and each must be closed + * by calling {@link endAutoOAuthDeviceCode}. + * @param providerId ID of the provider that's requesting the flyout be opened + */ + export function beginAutoOAuthDeviceCode(providerId: string, title: string, message: string, userCode: string, uri: string): Thenable; + + /** + * Closes the flyout dialog opened by {@link beginAutoOAuthDeviceCode} + */ + export function endAutoOAuthDeviceCode(): void; + + /** + * Notifies the account management service that an account has updated (usually due to the + * account going stale). + * @param updatedAccount Account object with updated properties + */ + export function accountUpdated(updatedAccount: Account): void; + + /** + * Gets all added accounts. + * @returns Promise to return the accounts + */ + export function getAllAccounts(): Thenable; + + /** + * Generates a security token by asking the account's provider + * @param account Account to generate security token for (defaults to + * AzureResource.ResourceManagement if not given) + * @return Promise to return the security token + */ + export function getSecurityToken(account: Account, resource?: AzureResource): Thenable<{}>; + + /** + * An [event](#Event) which fires when the accounts have changed. + */ + export const onDidChangeAccounts: vscode.Event; + } + + /** + * Represents display information for an account. + */ + export interface AccountDisplayInfo { + /** + * A display name that offers context for the account, such as "Contoso". + */ + contextualDisplayName: string; + + /** + * account provider (eg, Work/School vs Microsoft Account) + */ + accountType: string; + + /** + * A display name that identifies the account, such as "User Name". + */ + displayName: string; + + /** + * User id that identifies the account, such as "user@contoso.com". + */ + userId: string; + } + + /** + * Represents a key that identifies an account. + */ + export interface AccountKey { + /** + * Identifier of the provider + */ + providerId: string; + + /** + * Any arguments that identify an instantiation of the provider + */ + providerArgs?: any; + + /** + * Identifier for the account, unique to the provider + */ + accountId: string; + } + + /** + * Represents an account. + */ + export interface Account { + /** + * The key that identifies the account + */ + key: AccountKey; + + /** + * Display information for the account + */ + displayInfo: AccountDisplayInfo; + + /** + * Custom properties stored with the account + */ + properties: any; + + /** + * Indicates if the account needs refreshing + */ + isStale: boolean; + } + + export enum AzureResource { + ResourceManagement = 0, + Sql = 1 + } + + export interface DidChangeAccountsParams { + // Updated accounts + accounts: Account[]; + } + + // - ACCOUNT PROVIDER ////////////////////////////////////////////////// + /** + * Error to be used when the user has cancelled the prompt or refresh methods. When + * AccountProvider.refresh or AccountProvider.prompt are rejected with this error, the error + * will not be reported to the user. + */ + export interface PromptFailedResult { + /** + * Type guard for differentiating user cancelled sign in errors from other errors + */ + canceled: boolean; + } + + /** + * Represents a provider of accounts. + */ + export interface AccountProviderMetadata { + /** + * The identifier of the provider + */ + id: string; + + /** + * Display name of the provider + */ + displayName: string; + + /** + * Any arguments that identify an instantiation of the provider + */ + args?: any; + + /** + * Optional settings that identify an instantiation of a provider + */ + settings?: {}; + } + + /** + * Represents a provider of accounts for use with the account management service + */ + export interface AccountProvider { + /** + * Initializes the account provider with the accounts restored from the memento, + * @param storedAccounts Accounts restored from the memento + * @return Account objects after being rehydrated (if necessary) + */ + initialize(storedAccounts: Account[]): Thenable; + + /** + * Generates a security token for the provided account + * @param account The account to generate a security token for + * @param resource The resource to get the token for + * @return Promise to return a security token object + */ + getSecurityToken(account: Account, resource: AzureResource): Thenable<{}>; + + /** + * Prompts the user to enter account information. + * Returns an error if the user canceled the operation. + */ + prompt(): Thenable; + + /** + * Refreshes a stale account. + * Returns an error if the user canceled the operation. + * Otherwise, returns a new updated account instance. + * @param account - An account. + */ + refresh(account: Account): Thenable; + + /** + * Clears sensitive information for an account. To be called when account is removed + * @param accountKey - Key that uniquely identifies the account to clear + */ + clear(accountKey: AccountKey): Thenable; + + /** + * Called from the account management service when the user has cancelled an auto OAuth + * authorization process. Implementations should use this to cancel any polling process + * and call the end OAuth method. + */ + autoOAuthCancelled(): Thenable; + } + + // Resource provider interfaces ----------------------------------------------------------------------- + + // - ACCOUNT PROVIDER ////////////////////////////////////////////////// + /** + * Represents a provider of accounts. + */ + export interface ResourceProviderMetadata { + /** + * The identifier of the provider + */ + id: string; + + /** + * Display name of the provider + */ + displayName: string; + + /** + * Optional settings that identify an instantiation of a provider + */ + settings?: {}; + } + + export namespace resources { + /** + * Registers a resource provider that can suport + */ + export function registerResourceProvider(providerMetadata: ResourceProviderMetadata, provider: ResourceProvider): vscode.Disposable; + } + + /** + * Represents a provider of resource + */ + export interface ResourceProvider { + createFirewallRule(account: Account, firewallruleInfo: FirewallRuleInfo): Thenable; + handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Thenable; + } + + export interface FirewallRuleInfo { + startIpAddress: string; + endIpAddress: string; + serverName: string; + securityTokenMappings: {}; + } + + export interface CreateFirewallRuleResponse { + result: boolean; + errorMessage: string; + } + + export interface HandleFirewallRuleResponse { + result: boolean; + ipAddress: string; + } + + export interface ModalDialog { + /** + * Title of the webview. + */ + title: string; + + /** + * Contents of the dialog body. + */ + html: string; + + /** + * The caption of the OK button. + */ + okTitle: string; + + /** + * The caption of the Close button. + */ + closeTitle: string; + + /** + * Opens the dialog. + */ + open(): void; + + /** + * Closes the dialog. + */ + close(): void; + + /** + * Raised when the webview posts a message. + */ + readonly onMessage: vscode.Event; + + /** + * Raised when dialog closed. + */ + readonly onClosed: vscode.Event; + + /** + * Post a message to the dialog. + * + * @param message Body of the message. + */ + postMessage(message: any): Thenable; + } + + export interface DashboardWebview { + + /** + * Raised when the webview posts a message. + */ + readonly onMessage: vscode.Event; + + /** + * Raised when the webview closed. + */ + readonly onClosed: vscode.Event; + + /** + * Post a message to the webview. + * + * @param message Body of the message. + */ + postMessage(message: any): Thenable; + + /** + * The connection info for the dashboard the webview exists on + */ + readonly connection: connection.Connection; + + /** + * The info on the server for the webview dashboard + */ + readonly serverInfo: ServerInfo; + + /** + * Contents of the dialog body. + */ + html: string; + } + + export namespace dashboard { + /** + * Register a provider for a webview widget + */ + export function registerWebviewProvider(widgetId: string, handler: (webview: DashboardWebview) => void): void; + } + + export namespace workspace { + /** + * An event that is emitted when a [dashboard](#DashboardDocument) is opened. + */ + export const onDidOpenDashboard: vscode.Event; + + /** + * An event that is emitted when a [dashboard](#DashboardDocument) is focused. + */ + export const onDidChangeToDashboard: vscode.Event; + } + + export interface DashboardDocument { + profile: IConnectionProfile; + serverInfo: ServerInfo; + } + + export enum ExtensionNodeType { + Server = 'Server', + Database = 'Database' + } + + export class TreeItem extends vscode.TreeItem { + payload?: IConnectionProfile; + childProvider?: string; + type?: ExtensionNodeType; + } + + export namespace tasks { + + export interface ITaskHandler { + (profile: IConnectionProfile, ...args: any[]): any; + } + + /** + * Registers a task that can be invoked via a keyboard shortcut, + * a menu item, an action, or directly. + * + * Registering a task with an existing task identifier twice + * will cause an error. + * + * @param task A unique identifier for the task. + * @param callback A task handler function. + * @param thisArg The `this` context used when invoking the handler function. + * @return Disposable which unregisters this task on disposal. + */ + export function registerTask(task: string, callback: ITaskHandler, thisArg?: any): vscode.Disposable; + } + + /** + * Supports defining a model that can be instantiated as a view in the UI + * @export + */ + export interface ModelBuilder { + navContainer(): ContainerBuilder; + divContainer(): DivBuilder; + flexContainer(): FlexBuilder; + splitViewContainer(): SplitViewBuilder; + dom(): ComponentBuilder; + /** + * @deprecated please use radioCardGroup component. + */ + card(): ComponentBuilder; + inputBox(): ComponentBuilder; + checkBox(): ComponentBuilder; + radioButton(): ComponentBuilder; + webView(): ComponentBuilder; + editor(): ComponentBuilder; + diffeditor(): ComponentBuilder; + text(): ComponentBuilder; + image(): ComponentBuilder; + button(): ComponentBuilder; + dropDown(): ComponentBuilder; + tree(): ComponentBuilder>; + listBox(): ComponentBuilder; + table(): ComponentBuilder; + declarativeTable(): ComponentBuilder; + dashboardWidget(widgetId: string): ComponentBuilder; + dashboardWebview(webviewId: string): ComponentBuilder; + formContainer(): FormBuilder; + groupContainer(): GroupBuilder; + toolbarContainer(): ToolbarBuilder; + loadingComponent(): LoadingComponentBuilder; + fileBrowserTree(): ComponentBuilder; + hyperlink(): ComponentBuilder; + } + + export interface TreeComponentDataProvider extends vscode.TreeDataProvider { + getTreeItem(element: T): TreeComponentItem | Thenable; + } + + export interface NodeCheckedEventParameters { + element: T; + checked: boolean; + } + + export interface TreeComponentView extends vscode.Disposable { + onNodeCheckedChanged: vscode.Event>; + onDidChangeSelection: vscode.Event>; + } + + export class TreeComponentItem extends vscode.TreeItem { + checked?: boolean; + enabled?: boolean; + } + + export interface ComponentBuilder { + component(): T; + withProperties(properties: U): ComponentBuilder; + withValidation(validation: (component: T) => boolean): ComponentBuilder; + } + export interface ContainerBuilder extends ComponentBuilder { + withLayout(layout: TLayout): ContainerBuilder; + withItems(components: Array, itemLayout?: TItemLayout): ContainerBuilder; + } + + export interface FlexBuilder extends ContainerBuilder { + + } + + // Building on top of flex item + export interface SplitViewBuilder extends ContainerBuilder { + + } + + export interface DivBuilder extends ContainerBuilder { + + } + + export interface GroupBuilder extends ContainerBuilder { + } + + export interface ToolbarBuilder extends ContainerBuilder { + withToolbarItems(components: ToolbarComponent[]): ContainerBuilder; + + /** + * Creates a collection of child components and adds them all to this container + * + * @param toolbarComponents the definitions + */ + addToolbarItems(toolbarComponents: Array): void; + + /** + * Creates a child component and adds it to this container. + * + * @param toolbarComponent the component to be added + */ + addToolbarItem(toolbarComponent: ToolbarComponent): void; + } + + export interface LoadingComponentBuilder extends ComponentBuilder { + /** + * Set the component wrapped by the LoadingComponent + * @param component The component to wrap + */ + withItem(component: Component): LoadingComponentBuilder; + } + + export interface FormBuilder extends ContainerBuilder { + withFormItems(components: (FormComponent | FormComponentGroup)[], itemLayout?: FormItemLayout): FormBuilder; + + /** + * Creates a collection of child components and adds them all to this container + * + * @param formComponents the definitions + * @param [itemLayout] Optional layout for the child items + */ + addFormItems(formComponents: Array, itemLayout?: FormItemLayout): void; + + /** + * Creates a child component and adds it to this container. + * + * @param formComponent the component to be added + * @param [itemLayout] Optional layout for this child item + */ + addFormItem(formComponent: FormComponent | FormComponentGroup, itemLayout?: FormItemLayout): void; + + /** + * Inserts a from component in a given position in the form. Returns error given invalid index + * @param formComponent Form component + * @param index index to insert the component to + * @param itemLayout Item Layout + */ + insertFormItem(formComponent: FormComponent | FormComponentGroup, index?: number, itemLayout?: FormItemLayout): void; + + /** + * Removes a from item from the from + */ + removeFormItem(formComponent: FormComponent | FormComponentGroup): boolean; + } + + export interface Component extends ComponentProperties { + readonly id: string; + + /** + * Sends any updated properties of the component to the UI + * + * @returns Thenable that completes once the update + * has been applied in the UI + */ + updateProperties(properties: { [key: string]: any }): Thenable; + + /** + * Sends an updated property of the component to the UI + * + * @returns Thenable that completes once the update + * has been applied in the UI + */ + updateProperty(key: string, value: any): Thenable; + + /** + * Updates the specified CSS Styles and notifies the UI + * @param cssStyles The styles to update + * @returns Thenable that completes once the update has been applied to the UI + */ + updateCssStyles(cssStyles: { [key: string]: string }): Thenable; + + /** + * Event fired to notify that the component's validity has changed + */ + readonly onValidityChanged: vscode.Event; + + /** + * Whether the component is valid or not + */ + readonly valid: boolean; + + /** + * Run the component's validations + */ + validate(): Thenable; + + /** + * Focuses the component. + */ + focus(): Thenable; + } + + export interface FormComponent { + component: Component; + title: string; + actions?: Component[]; + required?: boolean; + } + + /** + * Used to create a group of components in a form layout + */ + export interface FormComponentGroup { + /** + * The form components to display in the group along with optional layouts for each item + */ + components: (FormComponent & { layout?: FormItemLayout })[]; + + /** + * The title of the group, displayed above its components + */ + title: string; + } + + export interface ToolbarComponent { + component: Component; + title?: string; + toolbarSeparatorAfter?: boolean; + } + + /** + * A component that contains other components + */ + export interface Container extends Component { + /** + * A copy of the child items array. This cannot be added to directly - + * components must be created using the create methods instead + */ + readonly items: Component[]; + + /** + * Removes all child items from this container + */ + clearItems(): void; + /** + * Creates a collection of child components and adds them all to this container + * + * @param itemConfigs the definitions + * @param [itemLayout] Optional layout for the child items + */ + addItems(itemConfigs: Array, itemLayout?: TItemLayout): void; + + /** + * Creates a child component and adds it to this container. + * Adding component to multiple containers is not supported + * + * @param component the component to be added + * @param [itemLayout] Optional layout for this child item + */ + addItem(component: Component, itemLayout?: TItemLayout): void; + + /** + * Creates a child component and inserts it to this container. Returns error given invalid index + * Adding component to multiple containers is not supported + * @param component the component to be added + * @param index the index to insert the component to + * @param [itemLayout] Optional layout for this child item + */ + insertItem(component: Component, index: number, itemLayout?: TItemLayout): void; + + /** + * + * @param component Removes a component from this container + */ + removeItem(component: Component): boolean; + + /** + * Defines the layout for this container + * + * @param layout object + */ + setLayout(layout: TLayout): void; + } + + export interface NavContainer extends Container { + + } + + /** + * Valid values for the align-items CSS property + */ + export type AlignItemsType = 'normal' | 'stretch' | 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'baseline' | 'first baseline' | 'last baseline' | 'safe center' | 'unsafe center' | 'inherit' | 'initial' | 'unset'; + + /** + * Valid values for the justify-content CSS property + */ + export type JustifyContentType = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'initial' | 'inherit'; + /** + * Valid values for the align-content CSS property + */ + export type AlignContentType = 'stretch' | 'center' | 'flex-start' | 'flex-end' | 'space-between' | 'space-around' | 'initial' | 'inherit'; + /** + * Valid values for flex-wrap CSS property + */ + export type FlexWrapType = 'nowrap' | 'wrap' | 'wrap-reverse'; + /** + * Valid values for the text-align CSS property + */ + export type TextAlignType = 'left' | 'right' | 'center' | 'justify' | 'initial' | 'inherit'; + /** + * Valid values for the position CSS property + */ + export type PositionType = 'static' | 'absolute' | 'fixed' | 'relative' | 'sticky' | 'initial' | 'inherit'; + /** + * Valid values for the display CSS property + */ + export type DisplayType = 'inline' | 'block' | 'contents' | 'flex' | 'grid' | 'inline-block' | 'inline-flex' | 'inline-grid' | 'inline-table' | 'list-item' | 'run-in' | 'table' | 'table-caption' | ' table-column-group' | 'table-header-group' | 'table-footer-group' | 'table-row-group' | 'table-cell' | 'table-column' | 'table-row' | 'none' | 'initial' | 'inherit' | ''; + + /** + * The config for a FlexBox-based container. This supports easy + * addition of content to a container with a flexible layout + * and use of space. + */ + export interface FlexLayout { + /** + * Matches the flex-flow CSS property and its available values. + * To layout as a vertical view use "column", and for horizontal + * use "row". + */ + flexFlow?: string; + /** + * Matches the justify-content CSS property. + */ + justifyContent?: JustifyContentType; + /** + * Matches the align-items CSS property. + */ + alignItems?: AlignItemsType; + /** + * Matches the align-content CSS property. + */ + alignContent?: AlignContentType; + /** + * Matches the flex-wrap CSS property. + */ + flexWrap?: FlexWrapType; + /** + * Container Height + */ + height?: number | string; + + /** + * Container Width + */ + width?: number | string; + + /** + * + */ + textAlign?: TextAlignType; + + /** + * The position CSS property. Empty by default. + * This is particularly useful if laying out components inside a FlexContainer and + * the size of the component is meant to be a fixed size. In this case the position must be + * set to 'absolute', with the parent FlexContainer having 'relative' position. + * Without this the component will fail to correctly size itself. + */ + position?: PositionType; + } + + export interface SplitViewLayout extends FlexLayout { + + /** + * Orientation of the views inside split + */ + orientation: string; + + /** + * SplitView height + */ + splitViewHeight: number | string; + } + + export interface FlexItemLayout { + /** + * Matches the order CSS property and its available values. + */ + order?: number; + /** + * Matches the flex CSS property and its available values. + * Default is "1 1 auto". + */ + flex?: string; + /** + * Matches the CSS style key and its available values. + */ + CSSStyles?: { [key: string]: string }; + } + + export interface FormItemLayout { + horizontal?: boolean; + componentWidth?: number | string; + componentHeight?: number | string; + titleFontSize?: number | string; + info?: string; + } + + export interface FormLayout { + width?: number | string; + height?: number | string; + padding?: string; + } + + export interface GroupLayout { + width?: number | string; + header?: string; + collapsible?: boolean; + collapsed?: boolean; + } + + export interface GroupItemLayout { + } + + export interface DivLayout { + /** + * Container Height + */ + height?: number | string; + + /** + * Container Width + */ + width?: number | string; + } + + export interface DivItemLayout { + /** + * Matches the order CSS property and its available values. + */ + order?: number; + + /** + * Matches the CSS style key and its available values. + */ + CSSStyles?: { [key: string]: string }; + } + + export interface DivContainer extends Container, DivContainerProperties { + /** + * An event called when the div is clicked + */ + onDidClick: vscode.Event; + } + + export interface FlexContainer extends Container { + } + + export interface SplitViewContainer extends Container { + } + + export interface FormContainer extends Container { + } + + export interface GroupContainer extends Container, GroupContainerProperties { + } + + + export enum Orientation { + Horizontal = 'horizontal', + Vertical = 'vertial' + } + + export interface ToolbarLayout { + orientation: Orientation; + } + export interface ToolbarContainer extends Container { + } + + /** + * Describes an action to be shown in the UI, with a user-readable label + * and a callback to execute the action + */ + export interface ActionDescriptor { + /** + * User-visible label to display + */ + label: string; + /** + * Name of the clickable action. If not defined then no action will be shown + */ + actionTitle?: string; + /** + * Data sent on callback being run. + */ + callbackData?: any; + } + + /** + * Defines status indicators that can be shown to the user as part of + * components such as the Card UI + */ + export enum StatusIndicator { + None = 0, + Ok = 1, + Warning = 2, + Error = 3 + } + + export enum CardType { + VerticalButton = 'VerticalButton', + Details = 'Details', + ListItem = 'ListItem' + } + + /** + * Properties representing the card component, can be used + * when using ModelBuilder to create the component + */ + export interface CardProperties extends ComponentProperties, ComponentWithIcon { + label: string; + value?: string; + actions?: ActionDescriptor[]; + descriptions?: CardDescriptionItem[]; + status?: StatusIndicator; + + /** + * Returns true if the card is selected + */ + selected?: boolean; + + /** + * Card Type, default: Details + */ + cardType?: CardType; + } + + export interface CardDescriptionItem { + label: string; + value?: string; + tooltip?: string; + fontWeight?: 'normal' | 'bold'; + } + + export type InputBoxInputType = 'color' | 'date' | 'datetime-local' | 'email' | 'month' | 'number' | 'password' | 'range' | 'search' | 'text' | 'time' | 'url' | 'week'; + + export interface ComponentProperties { + height?: number | string; + width?: number | string; + /** + * The position CSS property. Empty by default. + * This is particularly useful if laying out components inside a FlexContainer and + * the size of the component is meant to be a fixed size. In this case the position must be + * set to 'absolute', with the parent FlexContainer having 'relative' position. + * Without this the component will fail to correctly size itself + */ + position?: PositionType; + /** + * Whether the component is enabled in the DOM + */ + enabled?: boolean; + /** + * Corresponds to the display CSS property for the element + */ + display?: DisplayType; + /** + * Corresponds to the aria-label accessibility attribute for this component + */ + ariaLabel?: string; + /** + * Corresponds to the role accessibility attribute for this component + */ + ariaRole?: string; + /** + * Corresponds to the aria-selected accessibility attribute for this component + */ + ariaSelected?: boolean; + /** + * Matches the CSS style key and its available values. + */ + CSSStyles?: { [key: string]: string }; + } + + export interface ComponentWithIcon { + /** + * @deprecated This will be moved to `ComponentWithIconProperties` + */ + iconPath?: string | vscode.Uri | { light: string | vscode.Uri; dark: string | vscode.Uri }; + /** + * @deprecated This will be moved to `ComponentWithIconProperties` + */ + iconHeight?: number | string; + /** + * @deprecated This will be moved to `ComponentWithIconProperties` + */ + iconWidth?: number | string; + } + + export interface InputBoxProperties extends ComponentProperties { + value?: string; + ariaLive?: string; + placeHolder?: string; + inputType?: InputBoxInputType; + required?: boolean; + multiline?: boolean; + rows?: number; + columns?: number; + min?: number; + max?: number; + /** + * Whether to stop key event propagation when enter is pressed in the input box. Leaving this as false + * means the event will propagate up to any parents that have handlers (such as validate on Dialogs) + */ + stopEnterPropagation?: boolean; + } + + export interface TableColumn { + value: string; + width?: number; + cssClass?: string; + headerCssClass?: string; + toolTip?: string; + type?: ColumnType; + options?: CheckboxColumnOption | TextColumnOption; + } + + export enum ColumnType { + text = 0, + checkBox = 1, + button = 2 + } + + export interface CheckboxColumnOption { + actionOnCheckbox: ActionOnCellCheckboxCheck; + } + + export interface TextColumnOption { + } + + export enum ActionOnCellCheckboxCheck { + selectRow = 0, + customAction = 1 + } + + export enum ColumnSizingMode { + ForceFit = 0, // all columns will be sized to fit in viewable space, no horiz scroll bar + AutoFit = 1, // columns will be ForceFit up to a certain number; currently 3. At 4 or more the behavior will switch to NO force fit + DataFit = 2 // columns use sizing based on cell data, horiz scroll bar present if more cells than visible in view area + } + + export interface TableComponentProperties extends ComponentProperties { + data: any[][]; + columns: string[] | TableColumn[]; + fontSize?: number | string; + selectedRows?: number[]; + forceFitColumns?: ColumnSizingMode; + title?: string; + ariaRowCount?: number; + ariaColumnCount?: number; + updateCells?: TableCell[]; + moveFocusOutWithTab?: boolean; //accessibility requirement for tables with no actionable cells + } + + export interface CheckBoxCell extends TableCell { + checked: boolean; + columnName: string; + } + + export interface FileBrowserTreeProperties extends ComponentProperties { + ownerUri: string; + } + + export interface CheckBoxProperties extends ComponentProperties { + checked?: boolean; + label?: string; + } + + export interface TreeProperties extends ComponentProperties { + withCheckbox?: boolean; + } + + export enum DeclarativeDataType { + string = 'string', + category = 'category', + boolean = 'boolean', + editableCategory = 'editableCategory' + } + + export interface RadioButtonProperties { + name?: string; + label?: string; + value?: string; + checked?: boolean; + } + + export interface TextComponentProperties extends ComponentProperties, TitledComponentProperties { + value?: string; + links?: LinkArea[]; + description?: string; + requiredIndicator?: boolean; + } + + export interface ImageComponentProperties extends ComponentProperties, ComponentWithIcon { + + } + + export interface GroupContainerProperties { + collapsed: boolean; + } + + export interface LinkArea { + text: string; + url: string; + } + + export interface HyperlinkComponentProperties extends ComponentProperties, TitledComponentProperties { + label: string; + url: string; + } + + export interface DropDownProperties extends ComponentProperties { + value?: string | CategoryValue; + values?: string[] | CategoryValue[]; + editable?: boolean; + fireOnTextChange?: boolean; + required?: boolean; + } + + export interface DeclarativeTableColumn { + displayName: string; + valueType: DeclarativeDataType; + isReadOnly: boolean; + width: number | string; + categoryValues?: CategoryValue[]; + } + + export interface DeclarativeTableProperties { + data: any[][]; + columns: DeclarativeTableColumn[]; + } + + export interface ListBoxProperties { + selectedRow?: number; + values?: string[]; + } + + export interface WebViewProperties extends ComponentProperties { + message?: any; + + /** + * Contents of the webview. + * + * Should be a complete html document. + */ + html?: string; + /** + * Content settings for the webview. + */ + options?: vscode.WebviewOptions; + } + + export interface DomProperties extends ComponentProperties { + /** + * Contents of the DOM component. + */ + html?: string; + } + + /** + * Editor properties for the editor component + */ + export interface EditorProperties extends ComponentProperties { + /** + * The content inside the text editor + */ + content?: string; + /** + * The languge mode for this text editor. The language mode is SQL by default. + */ + languageMode?: string; + /** + * Minimum height for editor component + */ + minimumHeight?: number; + } + + export interface ButtonProperties extends ComponentProperties, ComponentWithIcon { + /** + * The label for the button + */ + label?: string; + /** + * Whether the button opens the file browser dialog + */ + isFile?: boolean; + /** + * The content of the currently selected file + */ + fileContent?: string; + /** + * @deprecated This will be moved to `ComponentWithIconProperties` + * + * The title for the button. This title will show when hovered over + */ + title?: string; + } + + export interface LoadingComponentProperties { + loading?: boolean; + showText?: boolean; + loadingText?: string; + loadingCompletedText?: string; + } + + export interface DivContainerProperties extends ComponentProperties { + /** + * Matches the overflow-y CSS property and its available values. + */ + overflowY?: string; + + /** + * Setting the scroll based on the y offset + * This is used when its child component is webview + */ + yOffsetChange?: number; + + /** + * Indicates whether the element is clickable + */ + clickable?: boolean; + } + + export interface TitledComponentProperties { + /** + * The title for the component. This title will show when hovered over + */ + title?: string; + } + + export interface CardComponent extends Component, CardProperties { + onDidActionClick: vscode.Event; + onCardSelectedChanged: vscode.Event; + } + + export interface DomComponent extends Component, DomProperties { + + } + + export interface TextComponent extends Component, TextComponentProperties { + + } + + export interface ImageComponent extends Component, ImageComponentProperties { + } + + export interface HyperlinkComponent extends Component, HyperlinkComponentProperties { + + } + + export interface InputBoxComponent extends Component, InputBoxProperties { + onTextChanged: vscode.Event; + /** + * Event that's fired whenever enter is pressed within the input box + */ + onEnterKeyPressed: vscode.Event; + } + + export interface RadioButtonComponent extends Component, RadioButtonProperties { + /** + * An event called when the radio button is clicked + */ + onDidClick: vscode.Event; + } + + export interface CheckBoxComponent extends Component, CheckBoxProperties { + onChanged: vscode.Event; + } + + export interface DropDownComponent extends Component, DropDownProperties { + onValueChanged: vscode.Event; + } + + export interface TableCell { + row: number; + column: number; + value: any; + } + + export interface DeclarativeTableComponent extends Component, DeclarativeTableProperties { + onDataChanged: vscode.Event; + } + + export interface ListBoxComponent extends Component, ListBoxProperties { + onRowSelected: vscode.Event; + } + + export interface ICheckboxCellActionEventArgs extends ICellActionEventArgs { + checked: boolean; + } + + interface ICellActionEventArgs { + row: number; + column: number; + columnName: number; + } + + export interface TableComponent extends Component, TableComponentProperties { + onRowSelected: vscode.Event; + onCellAction?: vscode.Event; + } + + export interface FileBrowserTreeComponent extends Component, FileBrowserTreeProperties { + onDidChange: vscode.Event; + } + + export interface TreeComponent extends Component, TreeProperties { + registerDataProvider(dataProvider: TreeComponentDataProvider): TreeComponentView; + } + + export interface WebViewComponent extends Component { + html: string; + message: any; + onMessage: vscode.Event; + readonly options: vscode.WebviewOptions; + } + + /** + * Editor component for displaying the text code editor + */ + export interface EditorComponent extends Component { + /** + * The content inside the text editor + */ + content: string; + /** + * The languge mode for this text editor. The language mode is SQL by default. + */ + languageMode: string; + /** + * The editor Uri which will be used as a reference for VSCode Language Service. + * Currently this is auto-generated by the framework but can be queried after + * view initialization is completed + */ + readonly editorUri: string; + /** + * An event called when the editor content is updated + */ + readonly onContentChanged: vscode.Event; + + /** + * An event called when the editor is created + */ + readonly onEditorCreated: vscode.Event; + + /** + * Toggle for whether the editor should be automatically resized or not + */ + isAutoResizable: boolean; + + /** + * Minimum height for editor component + */ + minimumHeight: number; + + } + + export interface DiffEditorComponent extends Component { + /** + * The content inside the left text editor + */ + contentLeft: string; + /** + * The content inside the right text editor + */ + contentRight: string; + /** + * The languge mode for this text editor. The language mode is SQL by default. + */ + languageMode: string; + /** + * The left editor Uri which will be used as a reference for VSCode Language Service. + * Currently this is auto-generated by the framework but can be queried after + * view initialization is completed + */ + readonly editorUriLeft: string; + /** + * The right editor Uri which will be used as a reference for VSCode Language Service. + * Currently this is auto-generated by the framework but can be queried after + * view initialization is completed + */ + readonly editorUriRight: string; + /** + * An event called when the editor content is updated + */ + readonly onContentChanged: vscode.Event; + + /** + * An event called when the editor is created + */ + readonly onEditorCreated: vscode.Event; + + /** + * Toggle for whether the editor should be automatically resized or not + */ + isAutoResizable: boolean; + + /** + * Minimum height for editor component + */ + minimumHeight: number; + } + + export interface ButtonComponent extends Component, ButtonProperties { + /** + * An event called when the button is clicked + */ + onDidClick: vscode.Event; + } + + export interface DashboardWidgetComponent extends Component { + widgetId: string; + } + + export interface DashboardWebviewComponent extends Component { + webviewId: string; + } + + /** + * Component used to wrap another component that needs to be loaded, and show a loading spinner + * while the contained component is loading + */ + export interface LoadingComponent extends Component { + /** + * Whether to show the loading spinner instead of the contained component. True by default + */ + loading: boolean; + + /** + * The component displayed when the loading property is false + */ + component: Component; + } + + /** + * A view backed by a model provided by an extension. + * This model contains enough information to lay out the view + */ + export interface ModelView { + /** + * Raised when the view closed. + */ + readonly onClosed: vscode.Event; + + /** + * The connection info for the dashboard the webview exists on + */ + readonly connection: connection.Connection; + + /** + * The info on the server for the dashboard + */ + readonly serverInfo: ServerInfo; + + /** + * The model backing the model-based view + */ + readonly modelBuilder: ModelBuilder; + + /** + * Whether or not the model view's root component is valid + */ + readonly valid: boolean; + + /** + * Raised when the model view's valid property changes + */ + readonly onValidityChanged: vscode.Event; + + /** + * Run the model view root component's validations + */ + validate(): Thenable; + + /** + * Initializes the model with a root component definition. + * Once this has been done, the components will be laid out in the UI and + * can be accessed and altered as needed. + */ + initializeModel(root: T): Thenable; + } + + export namespace ui { + /** + * Register a provider for a model-view widget + */ + export function registerModelViewProvider(widgetId: string, handler: (view: ModelView) => void): void; + } + + export namespace window { + /** + * creates a web view dialog + */ + export function createWebViewDialog(title: string): ModalDialog; + + /** + * Create a dialog with the given title + * @param title The title of the dialog, displayed at the top + * @param isWide Indicates whether the dialog is wide or normal + */ + export function createModelViewDialog(title: string, dialogName?: string, isWide?: boolean): Dialog; + + /** + * Create a dialog tab which can be included as part of the content of a dialog + * @param title The title of the page, displayed on the tab to select the page + */ + export function createTab(title: string): DialogTab; + + /** + * Create a button which can be included in a dialog + * @param label The label of the button + */ + export function createButton(label: string, position?: DialogButtonPosition): Button; + + /** + * Opens the given dialog if it is not already open + */ + export function openDialog(dialog: Dialog): void; + + /** + * Closes the given dialog if it is open + */ + export function closeDialog(dialog: Dialog): void; + + /** + * Create a wizard page with the given title, for inclusion in a wizard + * @param title The title of the page + */ + export function createWizardPage(title: string): WizardPage; + + /** + * Create a wizard with the given title and pages + * @param title The title of the wizard + */ + export function createWizard(title: string): Wizard; + + /** + * Used to control whether a message in a dialog/wizard is displayed as an error, + * warning, or informational message. Default is error. + */ + export enum MessageLevel { + Error = 0, + Warning = 1, + Information = 2 + } + + /** + * A message shown in a dialog. If the level is not set it defaults to error. + */ + export type DialogMessage = { + readonly text: string, + readonly description?: string, + readonly level?: MessageLevel + }; + + export interface ModelViewPanel { + /** + * Register model view content for the dialog. + * Doesn't do anything if model view is already registered + */ + registerContent(handler: (view: ModelView) => Thenable): void; + + /** + * Returns the model view content if registered. Returns undefined if model review is not registered + */ + readonly modelView: ModelView; + + /** + * Whether the panel's content is valid + */ + readonly valid: boolean; + + /** + * Fired whenever the panel's valid property changes + */ + readonly onValidityChanged: vscode.Event; + } + + // Model view dialog classes + export interface Dialog extends ModelViewPanel { + /** + * The title of the dialog + */ + title: string; + + /** + * Indicates the width of the dialog + */ + isWide: boolean; + + /** + * The content of the dialog. If multiple tabs are given they will be displayed with tabs + * If a string is given, it should be the ID of the dialog's model view content + */ + content: string | DialogTab[]; + + /** + * The ok button + */ + okButton: Button; + + /** + * The cancel button + */ + cancelButton: Button; + + /** + * Any additional buttons that should be displayed + */ + customButtons: Button[]; + + /** + * Set the informational message shown in the dialog. Hidden when the message is + * undefined or the text is empty or undefined. The default level is error. + */ + message: DialogMessage; + + /** + * Set the dialog name when opening + * the dialog for telemetry + */ + dialogName?: string; + + /** + * Register a callback that will be called when the user tries to click done. Only + * one callback can be registered at once, so each registration call will clear + * the previous registration. + * @param validator The callback that gets executed when the user tries to click + * done. Return true to allow the dialog to close or false to block it from closing + */ + registerCloseValidator(validator: () => boolean | Thenable): void; + + /** + * Register an operation to run in the background when the dialog is done + * @param operationInfo Operation Information + */ + registerOperation(operationInfo: BackgroundOperationInfo): void; + } + + export interface DialogTab extends ModelViewPanel { + /** + * The title of the tab + */ + title: string; + + /** + * A string giving the ID of the tab's model view content + */ + content: string; + } + + export interface Button { + /** + * The label displayed on the button + */ + label: string; + + /** + * Whether the button is enabled + */ + enabled: boolean; + + /** + * Whether the button is hidden + */ + hidden: boolean; + + /** + * Whether the button is focused + */ + focused?: boolean; + + /** + * Raised when the button is clicked + */ + readonly onClick: vscode.Event; + + /** + * Position of the button on the dialog footer + */ + position?: DialogButtonPosition; + } + + export type DialogButtonPosition = 'left' | 'right'; + + export interface WizardPageChangeInfo { + /** + * The page number that the wizard changed from + */ + lastPage: number; + + /** + * The new page number or undefined if the user is closing the wizard + */ + newPage: number; + } + + export interface WizardPage extends ModelViewPanel { + /** + * The title of the page + */ + title: string; + + /** + * A string giving the ID of the page's model view content + */ + content: string; + + /** + * Any additional buttons that should be displayed while the page is open + */ + customButtons: Button[]; + + /** + * Whether the page is enabled. If the page is not enabled, the user will not be + * able to advance to it. Defaults to true. + */ + enabled: boolean; + + /** + * An optional description for the page. If provided it will be displayed underneath the page title. + */ + description: string; + } + + export interface Wizard { + /** + * The title of the wizard + */ + title: string; + + /** + * The wizard's pages. Pages can be added/removed while the dialog is open by using + * the addPage and removePage methods + */ + pages: WizardPage[]; + + /** + * The index in the pages array of the active page, or undefined if the wizard is + * not currently visible + */ + readonly currentPage: number; + + /** + * The done button + */ + doneButton: Button; + + /** + * The cancel button + */ + cancelButton: Button; + + /** + * The generate script button + */ + generateScriptButton: Button; + + /** + * The next button + */ + nextButton: Button; + + /** + * The back button + */ + backButton: Button; + + /** + * Any additional buttons that should be displayed for all pages of the dialog. If + * buttons are needed for specific pages they can be added using the customButtons + * property on each page. + */ + customButtons: Button[]; + + /** + * When set to false page titles and descriptions will not be displayed at the top + * of each wizard page. The default is true. + */ + displayPageTitles: boolean; + + /** + * Event fired when the wizard's page changes, containing information about the + * previous page and the new page + */ + onPageChanged: vscode.Event; + + /** + * Add a page to the wizard at the given index + * @param page The page to add + * @param index The index in the pages array to add the page at, or undefined to + * add it at the end + */ + addPage(page: WizardPage, index?: number): Thenable; + + /** + * Remove the page at the given index from the wizard + * @param index The index in the pages array to remove + */ + removePage(index: number): Thenable; + + /** + * Go to the page at the given index in the pages array. + * @param index The index of the page to go to + */ + setCurrentPage(index: number): Thenable; + + /** + * Open the wizard. Does nothing if the wizard is already open. + */ + open(): Thenable; + + /** + * Close the wizard. Does nothing if the wizard is not open. + */ + close(): Thenable; + + /** + * Register a callback that will be called when the user tries to navigate by + * changing pages or clicking done. Only one callback can be registered at once, so + * each registration call will clear the previous registration. + * @param validator The callback that gets executed when the user tries to + * navigate. Return true to allow the navigation to proceed, or false to + * cancel it. + */ + registerNavigationValidator(validator: (pageChangeInfo: WizardPageChangeInfo) => boolean | Thenable): void; + + /** + * Set the informational message shown in the wizard. Hidden when the message is + * undefined or the text is empty or undefined. The default level is error. + */ + message: DialogMessage; + + /** + * Register an operation to run in the background when the wizard is done + * @param operationInfo Operation Information + */ + registerOperation(operationInfo: BackgroundOperationInfo): void; + } + } + + /** + * Namespace for interacting with query editor + */ + export namespace queryeditor { + export type QueryEventType = + | 'queryStart' + | 'queryUpdate' + | 'queryStop' + | 'executionPlan' + | 'visualize'; + + /** + * args for each event type + * queryStart: undefined + * queryStop: undefined + * executionPlan: string + * visualize: ResultSetSummary + */ + export interface QueryEventListener { + onQueryEvent(type: QueryEventType, document: queryeditor.QueryDocument, args: ResultSetSummary | string | undefined): void; + } + + // new extensibility interfaces + export interface QueryDocument { + providerId: string; + + uri: string; + + // set the document's execution options + setExecutionOptions(options: Map): Thenable; + + // tab content is build using the modelview UI builder APIs + // probably should rename DialogTab class since it is useful outside dialogs + createQueryTab(tab: window.DialogTab): void; + + // connect the query document using the given connection profile + connect(connectionProfile: connection.ConnectionProfile): Thenable; + } + + /** + * Make connection for the query editor + * @param fileUri file URI for the query editor + * @param connectionId connection ID + */ + export function connect(fileUri: string, connectionId: string): Thenable; + + /** + * Run query if it is a query editor and it is already opened. + * @param fileUri file URI for the query editor + * @param options options + * @param runCurrentQuery true: run current query only, false: run all the queries in the file, default is true. + */ + export function runQuery(fileUri: string, options?: Map, runCurrentQuery?: boolean): void; + + /** + * Register a query event listener + */ + export function registerQueryEventListener(listener: queryeditor.QueryEventListener): void; + + /** + * Get a QueryDocument object for a file URI + */ + export function getQueryDocument(fileUri: string): Thenable; + } + + /** + * Namespace for interacting with the workspace + */ + export namespace workspace { + + /** + * Create a new model view editor + */ + export function createModelViewEditor(title: string, options?: ModelViewEditorOptions): ModelViewEditor; + + export interface ModelViewEditor extends window.ModelViewPanel { + /** + * `true` if there are unpersisted changes. + * This is editable to support extensions updating the dirty status. + */ + isDirty: boolean; + + /** + * Opens the editor + */ + openEditor(position?: vscode.ViewColumn): Thenable; + + /** + * Registers a save handler for this editor. This will be called if [supportsSave](#ModelViewEditorOptions.supportsSave) + * is set to true and the editor is marked as dirty + */ + registerSaveHandler(handler: () => Thenable): void; + } + } + + export interface ModelViewEditorOptions { + /** + * Should the model view editor's context be kept around even when the editor is no longer visible? It is false by default + */ + readonly retainContextWhenHidden?: boolean; + + /** + * Does this model view editor support save? + */ + readonly supportsSave?: boolean; + + /** + * Resource name for this editor + * File icons might depend on file extension, language id or resource name + * Resource name field needs to be set explitly if file icon for a particular Model View Editor depends on editor resource name + */ + readonly resourceName?: string; + } + + export enum DataProviderType { + ConnectionProvider = 'ConnectionProvider', + BackupProvider = 'BackupProvider', + RestoreProvider = 'RestoreProvider', + ScriptingProvider = 'ScriptingProvider', + ObjectExplorerProvider = 'ObjectExplorerProvider', + TaskServicesProvider = 'TaskServicesProvider', + FileBrowserProvider = 'FileBrowserProvider', + ProfilerProvider = 'ProfilerProvider', + MetadataProvider = 'MetadataProvider', + QueryProvider = 'QueryProvider', + AdminServicesProvider = 'AdminServicesProvider', + AgentServicesProvider = 'AgentServicesProvider', + CapabilitiesProvider = 'CapabilitiesProvider', + ObjectExplorerNodeProvider = 'ObjectExplorerNodeProvider', + IconProvider = 'IconProvider', + SerializationProvider = 'SerializationProvider' + } + + export namespace dataprotocol { + /** + * Get the provider corresponding to the given provider ID and type + * @param providerId The ID that the provider was registered with + * @param providerType The type of the provider + */ + export function getProvider(providerId: string, providerType: DataProviderType): T; + + /** + * Get all registered providers of the given type + * @param providerType The type of the providers + */ + export function getProvidersByType(providerType: DataProviderType): T[]; + } + + + /** + * Context object passed as an argument to command callbacks. + * Defines properties that can be sent for any connected context, + * whether that is the Object Explorer context menu or a command line + * startup argument. + */ + + export interface ConnectedContext { + /** + * The connection information for the selected object. + * Note that the connection is not guaranteed to be in a connected + * state on click. + */ + connectionProfile: IConnectionProfile; + } + + /** + * Context object passed as an argument to command callbacks. + * Defines the key properties required to identify a node in the object + * explorer tree and take action against it. + */ + export interface ObjectExplorerContext extends ConnectedContext { + + /** + * Defines whether this is a Connection-level object. + * If not, the object is expected to be a child object underneath + * one of the connections. + */ + isConnectionNode: boolean; + /** + * Node info for objects below a specific connection. This + * may be null for a Connection-level object + */ + nodeInfo: NodeInfo; + } + + /** + * Background Operation + */ + export interface BackgroundOperation { + /** + * Updates the operation status or adds progress message + * @param status Operation Status + * @param message Progress message + */ + updateStatus(status: TaskStatus, message?: string): void; + + /** + * Operation Id + */ + id: string; + + /** + * Event raised when operation is canceled in UI + */ + onCanceled: vscode.Event; + } + + /** + * Operation Information + */ + export interface BackgroundOperationInfo { + + /** + * The operation id. A unique id will be assigned to it If not specified a + */ + operationId?: string; + /** + * Connection information + */ + connection?: connection.Connection; + + /** + * Operation Display Name + */ + displayName: string; + + /** + * Operation Description + */ + description: string; + + /** + * True if the operation is cancelable + */ + isCancelable: boolean; + + /** + * The actual operation to execute + */ + operation: (operation: BackgroundOperation) => void; + } + + namespace tasks { + /** + * Starts an operation to run in the background + * @param operationInfo Operation Information + */ + export function startBackgroundOperation(operationInfo: BackgroundOperationInfo): void; + + } + + export interface ConnectionResult { + connected: boolean; + connectionId: string; + errorMessage: string; + errorCode: number; + } + + export namespace nb { + /** + * All notebook documents currently known to the system. + */ + export let notebookDocuments: NotebookDocument[]; + + /** + * The currently active Notebook editor or `undefined`. The active editor is the one + * that currently has focus or, when none has focus, the one that has changed + * input most recently. + */ + export let activeNotebookEditor: NotebookEditor | undefined; + + /** + * The currently visible editors or an empty array. + */ + export let visibleNotebookEditors: NotebookEditor[]; + + /** + * An event that is emitted when a [notebook document](#NotebookDocument) is opened. + * + * To add an event listener when a visible text document is opened, use the [TextEditor](#TextEditor) events in the + * [window](#window) namespace. Note that: + * + * - The event is emitted before the [document](#NotebookDocument) is updated in the + * [active notebook editor](#nb.activeNotebookEditor) + * - When a [notebook document](#NotebookDocument) is already open (e.g.: open in another visible notebook editor) this event is not emitted + * + */ + export const onDidOpenNotebookDocument: vscode.Event; + + /** + * An event that is emitted when a [notebook's](#NotebookDocument) cell contents are changed. + */ + export const onDidChangeNotebookCell: vscode.Event; + + /** + * Show the given document in a notebook editor. A [column](#ViewColumn) can be provided + * to control where the editor is being shown. Might change the [active editor](#nb.activeNotebookEditor). + * + * The document is denoted by an [uri](#Uri). Depending on the [scheme](#Uri.scheme) the + * following rules apply: + * `file`-scheme: Open a file on disk, will be rejected if the file does not exist or cannot be loaded. + * `untitled`-scheme: A new file that should be saved on disk, e.g. `untitled:c:\frodo\new.js`. The language + * will be derived from the file name. + * For all other schemes the registered notebook providers are consulted. + * + * @param document A document to be shown. + * @param column A view column in which the [editor](#NotebookEditor) should be shown. The default is the [active](#ViewColumn.Active), other values + * are adjusted to be `Min(column, columnCount + 1)`, the [active](#ViewColumn.Active)-column is not adjusted. Use [`ViewColumn.Beside`](#ViewColumn.Beside) + * to open the editor to the side of the currently active one. + * @param preserveFocus When `true` the editor will not take focus. + * @return A promise that resolves to a [notebook editor](#NotebookEditor). + */ + export function showNotebookDocument(uri: vscode.Uri, showOptions?: NotebookShowOptions): Thenable; + + export interface NotebookDocument { + /** + * The associated uri for this notebook document. + * + * *Note* that most documents use the `file`-scheme, which means they are files on disk. However, **not** all documents are + * saved on disk and therefore the `scheme` must be checked before trying to access the underlying file or siblings on disk. + * + */ + readonly uri: vscode.Uri; + + /** + * The file system path of the associated resource. Shorthand + * notation for [TextDocument.uri.fsPath](#TextDocument.uri). Independent of the uri scheme. + */ + readonly fileName: string; + + /** + * Is this document representing an untitled file which has never been saved yet. *Note* that + * this does not mean the document will be saved to disk, use [`uri.scheme`](#Uri.scheme) + * to figure out where a document will be [saved](#FileSystemProvider), e.g. `file`, `ftp` etc. + */ + readonly isUntitled: boolean; + + /** + * The identifier of the Notebook provider associated with this document. + */ + readonly providerId: string; + + /** + * `true` if there are unpersisted changes. + */ + readonly isDirty: boolean; + /** + * `true` if the document have been closed. A closed document isn't synchronized anymore + * and won't be re-used when the same resource is opened again. + */ + readonly isClosed: boolean; + + /** + * All cells. + */ + readonly cells: NotebookCell[]; + + /** + * The spec for current kernel, if applicable. This will be undefined + * until a kernel has been started + */ + readonly kernelSpec: IKernelSpec; + + /** + * Save the underlying file. + * + * @return A promise that will resolve to true when the file + * has been saved. If the file was not dirty or the save failed, + * will return false. + */ + save(): Thenable; + + /** + * Ensure a cell range is completely contained in this document. + * + * @param range A cell range. + * @return The given range or a new, adjusted range. + */ + validateCellRange(range: CellRange): CellRange; + } + + /** + * A cell range represents an ordered pair of two positions in a list of cells. + * It is guaranteed that [start](#CellRange.start).isBeforeOrEqual([end](#CellRange.end)) + * + * CellRange objects are __immutable__. + */ + export class CellRange { + + /** + * The start index. It is before or equal to [end](#CellRange.end). + */ + readonly start: number; + + /** + * The end index. It is after or equal to [start](#CellRange.start). + */ + readonly end: number; + + /** + * Create a new range from two positions. If `start` is not + * before or equal to `end`, the values will be swapped. + * + * @param start A number. + * @param end A number. + */ + constructor(start: number, end: number); + } + + export interface NotebookEditor { + /** + * The document associated with this editor. The document will be the same for the entire lifetime of this editor. + */ + readonly document: NotebookDocument; + /** + * The column in which this editor shows. Will be `undefined` in case this + * isn't one of the main editors, e.g an embedded editor, or when the editor + * column is larger than three. + */ + viewColumn?: vscode.ViewColumn; + + /** + * Perform an edit on the document associated with this notebook editor. + * + * The given callback-function is invoked with an [edit-builder](#NotebookEditorEdit) which must + * be used to make edits. Note that the edit-builder is only valid while the + * callback executes. + * + * @param callback A function which can create edits using an [edit-builder](#NotebookEditorEdit). + * @param options The undo/redo behavior around this edit. By default, undo stops will be created before and after this edit. + * @return A promise that resolves with a value indicating if the edits could be applied. + */ + edit(callback: (editBuilder: NotebookEditorEdit) => void, options?: { undoStopBefore: boolean; undoStopAfter: boolean; }): Thenable; + + /** + * Kicks off execution of a cell. Thenable will resolve only once the full execution is completed. + * + * + * @param cell An optional cell in this notebook which should be executed. If no cell is defined, it will run the active cell instead + * @return A promise that resolves with a value indicating if the cell was run or not. + */ + runCell(cell?: NotebookCell): Thenable; + + /** + * Kicks off execution of all code cells. Thenable will resolve only when full execution of all cells is completed. + */ + runAllCells(startCell?: NotebookCell, endCell?: NotebookCell): Thenable; + + /** + * Clears the outputs of the active code cell in a notebook. + */ + clearOutput(cell?: NotebookCell): Thenable; + + /** Clears the outputs of all code cells in a Notebook + * @return A promise that resolves with a value indicating if the outputs are cleared or not. + */ + clearAllOutputs(): Thenable; + + /** + * Changes the Notebook's kernel. Thenable will resolve only after kernel change is complete. + */ + changeKernel(kernel: IKernelSpec): Thenable; + } + + export interface NotebookCell { + contents: ICellContents; + uri?: vscode.Uri; + } + + export interface NotebookShowOptions { + /** + * An optional view column in which the [editor](#NotebookEditor) should be shown. + * The default is the [active](#ViewColumn.Active), other values are adjusted to + * be `Min(column, columnCount + 1)`, the [active](#ViewColumn.Active)-column is + * not adjusted. Use [`ViewColumn.Beside`](#ViewColumn.Beside) to open the + * editor to the side of the currently active one. + */ + viewColumn?: vscode.ViewColumn; + + /** + * An optional flag that when `true` will stop the [editor](#NotebookEditor) from taking focus. + */ + preserveFocus?: boolean; + + /** + * An optional flag that controls if an [editor](#NotebookEditor)-tab will be replaced + * with the next editor or if it will be kept. + */ + preview?: boolean; + + /** + * An optional string indicating which notebook provider to initially use + */ + providerId?: string; + + /** + * Optional profile indicating the initial connection to use for this editor + */ + connectionProfile?: IConnectionProfile; + + /** + * Default kernel for notebook + */ + defaultKernel?: nb.IKernelSpec; + + /** + * Optional content used to give an initial notebook state + */ + initialContent?: nb.INotebookContents | string; + + /** + * A optional boolean value indicating the dirty state after the intial content is loaded, default value is true + */ + initialDirtyState?: boolean; + } + + /** + * Represents an event describing the change in a [notebook documents's cells](#NotebookDocument.cells). + */ + export interface NotebookCellChangeEvent { + /** + * The [notebook document](#NotebookDocument) for which the selections have changed. + */ + notebook: NotebookDocument; + /** + * The new value for the [notebook documents's cells](#NotebookDocument.cells). + */ + cells: NotebookCell[]; + /** + * The [change kind](#NotebookChangeKind) which has triggered this + * event. Can be `undefined`. + */ + kind?: NotebookChangeKind; + } + + export enum NotebookChangeKind { + ContentUpdated = 0, + MetadataUpdated = 1, + Save = 2, + CellExecuted = 3 + } + + /** + * A complex edit that will be applied in one transaction on a TextEditor. + * This holds a description of the edits and if the edits are valid (i.e. no overlapping regions, document was not changed in the meantime, etc.) + * they can be applied on a [document](#TextDocument) associated with a [text editor](#TextEditor). + * + */ + export interface NotebookEditorEdit { + /** + * Replace a cell range with a new cell. + * + * @param location The range this operation should remove. + * @param value The new cell this operation should insert after removing `location`. + */ + replace(location: number | CellRange, value: ICellContents): void; + + /** + * Insert a cell (optionally) at a specific index. Any index outside of the length of the cells + * will result in the cell being added at the end. + * + * @param index The position where the new text should be inserted. + * @param value The new text this operation should insert. + * @param collapsed The collapsed state of the new cell. Default value is `false` if not provided. + */ + insertCell(value: ICellContents, index?: number, collapsed?: boolean): void; + + /** + * Delete a certain cell. + * + * @param index The index of the cell to remove. + */ + deleteCell(index: number): void; + } + + /** + * Register a notebook provider. The supported file types handled by this + * provider are defined in the `package.json: + * ```json + * { + * "contributes": { + * "notebook.providers": [{ + * "provider": "providername", + * "fileExtensions": ["FILEEXT"] + * }] + * } + * } + * ``` + * @export + * @param notebook provider + * @returns disposable + */ + export function registerNotebookProvider(provider: NotebookProvider): vscode.Disposable; + + export interface IStandardKernel { + readonly name: string; + readonly displayName: string; + readonly connectionProviderIds: string[]; + } + + export interface NotebookProvider { + readonly providerId: string; + readonly standardKernels: IStandardKernel[]; + getNotebookManager(notebookUri: vscode.Uri): Thenable; + handleNotebookClosed(notebookUri: vscode.Uri): void; + } + + export interface NotebookManager { + /** + * Manages reading and writing contents to/from files. + * Files may be local or remote, with this manager giving them a chance to convert and migrate + * from specific notebook file types to and from a standard type for this UI + */ + readonly contentManager: ContentManager; + /** + * A SessionManager that handles starting, stopping and handling notifications around sessions. + * Each notebook has 1 session associated with it, and the session is responsible + * for kernel management + */ + readonly sessionManager: SessionManager; + /** + * (Optional) ServerManager to handle server lifetime management operations. + * Depending on the implementation this may not be needed. + */ + readonly serverManager?: ServerManager; + } + + /** + * Defines the contracts needed to manage the lifetime of a notebook server. + */ + export interface ServerManager { + /** + * Indicates if the server is started at the current time + */ + readonly isStarted: boolean; + + /** + * Event sent when the server has started. This can be used to query + * the manager for server settings + */ + readonly onServerStarted: vscode.Event; + + /** + * Starts the server. Some server types may not support or require this. + * Should no-op if server is already started + */ + startServer(): Thenable; + + /** + * Stops the server. Some server types may not support or require this + */ + stopServer(): Thenable; + } + + //#region Content APIs + /** + * Handles interacting with file and folder contents + */ + export interface ContentManager { + /* Reads contents from a Uri representing a local or remote notebook and returns a + * JSON object containing the cells and metadata about the notebook + */ + getNotebookContents(notebookUri: vscode.Uri): Thenable; + + /** + * Save a file. + * + * @param notebookUri - The desired file path. + * + * @param notebook - notebook to be saved. + * + * @returns A thenable which resolves with the file content model when the + * file is saved. + */ + save(notebookUri: vscode.Uri, notebook: INotebookContents): Thenable; + } + + + /** + * Interface defining the file format contents of a notebook, usually in a serializable + * format. This interface does not have any methods for manipulating or interacting + * with a notebook object. + * + */ + export interface INotebookContents { + + readonly cells: ICellContents[]; + readonly metadata: INotebookMetadata; + readonly nbformat: number; + readonly nbformat_minor: number; + } + + export interface INotebookMetadata { + kernelspec: IKernelInfo; + language_info?: ILanguageInfo; + tags?: string[]; + } + + export interface IKernelInfo { + name: string; + language?: string; + display_name?: string; + } + + export interface ILanguageInfo { + name: string; + version?: string; + mimetype?: string; + codemirror_mode?: string | ICodeMirrorMode; + } + + export interface ICodeMirrorMode { + name: string; + version: string; + } + + /** + * Interface defining the file format contents of a notebook cell, usually in a serializable + * format. This interface does not have any methods for manipulating or interacting + * with a cell object. + * + */ + export interface ICellContents { + cell_type: CellType; + source: string | string[]; + metadata?: { + language?: string; + tags?: string[]; + azdata_cell_guid?: string; + }; + execution_count?: number; + outputs?: ICellOutput[]; + } + + export type CellType = 'code' | 'markdown' | 'raw'; + + export interface ICellOutput { + output_type: OutputTypeName; + } + + /** + * An alias for a stream type. + */ + export type StreamType = 'stdout' | 'stderr'; + + /** + * A multiline string. + */ + export type MultilineString = string | string[]; + + export interface IStreamResult extends ICellOutput { + output_type: 'stream'; + /** + * Stream output field defining the stream name, for example stdout + */ + name: StreamType; + /** + * Stream output field defining the multiline stream text + */ + text: MultilineString; + } + export interface IDisplayResult extends ICellOutput { + /** + * Mime bundle expected to contain mime type -> contents mappings. + * This is dynamic and is controlled by kernels, so cannot be more specific + */ + data: { [key: string]: any }; + /** + * Optional metadata, also a mime bundle + */ + metadata?: {}; + } + export interface IDisplayData extends IDisplayResult { + output_type: 'display_data'; + } + export interface IUpdateDisplayData extends IDisplayResult { + output_type: 'update_display_data'; + } + export interface IExecuteResult extends IDisplayResult { + /** + * Type of cell output. + */ + output_type: 'execute_result'; + /** + * Number of times the cell was executed + */ + execution_count: number; + } + export interface IErrorResult extends ICellOutput { + /** + * Type of cell output. + */ + output_type: 'error'; + /** + * Exception name + */ + ename: string; + /** + * Exception value + */ + evalue: string; + /** + * Stacktrace equivalent + */ + traceback?: string[]; + } + + export type OutputTypeName = + | 'execute_result' + | 'display_data' + | 'stream' + | 'error' + | 'update_display_data'; + + export type Output = nb.IDisplayData | nb.IUpdateDisplayData | nb.IExecuteResult | nb.IErrorResult | nb.IStreamResult; + + //#endregion + + //#region Session APIs + export interface SessionManager { + /** + * Indicates whether the manager is ready. + */ + readonly isReady: boolean; + + /** + * A Thenable that is fulfilled when the manager is ready. + */ + readonly ready: Thenable; + + readonly specs: IAllKernels | undefined; + + startNew(options: ISessionOptions): Thenable; + + shutdown(id: string): Thenable; + } + + export interface ISession { + /** + * Is change of kernels supported for this session? + */ + canChangeKernels: boolean; + /* + * Unique id of the session. + */ + readonly id: string; + + /** + * The current path associated with the session. + */ + readonly path: string; + + /** + * The current name associated with the session. + */ + readonly name: string; + + /** + * The type of the session. + */ + readonly type: string; + + /** + * The status indicates if the kernel is healthy, dead, starting, etc. + */ + readonly status: KernelStatus; + + /** + * The kernel. + * + * #### Notes + * This is a read-only property, and can be altered by [changeKernel]. + */ + readonly kernel: IKernel; + + /** + * Tracks whether the default kernel failed to load + * This could be for a reason such as the kernel name not being recognized as a valid kernel; + */ + defaultKernelLoaded?: boolean; + + changeKernel(kernelInfo: IKernelSpec): Thenable; + + configureKernel(kernelInfo: IKernelSpec): Thenable; + + configureConnection(connection: IConnectionProfile): Thenable; + } + + export interface ISessionOptions { + /** + * The path (not including name) to the session. + */ + path: string; + /** + * The name of the session. + */ + name?: string; + /** + * The type of the session. + */ + type?: string; + /** + * The type of kernel (e.g. python3). + */ + kernelName?: string; + /** + * The id of an existing kernel. + */ + kernelId?: string; + } + + export interface IKernel { + readonly id: string; + readonly name: string; + readonly supportsIntellisense: boolean; + readonly requiresConnection?: boolean; + /** + * Test whether the kernel is ready. + */ + readonly isReady: boolean; + + /** + * A Thenable that is fulfilled when the kernel is ready. + */ + readonly ready: Thenable; + + /** + * The cached kernel info. + * + * #### Notes + * This value will be null until the kernel is ready. + */ + readonly info: IInfoReply | null; + + /** + * Gets the full specification for this kernel, which can be serialized to + * a noteobok file + */ + getSpec(): Thenable; + + /** + * Send an `execute_request` message. + * + * @param content - The content of the request. + * + * @param disposeOnDone - Whether to dispose of the future when done. + * + * @returns A kernel future. + * + * #### Notes + * See [Messaging in + * Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute). + * + * This method returns a kernel future, rather than a Thenable, since execution may + * have many response messages (for example, many iopub display messages). + * + * Future `onReply` is called with the `execute_reply` content when the + * shell reply is received and validated. + * + * **See also:** [[IExecuteReply]] + */ + requestExecute(content: IExecuteRequest, disposeOnDone?: boolean): IFuture; + + + /** + * Send a `complete_request` message. + * + * @param content - The content of the request. + * + * @returns A Thenable that resolves with the response message. + * + * #### Notes + * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion). + * + * Fulfills with the `complete_reply` content when the shell reply is + * received and validated. + */ + requestComplete(content: ICompleteRequest): Thenable; + + /** + * Interrupt a kernel. + * + * #### Notes + * Uses the [Jupyter Notebook API](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/notebook/master/notebook/services/api/api.yaml#!/kernels). + * + * The promise is fulfilled on a valid response and rejected otherwise. + * + * It is assumed that the API call does not mutate the kernel id or name. + * + * The promise will be rejected if the kernel status is `Dead` or if the + * request fails or the response is invalid. + */ + interrupt(): Thenable; + } + + export interface IInfoReply { + protocol_version: string; + implementation: string; + implementation_version: string; + language_info: ILanguageInfo; + banner: string; + help_links: { + text: string; + url: string; + }[]; + } + + /** + * The contents of a requestExecute message sent to the server. + */ + export interface IExecuteRequest extends IExecuteOptions { + code: string | string[]; + } + + /** + * The options used to configure an execute request. + */ + export interface IExecuteOptions { + /** + * Whether to execute the code as quietly as possible. + * The default is `false`. + */ + silent?: boolean; + + /** + * Whether to store history of the execution. + * The default `true` if silent is False. + * It is forced to `false ` if silent is `true`. + */ + store_history?: boolean; + + /** + * A mapping of names to expressions to be evaluated in the + * kernel's interactive namespace. + */ + user_expressions?: {}; + + /** + * Whether to allow stdin requests. + * The default is `true`. + */ + allow_stdin?: boolean; + + /** + * Whether to the abort execution queue on an error. + * The default is `false`. + */ + stop_on_error?: boolean; + } + + /** + * The content of a `'complete_request'` message. + * + * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion). + * + * **See also:** [[ICompleteReply]], [[IKernel.complete]] + */ + export interface ICompleteRequest { + code: string; + cursor_pos: number; + } + + export interface ICompletionContent { + matches: string[]; + cursor_start: number; + cursor_end: number; + metadata: any; + status: 'ok' | 'error'; + } + /** + * A `'complete_reply'` message on the `'stream'` channel. + * + * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion). + * + * **See also:** [[ICompleteRequest]], [[IKernel.complete]] + */ + export interface ICompleteReplyMsg extends IShellMessage { + content: ICompletionContent; + } + + /** + * The valid Kernel status states. + */ + export type KernelStatus = + | 'unknown' + | 'starting' + | 'reconnecting' + | 'idle' + | 'busy' + | 'restarting' + | 'dead' + | 'connected'; + + /** + * An arguments object for the kernel changed event. + */ + export interface IKernelChangedArgs { + oldValue: IKernel | null; + newValue: IKernel | null; + } + + /// -------- JSON objects, and objects primarily intended not to have methods ----------- + export interface IAllKernels { + defaultKernel: string; + kernels: IKernelSpec[]; + } + export interface IKernelSpec { + name: string; + language?: string; + display_name?: string; + } + + export interface MessageHandler { + handle(message: T): void | Thenable; + } + + /** + * A Future interface for responses from the kernel. + * + * When a message is sent to a kernel, a Future is created to handle any + * responses that may come from the kernel. + */ + export interface IFuture extends vscode.Disposable { + + /** + * The original outgoing message. + */ + readonly msg: IMessage; + + /** + * A Thenable that resolves when the future is done. + * + * #### Notes + * The future is done when there are no more responses expected from the + * kernel. + * + * The `done` Thenable resolves to the reply message if there is one, + * otherwise it resolves to `undefined`. + */ + readonly done: Thenable; + + /** + * Set the reply handler for the kernel future. + * + * #### Notes + * If the handler returns a Thenable, all kernel message processing pauses + * until the Thenable is resolved. If there is a reply message, the future + * `done` Thenable also resolves to the reply message after this handler has + * been called. + */ + setReplyHandler(handler: MessageHandler): void; + + /** + * Sets the stdin handler for the kernel future. + * + * #### Notes + * If the handler returns a Thenable, all kernel message processing pauses + * until the Thenable is resolved. + */ + setStdInHandler(handler: MessageHandler): void; + + /** + * Sets the iopub handler for the kernel future. + * + * #### Notes + * If the handler returns a Thenable, all kernel message processing pauses + * until the Thenable is resolved. + */ + setIOPubHandler(handler: MessageHandler): void; + + /** + * Register hook for IOPub messages. + * + * @param hook - The callback invoked for an IOPub message. + * + * #### Notes + * The IOPub hook system allows you to preempt the handlers for IOPub + * messages handled by the future. + * + * The most recently registered hook is run first. A hook can return a + * boolean or a Thenable to a boolean, in which case all kernel message + * processing pauses until the Thenable is fulfilled. If a hook return value + * resolves to false, any later hooks will not run and the function will + * return a Thenable resolving to false. If a hook throws an error, the error + * is logged to the console and the next hook is run. If a hook is + * registered during the hook processing, it will not run until the next + * message. If a hook is removed during the hook processing, it will be + * deactivated immediately. + */ + registerMessageHook( + hook: (msg: IIOPubMessage) => boolean | Thenable + ): void; + + /** + * Remove a hook for IOPub messages. + * + * @param hook - The hook to remove. + * + * #### Notes + * If a hook is removed during the hook processing, it will be deactivated immediately. + */ + removeMessageHook( + hook: (msg: IIOPubMessage) => boolean | Thenable + ): void; + + /** + * Send an `input_reply` message. + */ + sendInputReply(content: IInputReply): void; + } + + export interface IExecuteReplyMsg extends IShellMessage { + content: IExecuteReply; + } + + /** + * The content of an `execute-reply` message. + * + * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results). + */ + export interface IExecuteReply { + status: 'ok' | 'error' | 'abort'; + execution_count: number | null; + } + + /** + * The valid channel names. + */ + export type Channel = 'shell' | 'iopub' | 'stdin' | 'execute_reply'; + + /** + * Kernel message header content. + * + * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#general-message-format). + * + * **See also:** [[IMessage]] + */ + export interface IHeader { + username: string; + version: string; + session: string; + msg_id: string; + msg_type: string; + } + + /** + * A kernel message + */ + export interface IMessage { + type: Channel; + header: IHeader; + parent_header: IHeader | {}; + metadata: {}; + content: any; + } + + /** + * A kernel message on the `'shell'` channel. + */ + export interface IShellMessage extends IMessage { + channel: 'shell'; + } + + /** + * A kernel message on the `'iopub'` channel. + */ + export interface IIOPubMessage extends IMessage { + channel: 'iopub'; + } + + /** + * A kernel message on the `'stdin'` channel. + */ + export interface IStdinMessage extends IMessage { + channel: 'stdin'; + content: { + prompt: string; + password: boolean; + }; + } + + /** + * The content of an `'input_reply'` message. + */ + export interface IInputReply { + value: string; + } + + export function registerNavigationProvider(provider: NavigationProvider): vscode.Disposable; + + export interface NavigationProvider { + readonly providerId: string; + getNavigation(notebookUri: vscode.Uri): Thenable; + } + + export interface NavigationResult { + hasNavigation: boolean; + previous?: vscode.Uri; + next?: vscode.Uri; + } + + //#endregion + + } +} diff --git a/types/azdata/tsconfig.json b/types/azdata/tsconfig.json new file mode 100644 index 0000000000..5626cf2dc9 --- /dev/null +++ b/types/azdata/tsconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": ["es6"], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "strictFunctionTypes": true, + "baseUrl": "../", + "typeRoots": ["../"], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }, + "files": ["index.d.ts", "azdata-tests.ts"] +} diff --git a/types/azdata/tslint.json b/types/azdata/tslint.json new file mode 100644 index 0000000000..0690f776f2 --- /dev/null +++ b/types/azdata/tslint.json @@ -0,0 +1,23 @@ +{ + "extends": "dtslint/dt.json", + "rules": { + "array-type": false, + "comment-format": false, + "interface-name": false, + "interface-over-type-literal": false, + "jsdoc-format": false, + "max-line-length": false, + "member-access": false, + "npm-naming": false, + "no-consecutive-blank-lines": false, + "no-declare-current-package": false, + "no-empty-interface": false, + "no-mergeable-namespace": false, + "no-padding": false, + "no-redundant-jsdoc-2": false, + "no-single-declare-module": false, + "no-unnecessary-generics": false, + "no-unnecessary-qualifier": false, + "strict-export-declare-modifiers": false + } +} \ No newline at end of file