@halcyontech/vscode-ibmi-types 2.14.4 → 2.15.0

package/api/configuration/config/ConnectionManager.d.ts

@@ -0,0 +1,31 @@
+import { Config } from "./VirtualConfig";
+import { ConnectionData } from "../../types";
+import { ConnectionConfig } from "./types";
+export declare class ConnectionManager {
+    configMethod: Config;
+    /**
+     * A bit of a hack to access any piece of configuration. (like actions)
+     */
+    get<T>(key: string): T;
+    /**
+     * Same hack as get.
+     */
+    set(key: string, value: any): Promise<void>;
+    getByName(name: string): {
+        index: number;
+        data: ConnectionData;
+    };
+    sort(): Promise<void>;
+    getAll(): ConnectionData[];
+    setAll(connections: ConnectionData[]): Promise<void>;
+    storeNew(data: ConnectionData): Promise<{
+        index: number;
+        data: ConnectionData;
+    }>;
+    deleteByName(name: string): Promise<void>;
+    updateByIndex(index: number, data: ConnectionData): Promise<void>;
+    getConnectionSettings(): ConnectionConfig[];
+    updateAll(connections: ConnectionConfig[]): Promise<void>;
+    update(parameters: ConnectionConfig): Promise<void>;
+    load(name: string): Promise<ConnectionConfig>;
+}

package/api/configuration/config/VirtualConfig.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class Config {
+    abstract get<T>(key: string): T | undefined;
+    abstract set(key: string, value: any): Promise<void>;
+}
+export declare class VirtualConfig extends Config {
+    private readonly config;
+    get<T>(key: string): T | undefined;
+    set(key: string, value: any): Promise<void>;
+}

package/api/configuration/config/types.d.ts

@@ -0,0 +1,66 @@
+import { FilterType } from "../../Filter";
+import { DeploymentMethod, ConnectionData } from "../../types";
+export declare type DefaultOpenMode = "browse" | "edit";
+export declare type ReconnectMode = "always" | "never" | "ask";
+export interface ConnectionConfig extends ConnectionProfile {
+    host: string;
+    autoClearTempData: boolean;
+    connectionProfiles: ConnectionProfile[];
+    commandProfiles: CommandProfile[];
+    autoSortIFSShortcuts: boolean;
+    tempLibrary: string;
+    tempDir: string;
+    sourceFileCCSID: string;
+    autoConvertIFSccsid: boolean;
+    hideCompileErrors: string[];
+    enableSourceDates: boolean;
+    sourceDateGutter: boolean;
+    encodingFor5250: string;
+    terminalFor5250: string;
+    setDeviceNameFor5250: boolean;
+    connectringStringFor5250: string;
+    autoSaveBeforeAction: boolean;
+    showDescInLibList: boolean;
+    debugPort: string;
+    debugSepPort: string;
+    debugUpdateProductionFiles: boolean;
+    debugEnableDebugTracing: boolean;
+    readOnlyMode: boolean;
+    quickConnect: boolean;
+    defaultDeploymentMethod: DeploymentMethod | '';
+    protectedPaths: string[];
+    showHiddenFiles: boolean;
+    lastDownloadLocation: string;
+    [name: string]: any;
+}
+export interface ObjectFilters {
+    name: string;
+    filterType: FilterType;
+    library: string;
+    object: string;
+    types: string[];
+    member: string;
+    memberType: string;
+    protected: boolean;
+}
+export interface CustomVariable {
+    name: string;
+    value: string;
+}
+export interface ConnectionProfile {
+    name: string;
+    homeDirectory: string;
+    currentLibrary: string;
+    libraryList: string[];
+    objectFilters: ObjectFilters[];
+    ifsShortcuts: string[];
+    customVariables: CustomVariable[];
+}
+export interface CommandProfile {
+    name: string;
+    command: string;
+}
+export interface StoredConnection {
+    index: number;
+    data: ConnectionData;
+}

