@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/services/preferences/common/preferencesValidation.js

@@ -1,8 +1,11 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { Color } from '../../../../base/common/color.js';
 import { isStringArray, isUndefinedOrNull, isString, isObject } from '../../../../base/common/types.js';
+const _moduleId = "vs/workbench/services/preferences/common/preferencesValidation";
 function canBeType(propTypes, ...types) {
-    return ( types.some(t => propTypes.includes(t)));
+    return (
+         (types.some(t => propTypes.includes(t)))
+    );
 }
 function isNullOrEmpty(value) {
     return value === '' || isUndefinedOrNull(value);
@@ -33,41 +36,29 @@ function createValidator(prop) {
             }
         }
         if (prop.type === 'boolean' && value !== true && value !== false) {
-            errors.push(( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.booleanIncorrectType',
-                'Incorrect type. Expected "boolean".'
-            )));
+            errors.push(( localizeWithPath(_moduleId, 0, 'Incorrect type. Expected "boolean".')));
         }
         if (isNumeric) {
             if (isNullOrEmpty(value) || typeof value === 'boolean' || Array.isArray(value) || isNaN(+value)) {
-                errors.push(( localizeWithPath(
-                    'vs/workbench/services/preferences/common/preferencesValidation',
-                    'validations.expectedNumeric',
-                    "Value must be a number."
-                )));
+                errors.push(( localizeWithPath(_moduleId, 1, "Value must be a number.")));
             }
             else {
-                errors.push(...( numericValidations.filter(validator => !validator.isValid(+value)).map(validator => validator.message)));
+                errors.push(...( (numericValidations.filter(validator => !validator.isValid(+value)).map(validator => validator.message))));
             }
         }
         if (prop.type === 'string') {
             if (prop.enum && !isStringArray(prop.enum)) {
                 errors.push(( localizeWithPath(
-                    'vs/workbench/services/preferences/common/preferencesValidation',
-                    'validations.stringIncorrectEnumOptions',
+                    _moduleId,
+                    2,
                     'The enum options should be strings, but there is a non-string option. Please file an issue with the extension author.'
                 )));
             }
             else if (!isString(value)) {
-                errors.push(( localizeWithPath(
-                    'vs/workbench/services/preferences/common/preferencesValidation',
-                    'validations.stringIncorrectType',
-                    'Incorrect type. Expected "string".'
-                )));
+                errors.push(( localizeWithPath(_moduleId, 3, 'Incorrect type. Expected "string".')));
             }
             else {
-                errors.push(...( stringValidations.filter(validator => !validator.isValid(value)).map(validator => validator.message)));
+                errors.push(...( (stringValidations.filter(validator => !validator.isValid(value)).map(validator => validator.message))));
             }
         }
         if (errors.length) {
@@ -81,10 +72,10 @@ function getInvalidTypeError(value, type) {
         return;
     }
     const typeArr = Array.isArray(type) ? type : [type];
-    if (!( typeArr.some(_type => valueValidatesAsType(value, _type)))) {
+    if (!( (typeArr.some(_type => valueValidatesAsType(value, _type))))) {
         return ( localizeWithPath(
-            'vs/workbench/services/preferences/common/preferencesValidation',
-            'invalidTypeError',
+            _moduleId,
+            4,
             "Setting has an invalid type, expected {0}. Fix in JSON.",
             JSON.stringify(type)
         ));
@@ -115,16 +106,20 @@ function valueValidatesAsType(value, type) {
 }
 function toRegExp(pattern) {
     try {
-        return ( new RegExp(pattern, 'u'));
+        return (
+             (new RegExp(pattern, 'u'))
+        );
     }
     catch (e) {
         try {
-            return ( new RegExp(pattern));
+            return (
+                 (new RegExp(pattern))
+            );
         }
         catch (e) {
             console.error(( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'regexParsingError',
+                _moduleId,
+                5,
                 "Error parsing the following regex both with and without the u flag:"
             )), pattern);
             return /.*/;
@@ -142,8 +137,8 @@ function getStringValidators(prop) {
             enabled: prop.maxLength !== undefined,
             isValid: ((value) => value.length <= prop.maxLength),
             message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.maxLength',
+                _moduleId,
+                6,
                 "Value must be {0} or fewer characters long.",
                 prop.maxLength
             ))
@@ -151,49 +146,31 @@ function getStringValidators(prop) {
         {
             enabled: prop.minLength !== undefined,
             isValid: ((value) => value.length >= prop.minLength),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.minLength',
-                "Value must be {0} or more characters long.",
-                prop.minLength
-            ))
+            message: ( localizeWithPath(_moduleId, 7, "Value must be {0} or more characters long.", prop.minLength))
         },
         {
             enabled: patternRegex !== undefined,
             isValid: ((value) => patternRegex.test(value)),
-            message: prop.patternErrorMessage || ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.regex',
-                "Value must match regex `{0}`.",
-                prop.pattern
-            ))
+            message: prop.patternErrorMessage || ( localizeWithPath(_moduleId, 8, "Value must match regex `{0}`.", prop.pattern))
         },
         {
             enabled: prop.format === 'color-hex',
             isValid: ((value) => Color.Format.CSS.parseHex(value)),
             message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.colorFormat',
+                _moduleId,
+                9,
                 "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."
             ))
         },
         {
             enabled: prop.format === 'uri' || prop.format === 'uri-reference',
             isValid: ((value) => !!value.length),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.uriEmpty',
-                "URI expected."
-            ))
+            message: ( localizeWithPath(_moduleId, 10, "URI expected."))
         },
         {
             enabled: prop.format === 'uri' || prop.format === 'uri-reference',
             isValid: ((value) => uriRegex.test(value)),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.uriMissing',
-                "URI is expected."
-            ))
+            message: ( localizeWithPath(_moduleId, 11, "URI is expected."))
         },
         {
             enabled: prop.format === 'uri',
@@ -201,11 +178,7 @@ function getStringValidators(prop) {
                 const matches = value.match(uriRegex);
                 return !!(matches && matches[2]);
             }),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.uriSchemeMissing',