package/api/configuration/storage/BaseStorage.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class BaseStorage {
+    protected readonly globalState: any;
+    constructor(globalState: any);
+    keys(): readonly string[];
+    get<T>(key: string): T | undefined;
+    set(key: string, value: any): Promise<void>;
+    getStorageKey(key: string): string;
+}
+export declare class VirtualStorage extends BaseStorage {
+    constructor();
+}

package/api/configuration/storage/CodeForIStorage.d.ts

@@ -0,0 +1,62 @@
+import { AspInfo, ConnectionData } from "../../types";
+import { ComponentInstallState } from "../../components/component";
+import { BaseStorage } from "./BaseStorage";
+export declare type PathContent = Record<string, string[]>;
+export declare type DeploymentPath = Record<string, string>;
+export declare type DebugCommands = Record<string, string>;
+export declare type LastConnection = {
+    name: string;
+    timestamp: number;
+};
+export declare type CachedServerSettings = {
+    lastCheckedOnVersion: string | undefined;
+    iAspInfo: AspInfo[];
+    qccsid: number | null;
+    jobCcsid: number | null;
+    remoteFeatures: {
+        [name: string]: string | undefined;
+    };
+    installedComponents: ComponentInstallState[];
+    remoteFeaturesKeys: string | null;
+    badDataAreasChecked: boolean | null;
+    libraryListValidated: boolean | null;
+    pathChecked?: boolean;
+    userDefaultCCSID: number | null;
+    debugConfigLoaded: boolean;
+    maximumArgsLength: number;
+} | undefined;
+export declare class CodeForIStorage {
+    private internalStorage;
+    constructor(internalStorage: BaseStorage);
+    protected getStorageKey(key: string): string;
+    getLastConnections(): LastConnection[];
+    setLastConnection(name: string): Promise<void>;
+    setLastConnections(lastConnections: LastConnection[]): Promise<void>;
+    getServerSettingsCache(name: string): {
+        lastCheckedOnVersion: string;
+        iAspInfo: AspInfo[];
+        qccsid: number;
+        jobCcsid: number;
+        remoteFeatures: {
+            [name: string]: string;
+        };
+        installedComponents: ComponentInstallState[];
+        remoteFeaturesKeys: string;
+        badDataAreasChecked: boolean;
+        libraryListValidated: boolean;
+        pathChecked?: boolean;
+        userDefaultCCSID: number;
+        debugConfigLoaded: boolean;
+        maximumArgsLength: number;
+    };
+    setServerSettingsCache(name: string, serverSettings: CachedServerSettings): Promise<void>;
+    setServerSettingsCacheSpecific(name: string, newSettings: Partial<CachedServerSettings>): Promise<void>;
+    deleteServerSettingsCache(name: string): Promise<void>;
+    deleteStaleServerSettingsCache(connections: ConnectionData[]): Promise<void>;
+    getPreviousSearchTerms(): string[];
+    addPreviousSearchTerm(term: string): Promise<void>;
+    clearPreviousSearchTerms(): Promise<void>;
+    getPreviousFindTerms(): string[];
+    addPreviousFindTerm(term: string): Promise<void>;
+    clearPreviousFindTerms(): Promise<void>;
+}

package/api/configuration/storage/ConnectionStorage.d.ts

@@ -0,0 +1,36 @@
+import { BaseStorage } from "./BaseStorage";
+import { PathContent, DeploymentPath, DebugCommands } from "./CodeForIStorage";
+declare type AuthorisedExtension = {
+    id: string;
+    displayName: string;
+    since: number;
+    lastAccess: number;
+};
+export declare class ConnectionStorage {
+    private internalStorage;
+    private connectionName;
+    constructor(internalStorage: BaseStorage);
+    get ready(): boolean;
+    setConnectionName(connectionName: string): void;
+    protected getStorageKey(key: string): string;
+    getSourceList(): PathContent;
+    setSourceList(sourceList: PathContent): Promise<void>;
+    getLastProfile(): string;
+    setLastProfile(lastProfile: string): Promise<void>;
+    getPreviousCurLibs(): string[];
+    setPreviousCurLibs(previousCurLibs: string[]): Promise<void>;
+    getDeployment(): DeploymentPath;
+    setDeployment(existingPaths: DeploymentPath): Promise<void>;
+    getDebugCommands(): DebugCommands;
+    setDebugCommands(existingCommands: DebugCommands): Promise<void>;
+    getWorkspaceDeployPath(workspaceFolderFsPath: string): string;
+    getRecentlyOpenedFiles(): string[];
+    setRecentlyOpenedFiles(recentlyOpenedFiles: string[]): Promise<void>;
+    clearRecentlyOpenedFiles(): Promise<void>;
+    grantExtensionAuthorisation(extensionId: string, displayName: string): Promise<void>;
+    getExtensionAuthorisation(extensionId: string): AuthorisedExtension;
+    getAuthorisedExtensions(): AuthorisedExtension[];
+    revokeAllExtensionAuthorisations(): void;
+    revokeExtensionAuthorisation(...extensions: AuthorisedExtension[]): Promise<void>;
+}
+export {};

package/api/errors/parser.d.ts

@@ -1,2 +1,2 @@
-import { FileError } from "../../typings";
+import { FileError } from "../types";
 export declare function parseErrors(lines: string[]): Map<string, FileError[]>;

package/api/import/Objects.d.ts

@@ -0,0 +1 @@
+export declare const ObjectTypes: Map<string, number>;

package/api/types.d.ts