-                "URI with a scheme is expected."
-            ))
+            message: ( localizeWithPath(_moduleId, 12, "URI with a scheme is expected."))
         },
         {
             enabled: prop.enum !== undefined,
@@ -213,10 +186,10 @@ function getStringValidators(prop) {
                 return prop.enum.includes(value);
             }),
             message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.invalidStringEnumValue',
+                _moduleId,
+                13,
                 "Value is not accepted. Valid values: {0}.",
-                prop.enum ? ( prop.enum.map(key => `"${key}"`)).join(', ') : '[]'
+                prop.enum ? ( (prop.enum.map(key => `"${key}"`))).join(', ') : '[]'
             ))
         }
     ].filter(validation => validation.enabled);
@@ -247,61 +220,32 @@ function getNumericValidators(prop) {
         {
             enabled: exclusiveMax !== undefined && (prop.maximum === undefined || exclusiveMax <= prop.maximum),
             isValid: ((value) => value < exclusiveMax),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.exclusiveMax',
-                "Value must be strictly less than {0}.",
-                exclusiveMax
-            ))
+            message: ( localizeWithPath(_moduleId, 14, "Value must be strictly less than {0}.", exclusiveMax))
         },
         {
             enabled: exclusiveMin !== undefined && (prop.minimum === undefined || exclusiveMin >= prop.minimum),
             isValid: ((value) => value > exclusiveMin),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.exclusiveMin',
-                "Value must be strictly greater than {0}.",
-                exclusiveMin
-            ))
+            message: ( localizeWithPath(_moduleId, 15, "Value must be strictly greater than {0}.", exclusiveMin))
         },
         {
             enabled: prop.maximum !== undefined && (exclusiveMax === undefined || exclusiveMax > prop.maximum),
             isValid: ((value) => value <= prop.maximum),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.max',
-                "Value must be less than or equal to {0}.",
-                prop.maximum
-            ))
+            message: ( localizeWithPath(_moduleId, 16, "Value must be less than or equal to {0}.", prop.maximum))
         },
         {
             enabled: prop.minimum !== undefined && (exclusiveMin === undefined || exclusiveMin < prop.minimum),
             isValid: ((value) => value >= prop.minimum),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.min',
-                "Value must be greater than or equal to {0}.",
-                prop.minimum
-            ))
+            message: ( localizeWithPath(_moduleId, 17, "Value must be greater than or equal to {0}.", prop.minimum))
         },
         {
             enabled: prop.multipleOf !== undefined,
             isValid: ((value) => value % prop.multipleOf === 0),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.multipleOf',
-                "Value must be a multiple of {0}.",
-                prop.multipleOf
-            ))
+            message: ( localizeWithPath(_moduleId, 18, "Value must be a multiple of {0}.", prop.multipleOf))
         },
         {
             enabled: isIntegral,
             isValid: ((value) => value % 1 === 0),
-            message: ( localizeWithPath(
-                'vs/workbench/services/preferences/common/preferencesValidation',
-                'validations.expectedInteger',
-                "Value must be an integer."
-            ))
+            message: ( localizeWithPath(_moduleId, 19, "Value must be an integer."))
         },
     ].filter(validation => validation.enabled);
 }