@@ -0,0 +1,184 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare type DeploymentMethod = "all" | "staged" | "unstaged" | "changed" | "compare";
+export interface StandardIO {
+    onStdout?: (data: Buffer) => void;
+    onStderr?: (data: Buffer) => void;
+    stdin?: string;
+}
+/**
+ * External interface for extensions to call `code-for-ibmi.runCommand`
+ */
+export declare type ActionType = "member" | "streamfile" | "object" | "file";
+export declare type ActionRefresh = "no" | "parent" | "filter" | "browser";
+export declare type ActionEnvironment = "ile" | "qsh" | "pase";
+export declare type Variable = Record<string, string>;
+export declare enum CcsidOrigin {
+    User = "user",
+    System = "system"
+}
+export interface RemoteCommand {
+    title?: string;
+    command: string;
+    environment?: ActionEnvironment;
+    cwd?: string;
+    env?: Record<string, string>;
+    noLibList?: boolean;
+}
+export interface CommandData extends StandardIO {
+    command: string;
+    directory?: string;
+    env?: Record<string, string>;
+}
+export interface CommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+    command?: string;
+}
+export interface Action {
+    name: string;
+    command: string;
+    type?: ActionType;
+    environment: ActionEnvironment;
+    extensions?: string[];
+    deployFirst?: boolean;
+    postDownload?: string[];
+    refresh?: ActionRefresh;
+    runOnProtected?: boolean;
+}
+export interface ConnectionData {
+    name: string;
+    host: string;
+    port: number;
+    username: string;
+    password?: string;
+    privateKeyPath?: string;
+    keepaliveInterval?: number;
+    readyTimeout?: number;
+}
+export interface Server {
+    name: string;
+}
+export interface Profile {
+    profile: string;
+}
+export interface QsysPath {
+    asp?: string;
+    library: string;
+    name: string;
+}
+export interface IBMiObject extends QsysPath {
+    type: string;
+    text: string;
+    sourceFile?: boolean;
+    attribute?: string;
+    sourceLength?: number;
+    size?: number;
+    created?: Date;
+    changed?: Date;
+    created_by?: string;
+    owner?: string;
+}
+export interface IBMiMember {
+    library: string;
+    file: string;
+    name: string;
+    extension: string;
+    recordLength?: number;
+    text?: string;
+    asp?: string;
+    lines?: number;
+    created?: Date;
+    changed?: Date;
+}
+export interface IFSFile {
+    type: "directory" | "streamfile";
+    name: string;
+    path: string;
+    size?: number;
+    modified?: Date;
+    owner?: string;
+}
+export interface IBMiError {
+    code: string;
+    text: string;
+}
+export interface FileError {
+    sev: number;
+    lineNum: number;
+    toLineNum: number;
+    column: number;
+    toColumn: number;
+    text: string;
+    code: string;
+}
+export interface QsysFsOptions {
+    readonly?: boolean;
+}
+export declare type IBMiEvent = "connected" | "disconnected" | "deployLocation" | "deploy";
+export interface WithPath {
+    path: string;
+}
+export interface WithLibrary {
+    library: string;
+}
+export declare type FocusOptions = {
+    select?: boolean;
+    focus?: boolean;
+    expand?: boolean | number;
+};
+export declare type IBMiMessage = {
+    id: string;
+    text: string;
+};
+export declare type IBMiMessages = {
+    messages: IBMiMessage[];
+    findId(id: string): IBMiMessage | undefined;
+};
+export declare const OBJECT_BROWSER_MIMETYPE = "application/vnd.code.tree.objectbrowser";
+export declare const IFS_BROWSER_MIMETYPE = "application/vnd.code.tree.ifsbrowser";
+export interface WrapResult {
+    newStatements: string[];
+    outStmf: string;
+}
+export declare type SpecialAuthorities = "*ALLOBJ" | "*AUDIT" | "*IOSYSCFG" | "*JOBCTL" | "*SAVSYS" | "*SECADM" | "*SERVICE" | "*SPLCTL";
+export declare type AttrOperands = 'ACCESS_TIME' | 'ALLOC_SIZE' | 'ALLOC_SIZE_64' | 'ALWCKPWR' | 'ALWSAV' | 'ASP' | 'AUDIT' | 'AUTH_GROUP' | 'AUTH_LIST_NAME' | 'AUTH_OWNER' | 'AUTH_USERS' | 'CCSID' | 'CHANGE_TIME' | 'CHECKED_OUT' | 'CHECKED_OUT_USER' | 'CHECKED_OUT_TIME' | 'CODEPAGE' | 'CREATE_TIME' | 'CRTOBJAUD' | 'CRTOBJSCAN' | 'DATA_SIZE' | 'DATA_SIZE_64' | 'DIR_FORMAT' | 'DISK_STG_OPT' | 'EXTENDED_ATTR_SIZE' | 'FILE_FORMAT' | 'FILE_ID' | 'JOURNAL_APPLY_CHANGES' | 'JOURNAL_ID' | 'JOURNAL_LIBRARY' | 'JOURNAL_NAME' | 'JOURNAL_OPTIONS' | 'JOURNAL_RCVR_ASP' | 'JOURNAL_RCVR_LIBRARY' | 'JOURNAL_RCVR_NAME' | 'JOURNAL_ROLLBACK_ENDED' | 'JOURNAL_START_TIME' | 'JOURNAL_STATUS' | 'LOCAL_REMOTE' | 'MAIN_STG_OPT' | 'MODIFY_TIME' | 'MULT_SIGS' | 'OBJTYPE' | 'PC_ARCHIVE' | 'PC_HIDDEN' | 'PC_READ_ONLY' | 'PC_SYSTEM' | 'RSTDRNMUNL' | 'SCAN' | 'SCAN_BINARY' | 'SCAN_CCSID1' | 'SCAN_CCSID2' | 'SCAN_SIGS_DIFF' | 'SCAN_STATUS' | 'SGID' | 'SIGNED' | 'STG_FREE' | 'SUID' | 'SYSTEM_ARCHIVE' | 'SYSTEM_USE' | 'SYS_SIGNED' | 'UDFS_DEFAULT_FORMAT' | 'USAGE_DAYS_USED' | 'USAGE_LAST_USED_TIME' | 'USAGE_RESET_TIME';
+export declare type SearchResults = {
+    term: string;
+    hits: SearchHit[];
+};
+export declare type SearchHit = {
+    path: string;
+    lines: SearchHitLine[];
+    readonly?: boolean;
+    label?: string;
+};
+export declare type SearchHitLine = {
+    number: number;
+    content: string;
+};
+export interface AspInfo {
+    id: number;
+    name: string;
+    type: string;
+    rdbName: string;
+}
+export interface ProgramExportImportInfo {
+    programLibrary: string;
+    programName: string;
+    objectType: string;
+    symbolName: string;
+    symbolUsage: string;
+    argumentOptimization: string;
+    dataItemSize: number;
+}
+export interface ModuleExport {
+    moduleLibrary: string;
+    moduleName: string;
+    moduleAttr: string;
+    symbolName: string;
+    symbolType: string;
+    argumentOptimization: string;
+}
+export * from "./configuration/config/types";

package/commands/actions.d.ts

@@ -0,0 +1,3 @@
+import { Disposable } from "vscode";
+import Instance from "../Instance";
+export declare function registerActionsCommands(instance: Instance): Disposable[];

package/commands/compare.d.ts

@@ -0,0 +1,3 @@
+import { Disposable } from "vscode";
+import Instance from "../Instance";
+export declare function registerCompareCommands(instance: Instance): Disposable[];

package/commands/connection.d.ts

@@ -0,0 +1,3 @@
+import { Disposable, ExtensionContext } from "vscode";
+import Instance from "../Instance";
+export declare function registerConnectionCommands(context: ExtensionContext, instance: Instance): Disposable[];

package/commands/open.d.ts

@@ -0,0 +1,7 @@
+import { Disposable, Range } from "vscode";
+import Instance from "../Instance";
+import { QsysFsOptions } from "../typings";
+export declare type OpenEditableOptions = QsysFsOptions & {
+    position?: Range;
+};
+export declare function registerOpenCommands(instance: Instance): Disposable[];

package/commands/password.d.ts

@@ -0,0 +1,3 @@
+import { Disposable, ExtensionContext } from "vscode";
+import Instance from "../Instance";
+export declare function registerPasswordCommands(context: ExtensionContext, instance: Instance): Disposable[];

package/config/Configuration.d.ts

@@ -0,0 +1,9 @@
+import * as vscode from 'vscode';
+import { Config } from "../api/configuration/config/VirtualConfig";
+export declare function onCodeForIBMiConfigurationChange<T>(props: string | string[], todo: (value: vscode.ConfigurationChangeEvent) => void): vscode.Disposable;
+export declare class VsCodeConfig extends Config {
+    constructor();
+    private getWorkspaceConfig;
+    get<T>(key: string): T | undefined;
+    set(key: string, value: any): Promise<void>;
+}

package/config/Storage.d.ts

@@ -0,0 +1,10 @@
+import * as vscode from 'vscode';
+import { BaseStorage } from '../api/configuration/storage/BaseStorage';
+export declare class VsStorage extends BaseStorage {
+    protected readonly globalState: vscode.Memento;
+    private connectionName;
+    constructor(context: vscode.ExtensionContext);
+    keys(): readonly string[];
+    get<T>(key: string): T | undefined;
+    set(key: string, value: any): Promise<void>;
+}

package/config/passwords.d.ts

@@ -0,0 +1,4 @@
+import { ExtensionContext } from "vscode";
+export declare function getStoredPassword(context: ExtensionContext, connectionName: string): Thenable<string>;
+export declare function setStoredPassword(context: ExtensionContext, connectionName: string, password: string): Thenable<void>;
+export declare function deleteStoredPassword(context: ExtensionContext, connectionName: string): Thenable<void>;

package/{api/debug → debug}/certificates.d.ts

@@ -1,15 +1,12 @@
 import vscode from "vscode";
-import IBMi from "../IBMi";
-import IBMiContent from '../IBMiContent';
-import { DebugConfiguration } from './config';
+import IBMi from "../api/IBMi";
+import IBMiContent from '../api/IBMiContent';
+import { DebugConfiguration } from '../api/configuration/DebugConfiguration';
 export declare type ImportedCertificate = {
     localFile?: vscode.Uri;
     remoteFile?: string;
     password: string;
 };