@@ -316,50 +260,28 @@ function getArrayValidator(prop) {
                 }
                 let message = '';
                 if (!Array.isArray(value)) {
-                    message += ( localizeWithPath(
-                        'vs/workbench/services/preferences/common/preferencesValidation',
-                        'validations.arrayIncorrectType',
-                        'Incorrect type. Expected an array.'
-                    ));
+                    message += ( localizeWithPath(_moduleId, 20, 'Incorrect type. Expected an array.'));
                     message += '\n';
                     return message;
                 }
                 const arrayValue = value;
                 if (prop.uniqueItems) {
-                    if (( new Set(arrayValue)).size < arrayValue.length) {
-                        message += ( localizeWithPath(
-                            'vs/workbench/services/preferences/common/preferencesValidation',
-                            'validations.stringArrayUniqueItems',
-                            'Array has duplicate items'
-                        ));
+                    if (( (new Set(arrayValue))).size < arrayValue.length) {
+                        message += ( localizeWithPath(_moduleId, 21, 'Array has duplicate items'));
                         message += '\n';
                     }
                 }
                 if (prop.minItems && arrayValue.length < prop.minItems) {
-                    message += ( localizeWithPath(
-                        'vs/workbench/services/preferences/common/preferencesValidation',
-                        'validations.stringArrayMinItem',
-                        'Array must have at least {0} items',
-                        prop.minItems
-                    ));
+                    message += ( localizeWithPath(_moduleId, 22, 'Array must have at least {0} items', prop.minItems));
                     message += '\n';
                 }
                 if (prop.maxItems && arrayValue.length > prop.maxItems) {
-                    message += ( localizeWithPath(
-                        'vs/workbench/services/preferences/common/preferencesValidation',
-                        'validations.stringArrayMaxItem',
-                        'Array must have at most {0} items',
-                        prop.maxItems
-                    ));
+                    message += ( localizeWithPath(_moduleId, 23, 'Array must have at most {0} items', prop.maxItems));
                     message += '\n';
                 }
                 if (propItems.type === 'string') {
                     if (!isStringArray(arrayValue)) {
-                        message += ( localizeWithPath(
-                            'vs/workbench/services/preferences/common/preferencesValidation',
-                            'validations.stringArrayIncorrectType',
-                            'Incorrect type. Expected a string array.'
-                        ));
+                        message += ( localizeWithPath(_moduleId, 24, 'Incorrect type. Expected a string array.'));
                         message += '\n';
                         return message;
                     }
@@ -370,8 +292,8 @@ function getArrayValidator(prop) {
                                 message +=
                                     propItems.patternErrorMessage ||
                                         ( localizeWithPath(
-                                            'vs/workbench/services/preferences/common/preferencesValidation',
-                                            'validations.stringArrayItemPattern',
+                                            _moduleId,
+                                            25,
                                             'Value {0} must match regex {1}.',
                                             withQuotes(v),
                                             withQuotes(propItems.pattern)
@@ -384,11 +306,11 @@ function getArrayValidator(prop) {
                         arrayValue.forEach(v => {
                             if (propItemsEnum.indexOf(v) === -1) {
                                 message += ( localizeWithPath(
-                                    'vs/workbench/services/preferences/common/preferencesValidation',
-                                    'validations.stringArrayItemEnum',
+                                    _moduleId,
+                                    26,
                                     'Value {0} is not one of {1}',
                                     withQuotes(v),
-                                    '[' + ( propItemsEnum.map(withQuotes)).join(', ') + ']'
+                                    '[' + ( (propItemsEnum.map(withQuotes))).join(', ') + ']'
                                 ));
                                 message += '\n';
                             }
@@ -418,14 +340,10 @@ function getObjectValidator(prop) {
             }
             const errors = [];
             if (!isObject(value)) {
-                errors.push(( localizeWithPath(
-                    'vs/workbench/services/preferences/common/preferencesValidation',
-                    'validations.objectIncorrectType',
-                    'Incorrect type. Expected an object.'
-                )));
+                errors.push(( localizeWithPath(_moduleId, 27, 'Incorrect type. Expected an object.')));
             }
             else {
-                ( Object.keys(value)).forEach((key) => {
+                ( (Object.keys(value))).forEach((key) => {
                     const data = value[key];
                     if (properties && key in properties) {
                         const errorMessage = getErrorsForSchema(properties[key], data);
@@ -446,12 +364,7 @@ function getObjectValidator(prop) {
                         }
                     }
                     if (additionalProperties === false) {
-                        errors.push(( localizeWithPath(
-                            'vs/workbench/services/preferences/common/preferencesValidation',
-                            'validations.objectPattern',
-                            'Property {0} is not allowed.\n',
-                            key
-                        )));
+                        errors.push(( localizeWithPath(_moduleId, 28, 'Property {0} is not allowed.\n', key)));
                     }
                     else if (typeof additionalProperties === 'object') {
                         const errorMessage = getErrorsForSchema(additionalProperties, data);

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.d.ts

@@ -0,0 +1,50 @@
+import { URI } from '../../../../base/common/uri.js';
+import { TunnelProtocol } from '../../../../platform/tunnel/common/tunnel.js';
+import { TunnelPrivacy } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import '../../../../editor/editor.api.js';
+import { IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { TunnelSource } from './tunnelModel.js';
+
+declare enum TunnelType {
+    Candidate = "Candidate",
+    Detected = "Detected",
+    Forwarded = "Forwarded",
+    Add = "Add"
+}
+interface ITunnelItem {
+    tunnelType: TunnelType;
+    remoteHost: string;
+    remotePort: number;
+    localAddress?: string;
+    protocol: TunnelProtocol;
+    localUri?: URI;
+    localPort?: number;
+    name?: string;
+    closeable?: boolean;
+    source: {
+        source: TunnelSource;
+        description: string;
+    };
+    privacy: TunnelPrivacy;
+    processDescription?: string;
+    readonly label: string;
+}
+declare enum TunnelEditId {
+    None = 0,
+    New = 1,
+    Label = 2,
+    LocalPort = 3
+}
+interface HelpInformation {
+    extensionDescription: IExtensionDescription;
+    getStarted?: string | {
+        id: string;
+    };
+    documentation?: string;
+    issues?: string;
+    reportIssue?: string;
+    remoteName?: string[] | string;
+    virtualWorkspace?: string;
+}
+
+export { type HelpInformation, type ITunnelItem, TunnelEditId, TunnelType };

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -6,6 +6,7 @@ import { IStorageService } from '../../../../platform/storage/common/storage.ser
 import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.service.js';
 import { TunnelModel } from './tunnelModel.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
+const _moduleId = "vs/workbench/services/remote/common/remoteExplorerService";
 const REMOTE_EXPLORER_TYPE_KEY = 'remote.explorerType';
 const TUNNEL_VIEW_ID = '~remote.forwardedPorts';
 const TUNNEL_VIEW_CONTAINER_ID = '~remote.forwardedPortsContainer';
@@ -16,29 +17,25 @@ const PORT_AUTO_SOURCE_SETTING_PROCESS = 'process';
 const PORT_AUTO_SOURCE_SETTING_OUTPUT = 'output';
 const PORT_AUTO_SOURCE_SETTING_HYBRID = 'hybrid';
 var TunnelType;
-( (function(TunnelType) {
+( ((function(TunnelType) {
     TunnelType["Candidate"] = "Candidate";
     TunnelType["Detected"] = "Detected";
     TunnelType["Forwarded"] = "Forwarded";
     TunnelType["Add"] = "Add";
-})(TunnelType || (TunnelType = {})));
+})(TunnelType || (TunnelType = {}))));
 var TunnelEditId;
-( (function(TunnelEditId) {
+( ((function(TunnelEditId) {
     TunnelEditId[TunnelEditId["None"] = 0] = "None";
     TunnelEditId[TunnelEditId["New"] = 1] = "New";
     TunnelEditId[TunnelEditId["Label"] = 2] = "Label";
     TunnelEditId[TunnelEditId["LocalPort"] = 3] = "LocalPort";
-})(TunnelEditId || (TunnelEditId = {})));
+})(TunnelEditId || (TunnelEditId = {}))));
 const getStartedWalkthrough = {
     type: 'object',
     required: ['id'],
     properties: {
         id: {
-            description: ( localizeWithPath(
-                'vs/workbench/services/remote/common/remoteExplorerService',
-                'getStartedWalkthrough.id',
-                'The ID of a Get Started walkthrough to open.'
-            )),
+            description: ( localizeWithPath(_moduleId, 0, 'The ID of a Get Started walkthrough to open.')),
             type: 'string'
         },
     }
@@ -46,17 +43,13 @@ const getStartedWalkthrough = {
 const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'remoteHelp',
     jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/services/remote/common/remoteExplorerService',
-            'RemoteHelpInformationExtPoint',
-            'Contributes help information for Remote'
-        )),
+        description: ( localizeWithPath(_moduleId, 1, 'Contributes help information for Remote')),
         type: 'object',
         properties: {
             'getStarted': {
                 description: ( localizeWithPath(
-                    'vs/workbench/services/remote/common/remoteExplorerService',
-                    'RemoteHelpInformationExtPoint.getStarted',
+                    _moduleId,
+                    2,
                     "The url, or a command that returns the url, to your project's Getting Started page, or a walkthrough ID contributed by your project's extension"
                 )),
                 oneOf: [
@@ -66,38 +59,33 @@ const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
             },
             'documentation': {
                 description: ( localizeWithPath(
-                    'vs/workbench/services/remote/common/remoteExplorerService',
-                    'RemoteHelpInformationExtPoint.documentation',
+                    _moduleId,
+                    3,
                     "The url, or a command that returns the url, to your project's documentation page"
                 )),
                 type: 'string'
             },
             'feedback': {
                 description: ( localizeWithPath(
-                    'vs/workbench/services/remote/common/remoteExplorerService',
-                    'RemoteHelpInformationExtPoint.feedback',
+                    _moduleId,
+                    4,
                     "The url, or a command that returns the url, to your project's feedback reporter"
                 )),
                 type: 'string',
-                markdownDeprecationMessage: ( localizeWithPath(
-                    'vs/workbench/services/remote/common/remoteExplorerService',
-                    'RemoteHelpInformationExtPoint.feedback.deprecated',
-                    "Use {0} instead",
-                    '`reportIssue`'
-                ))
+                markdownDeprecationMessage: ( localizeWithPath(_moduleId, 5, "Use {0} instead", '`reportIssue`'))
             },
             'reportIssue': {
                 description: ( localizeWithPath(
-                    'vs/workbench/services/remote/common/remoteExplorerService',
-                    'RemoteHelpInformationExtPoint.reportIssue',
+                    _moduleId,
+                    6,
                     "The url, or a command that returns the url, to your project's issue reporter"
                 )),
                 type: 'string'
             },
             'issues': {
                 description: ( localizeWithPath(
-                    'vs/workbench/services/remote/common/remoteExplorerService',
-                    'RemoteHelpInformationExtPoint.issues',
+                    _moduleId,
+                    7,
                     "The url, or a command that returns the url, to your project's issues list"
                 )),
                 type: 'string'
@@ -110,17 +98,17 @@ let RemoteExplorerService = class RemoteExplorerService {
         this.storageService = storageService;
         this.tunnelService = tunnelService;
         this._targetType = [];
-        this._onDidChangeTargetType = ( new Emitter());
+        this._onDidChangeTargetType = ( (new Emitter()));
         this.onDidChangeTargetType = this._onDidChangeTargetType.event;
-        this._onDidChangeHelpInformation = ( new Emitter());
+        this._onDidChangeHelpInformation = ( (new Emitter()));
         this.onDidChangeHelpInformation = this._onDidChangeHelpInformation.event;
         this._helpInformation = [];
-        this._onDidChangeEditable = ( new Emitter());
+        this._onDidChangeEditable = ( (new Emitter()));
         this.onDidChangeEditable = this._onDidChangeEditable.event;
-        this._onEnabledPortsFeatures = ( new Emitter());
+        this._onEnabledPortsFeatures = ( (new Emitter()));
         this.onEnabledPortsFeatures = this._onEnabledPortsFeatures.event;
         this._portsFeaturesEnabled = false;
-        this.namedProcesses = ( new Map());
+        this.namedProcesses = ( (new Map()));
         this._tunnelModel = instantiationService.createInstance(TunnelModel);
         remoteHelpExtPoint.setHandler((extensions) => {
             this._helpInformation.push(...extensions);
@@ -135,8 +123,8 @@ let RemoteExplorerService = class RemoteExplorerService {
         const newName = name.length > 0 ? name[0] : '';
         if (current !== newName) {
             this._targetType = name;
-            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( this._targetType.toString()), 1 , 1 );
-            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( this._targetType.toString()), 0 , 0 );
+            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( (this._targetType.toString())), 1 , 1 );
+            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( (this._targetType.toString())), 0 , 0 );
             this._onDidChangeTargetType.fire(this._targetType);
         }
     }
@@ -201,9 +189,9 @@ let RemoteExplorerService = class RemoteExplorerService {
         return this._portsFeaturesEnabled;
     }
 };
-RemoteExplorerService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ITunnelService)),
-    ( __param(2, IInstantiationService))
-], RemoteExplorerService));
+RemoteExplorerService = ( (__decorate([
+    ( (__param(0, IStorageService))),
+    ( (__param(1, ITunnelService))),
+    ( (__param(2, IInstantiationService)))
+], RemoteExplorerService)));
 export { PORT_AUTO_FALLBACK_SETTING, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_HYBRID, PORT_AUTO_SOURCE_SETTING_OUTPUT, PORT_AUTO_SOURCE_SETTING_PROCESS, REMOTE_EXPLORER_TYPE_KEY, RemoteExplorerService, TUNNEL_VIEW_CONTAINER_ID, TUNNEL_VIEW_ID, TunnelEditId, TunnelType };

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

@@ -0,0 +1,40 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { RemoteTunnel } from '../../../../platform/tunnel/common/tunnel.js';
+import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { IEditableData } from '../../../common/views.js';
+import { TunnelInformation } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { TunnelModel, TunnelProperties, Attributes, TunnelCloseReason, CandidatePort } from './tunnelModel.js';
+import { IExtensionPointUser } from '../../extensions/common/extensionsRegistry.js';
+import { HelpInformation, ITunnelItem, TunnelEditId } from './remoteExplorerService.js';
+
+declare const IRemoteExplorerService: ServiceIdentifier<IRemoteExplorerService>;
+interface IRemoteExplorerService {
+    readonly _serviceBrand: undefined;
+    onDidChangeTargetType: Event<string[]>;
+    targetType: string[];
+    onDidChangeHelpInformation: Event<readonly IExtensionPointUser<HelpInformation>[]>;
+    helpInformation: IExtensionPointUser<HelpInformation>[];
+    readonly tunnelModel: TunnelModel;
+    onDidChangeEditable: Event<{
+        tunnel: ITunnelItem;
+        editId: TunnelEditId;
+    } | undefined>;
+    setEditable(tunnelItem: ITunnelItem | undefined, editId: TunnelEditId, data: IEditableData | null): void;
+    getEditableData(tunnelItem: ITunnelItem | undefined, editId?: TunnelEditId): IEditableData | undefined;
+    forward(tunnelProperties: TunnelProperties, attributes?: Attributes | null): Promise<RemoteTunnel | string | undefined>;
+    close(remote: {
+        host: string;
+        port: number;
+    }, reason: TunnelCloseReason): Promise<void>;
+    setTunnelInformation(tunnelInformation: TunnelInformation | undefined): void;
+    setCandidateFilter(filter: ((candidates: CandidatePort[]) => Promise<CandidatePort[]>) | undefined): IDisposable;
+    onFoundNewCandidates(candidates: CandidatePort[]): void;
+    restore(): Promise<void>;
+    enablePortsFeatures(): void;
+    onEnabledPortsFeatures: Event<void>;
+    portsFeaturesEnabled: boolean;
+    readonly namedProcesses: Map<number, string>;
+}
+
+export { IRemoteExplorerService };