-export declare const SERVICE_CERTIFICATE = "debug_service.pfx";
-export declare const CLIENT_CERTIFICATE = "debug_service.crt";
-export declare const LEGACY_CERT_DIRECTORY = "/QIBM/ProdData/IBMiDebugService/bin/certs";
 /**
  * Generates or imports the debug service server certificate and generates the client certificate from it.
  * The keystore containing the certificate and its key must use the PKCS12 format.

package/{api/debug → debug}/index.d.ts

@@ -1,6 +1,6 @@
 import { ExtensionContext } from "vscode";
 import Instance from "../Instance";
-import { ILELibrarySettings } from "../CompileTools";
+import { ILELibrarySettings } from "../api/CompileTools";
 export declare function isManaged(): boolean;
 export declare function initialize(context: ExtensionContext): Promise<void>;
 interface DebugOptions {

package/{api/debug → debug}/server.d.ts

@@ -1,11 +1,11 @@
-import IBMi from "../IBMi";
-import { Tools } from "../Tools";
+import IBMi from "../api/IBMi";
+import { Tools } from "../api/Tools";
 export declare type DebugJob = {
     name: string;
     ports: number[];
 };
 export declare function debugPTFInstalled(): boolean;
-export declare function isSEPSupported(): Promise<boolean>;
+export declare function isSEPSupported(connection: IBMi): Promise<boolean>;
 export declare function startService(connection: IBMi): Promise<boolean>;
 export declare function stopService(connection: IBMi): Promise<boolean>;
 export declare function getDebugServiceJob(): Promise<DebugJob>;
@@ -14,7 +14,7 @@ export declare function getDebugServerJob(): Promise<DebugJob>;
  * Gets a list of debug jobs stuck at MSGW in QSYSWRK
  */
 export declare function getStuckJobs(connection: IBMi): Promise<string[]>;
-export declare function endJobs(jobIds: string[], connection: IBMi): Promise<import("../../typings").CommandResult[]>;
+export declare function endJobs(jobIds: string[], connection: IBMi): Promise<import("../typings").CommandResult[]>;
 export declare function isDebugEngineRunning(): Promise<boolean>;
 export declare function startServer(): Promise<boolean>;
 export declare function stopServer(): Promise<boolean>;

package/filesystems/ifsFs.d.ts

@@ -0,0 +1,27 @@
+import vscode from "vscode";
+export declare class IFSFS implements vscode.FileSystemProvider {
+    private readonly savedAsFiles;
+    private emitter;
+    onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]>;
+    watch(uri: vscode.Uri, options: {
+        readonly recursive: boolean;
+        readonly excludes: readonly string[];
+    }): vscode.Disposable;
+    readFile(uri: vscode.Uri, retrying?: boolean): Promise<Uint8Array>;
+    stat(uri: vscode.Uri): Promise<vscode.FileStat>;
+    writeFile(uri: vscode.Uri, content: Uint8Array, options: {
+        readonly create: boolean;
+        readonly overwrite: boolean;
+    }): Promise<void>;
+    copy(source: vscode.Uri, destination: vscode.Uri, options: {
+        readonly overwrite: boolean;
+    }): void | Thenable<void>;
+    rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: {
+        readonly overwrite: boolean;
+    }): void | Thenable<void>;
+    readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]>;
+    createDirectory(uri: vscode.Uri): Promise<void>;
+    delete(uri: vscode.Uri, options: {
+        readonly recursive: boolean;
+    }): void | Thenable<void>;
+}

package/{api → filesystems}/local/actions.d.ts

@@ -1,4 +1,4 @@
 import { WorkspaceFolder } from "vscode";
-import { Action } from "../../typings";
+import { Action } from "../../api/types";
 export declare function getLocalActions(currentWorkspace: WorkspaceFolder): Promise<Action[]>;
 export declare function getEvfeventFiles(currentWorkspace: WorkspaceFolder): Promise<import("vscode").Uri[]>;

package/{api → filesystems}/local/deployTools.d.ts

@@ -1,6 +1,7 @@
 import { Ignore } from 'ignore';
 import vscode, { Uri, WorkspaceFolder } from 'vscode';
-import { DeploymentMethod, DeploymentParameters } from '../../typings';
+import { DeploymentMethod } from '../../api/types';
+import { DeploymentParameters } from '../../typings';
 declare type ServerFileChanges = {
     uploads: Uri[];
     relativeRemoteDeletes: string[];

package/{api → filesystems}/local/deployment.d.ts

@@ -1,6 +1,6 @@
 import vscode from 'vscode';
+import IBMi from '../../api/IBMi';
 import { DeploymentParameters } from '../../typings';
-import IBMi from '../IBMi';
 export declare namespace Deployment {
     interface MD5Entry {
         path: string;
@@ -13,7 +13,7 @@ export declare namespace Deployment {
     const workspaceChanges: Map<vscode.WorkspaceFolder, Map<string, vscode.Uri>>;
     function initialize(context: vscode.ExtensionContext): void;
     function getConnection(): IBMi;
-    function getContent(): import("../IBMiContent").default;
+    function getContent(): import("../../api/IBMiContent").default;
     function createRemoteDirectory(remotePath: string): Promise<import("../../typings").CommandResult>;
     function showErrorButton(): Promise<void>;
     function getWorkspaceFolder(workspaceIndex?: number): Promise<vscode.WorkspaceFolder>;

package/filesystems/qsys/FSUtils.d.ts

@@ -0,0 +1,9 @@
+import vscode from "vscode";
+/**
+ * Called when a member/streamfile is left open when VS Code is closed and re-opened to reconnect (or not) to the previous IBM i, based on the `autoReconnect` global configuration value.
+ * If the user choses not to reconnect, the editor tab will be closed.
+ *
+ * @param uri the uri of the file triggerring the reconnection attempt
+ * @returns `true` if the user choses to reconnect, `false` otherwise.
+ */
+export declare function reconnectFS(uri: vscode.Uri): Promise<boolean>;

package/filesystems/qsys/QSysFs.d.ts

@@ -0,0 +1,40 @@
+import vscode, { FilePermission } from "vscode";
+import IBMi from "../../api/IBMi";
+import { IBMiMember, QsysFsOptions, QsysPath } from "../../typings";
+export declare function getMemberUri(member: IBMiMember, options?: QsysFsOptions): vscode.Uri;
+export declare function getUriFromPath(path: string, options?: QsysFsOptions): vscode.Uri;
+export declare function getFilePermission(uri: vscode.Uri): FilePermission | undefined;
+export declare function parseFSOptions(uri: vscode.Uri): QsysFsOptions;
+export declare function isProtectedFilter(filter?: string): boolean;
+export declare class QSysFS implements vscode.FileSystemProvider {
+    private readonly savedAsMembers;
+    private readonly sourceDateHandler;
+    private readonly extendedContent;
+    private extendedMemberSupport;
+    private emitter;
+    onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]>;
+    constructor(context: vscode.ExtensionContext);
+    private updateMemberSupport;
+    stat(uri: vscode.Uri): Promise<vscode.FileStat>;
+    getMemberAttributes(connection: IBMi, path: QsysPath & {
+        member?: string;
+    }): Promise<Record<string, string>>;
+    parseMemberPath(connection: IBMi, path: string): import("../../api/IBMi").MemberParts;
+    readFile(uri: vscode.Uri, retrying?: boolean): Promise<Uint8Array>;
+    writeFile(uri: vscode.Uri, content: Uint8Array, options: {
+        readonly create: boolean;
+        readonly overwrite: boolean;
+    }): Promise<void>;
+    rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: {
+        readonly overwrite: boolean;
+    }): void | Thenable<void>;
+    watch(uri: vscode.Uri, options: {
+        readonly recursive: boolean;
+        readonly excludes: readonly string[];
+    }): vscode.Disposable;
+    readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]>;
+    createDirectory(uri: vscode.Uri): Promise<void>;
+    delete(uri: vscode.Uri, options: {
+        readonly recursive: boolean;
+    }): void | Thenable<void>;
+}