@halcyontech/vscode-ibmi-types 1.6.2 → 1.6.13

package/api/CompileTools.d.ts

@@ -0,0 +1,69 @@
+export = CompileTools;
+declare class CompileTools {
+    /**
+     * @param {vscode.ExtensionContext} context
+     */
+    static register(context: vscode.ExtensionContext): void;
+    /**
+     * Does what it says on the tin.
+     */
+    static clearDiagnostics(): void;
+    /**
+     * @param {Instance} instance
+     * @param {{asp?: string, lib: string, object: string, ext?: string, workspace?: number}} evfeventInfo
+     */
+    static refreshDiagnostics(instance: Instance, evfeventInfo: {
+        asp?: string;
+        lib: string;
+        object: string;
+        ext?: string;
+        workspace?: number;
+    }): Promise<void>;
+    /**
+     *
+     * @param {string} string
+     * @param {{[name: string]: string}} variables
+     */
+    static replaceValues(string: string, variables: {
+        [name: string]: string;
+    }): string;
+    /**
+     *
+     * @param {Instance} instance
+     * @returns
+     */
+    static getDefaultVariables(instance: Instance): {
+        [name: string]: string;
+    };
+    /**
+     * @param {Instance} instance
+     * @param {vscode.Uri} uri
+     */
+    static RunAction(instance: Instance, uri: vscode.Uri): Promise<void>;
+    /**
+     * Execute command
+     * @param {Instance} instance
+     * @param {import("../typings").RemoteCommand} options
+     * @returns {Promise<import("../typings").CommandResult|null>}
+     */
+    static runCommand(instance: Instance, options: import("../typings").RemoteCommand): Promise<import("../typings").CommandResult | null>;
+    static showOutput(): void;
+    static appendOutput(output: any): void;
+    /**
+     * @param {string} name Name of action
+     * @param {string} command Command string
+     * @return {Promise<string>} new command
+     */
+    static showCustomInputs(name: string, command: string): Promise<string>;
+    /**
+     *
+     * @param {string} baseCommand
+     * @returns {{lib?: string, object: string}}
+     */
+    static getObjectFromCommand(baseCommand: string): {
+        lib?: string;
+        object: string;
+    };
+}
+import vscode = require("vscode");
+import { default as Instance } from "./Instance";

package/api/IBMi.d.ts

@@ -72,5 +72,13 @@ export default class IBMi {
      * @returns {string} result
      */
     sysNameInAmerican(string: string): string;
+    uploadFiles(files: {
+        local: string | vscode.Uri;
+        remote: string;
+    }[], options?: node_ssh.SSHPutFilesOptions): Promise<void>;
+    downloadFile(localFile: string | vscode.Uri, remoteFile: string): Promise<void>;
+    uploadDirectory(localDirectory: string | vscode.Uri, remoteDirectory: string, options?: node_ssh.SSHGetPutDirectoryOptions): Promise<void>;
+    downloadDirectory(localDirectory: string | vscode.Uri, remoteDirectory: string, options?: node_ssh.SSHGetPutDirectoryOptions): Promise<void>;
+    fileToPath(file: string | vscode.Uri): string;
 }
 export {};

package/api/IBMiContent.d.ts

@@ -1,109 +1,69 @@
-/// <reference types="node" />
-export = IBMiContent;
-declare class IBMiContent {
-    /**
-     * @param {IBMi} instance
-     */
-    constructor(instance: IBMi);
-    ibmi: IBMi;
-    /**
-     * @param {string} remotePath
-     * @param {string} localPath
-     */
+import { default as IBMi } from './IBMi';
+import { Tools } from './Tools';
+import { IBMiError, IBMiFile, IBMiMember, IBMiObject, IFSFile } from '../typings';
+export default class IBMiContent {
+    readonly ibmi: IBMi;
+    constructor(ibmi: IBMi);
+    private get config();
+    private getTempRemote;
+    private getNotUTF8CCSID;
+    private convertToUTF8;
     downloadStreamfile(remotePath: string, localPath?: string): Promise<string>;
-    writeStreamfile(originalPath: any, content: any): Promise<void | String | import("../typings").CommandResult>;
+    writeStreamfile(originalPath: any, content: any): Promise<string | void>;
     /**
      * Download the contents of a source member
-     * @param {string|undefined} asp
-     * @param {string} lib
-     * @param {string} spf
-     * @param {string} mbr
      */
-    downloadMemberContent(asp: string | undefined, lib: string, spf: string, mbr: string): Promise<string>;
+    downloadMemberContent(asp: string | undefined, library: string, sourceFile: string, member: string): Promise<string>;
     /**
      * Upload to a member
-     * @param {string|undefined} asp
-     * @param {string} lib
-     * @param {string} spf
-     * @param {string} mbr
-     * @param {string|Uint8Array} content
      */
-    uploadMemberContent(asp: string | undefined, lib: string, spf: string, mbr: string, content: string | Uint8Array): Promise<boolean>;
+    uploadMemberContent(asp: string | undefined, library: string, sourceFile: string, member: string, content: string | Uint8Array): Promise<boolean>;
     /**
      * Run an SQL statement
-     * @param {string} statement
-     * @returns {Promise<Tools.DB2Row[]>} Result set
+     * @param statement
+     * @returns a Result set
      */
     runSQL(statement: string): Promise<Tools.DB2Row[]>;
     /**
      * Download the contents of a table.
-     * @param {string} lib
-     * @param {string} file
-     * @param {string} [mbr] Will default to file provided
-     * @param {boolean} [deleteTable] Will delete the table after download
+     * @param library
+     * @param file
+     * @param member Will default to file provided
+     * @param deleteTable Will delete the table after download
      */
-    getTable(lib: string, file: string, mbr?: string, deleteTable?: boolean): Promise<any>;
+    getTable(library: string, file: string, member: string, deleteTable: boolean): Promise<Tools.DB2Row[]>;
     /**
      * Get list of libraries with description and attribute
-     * @param {string[]} libraries Array of libraries to retrieve
-     * @returns {Promise<{name: string, text: string, attribute: string}[]>} List of libraries
+     * @param libraries Array of libraries to retrieve
+     * @returns an array of libraries as IBMiObject
      */
-    getLibraryList(libraries: string[]): Promise<{
-        name: string;
-        text: string;
-        attribute: string;
-    }[]>;
+    getLibraryList(libraries: string[]): Promise<IBMiObject[]>;
     /**
-     * @param {{library: string, object?: string, types?: string[]}} filters
-     * @param {string?} sortOrder
-     * @returns {Promise<{library: string, name: string, type: string, text: string, attribute: string, count?: number}[]>} List of members
+     * @param filters
+     * @param sortOrder
+     * @returns an array of IBMiFile
      */
     getObjectList(filters: {
         library: string;
         object?: string;
         types?: string[];
-    }, sortOrder?: string | null): Promise<{
-        library: string;
-        name: string;
-        type: string;
-        text: string;
-        attribute: string;
-        count?: number;
-    }[]>;
+    }, sortOrder?: `name` | `type`): Promise<IBMiFile[]>;
     /**
-     * @param {string} lib
-     * @param {string} spf
-     * @param {string} [mbr]
-     * @returns {Promise<{asp?: string, library: string, file: string, name: string, extension: string, recordLength: number, text: string}[]>} List of members
+     * @param lib
+     * @param spf
+     * @param mbr
+     * @returns an array of IBMiMember
      */
-    getMemberList(lib: string, spf: string, mbr?: string, ext?: string): Promise<{
-        asp?: string;
-        library: string;
-        file: string;
-        name: string;
-        extension: string;
-        recordLength: number;
-        text: string;
-    }[]>;
+    getMemberList(lib: string, spf: string, mbr?: string, ext?: string): Promise<IBMiMember[]>;
     /**
      * Get list of items in a path
-     * @param {string} remotePath
-     * @return {Promise<{type: "directory"|"streamfile", name: string, path: string}[]>} Resulting list
+     * @param remotePath
+     * @return an array of IFSFile
      */
-    getFileList(remotePath: string): Promise<{
-        type: "directory" | "streamfile";
-        name: string;
-        path: string;
-    }[]>;
+    getFileList(remotePath: string): Promise<IFSFile[]>;
     /**
-     * @param {string} errorsString
-     * @returns {{code: string, text: string}[]} errors
+     * @param errorsString; several lines of `code:text`...
+     * @returns errors
      */
-    parseIBMiErrors(errorsString: string): {
-        code: string;
-        text: string;
-    }[];
+    parseIBMiErrors(errorsString: string): IBMiError[];
 }
-import { default as IBMi } from "./IBMi";
-import { Tools } from "./Tools";
-import path = require("path");

package/api/Instance.d.ts

@@ -18,4 +18,5 @@ export default class Instance {
     getConfig(): ConnectionConfiguration.Parameters;
     getContent(): IBMiContent;
     getStorage(): Storage;
+    onEvent(event: "connected" | "disconnected", func: Function): void;
 }

package/api/Storage.d.ts

@@ -1,6 +1,6 @@
 import vscode from 'vscode';
-export interface PathContent extends Record<string, string[]> {
-}
+export declare type PathContent = Record<string, string[]>;
+export declare type DeploymentPath = Record<string, string>;
 export declare class Storage {
     readonly context: vscode.ExtensionContext;
     readonly connectionName: string;
@@ -13,6 +13,6 @@ export declare class Storage {
     setLastProfile(lastProfile: string): Promise<void>;
     getPreviousCurLibs(): string[];
     setPreviousCurLibs(previousCurLibs: string[]): Promise<void>;
-    getDeployment(): PathContent;
-    setDeployment(existingPaths: PathContent): Promise<void>;
+    getDeployment(): DeploymentPath;
+    setDeployment(existingPaths: DeploymentPath): Promise<void>;
 }

package/api/configVars.d.ts

@@ -0,0 +1,3 @@
+import { ConnectionData } from "../typings";
+export declare function replace(data: string): string;
+export declare function replaceAll(connectionObject: ConnectionData): void;

package/api/errors/handler.d.ts

@@ -0,0 +1,4 @@
+import { FileError } from "../../typings";
+export declare function formatName(input: string): string;
+export declare function formatIFS(path: string): string;
+export declare function parseErrors(lines: string[]): Map<string, FileError[]>;

package/api/errors/handlers/new.d.ts

@@ -0,0 +1,9 @@
+import { FileError } from '../../../typings';
+export declare namespace NewHandler {
+    /**
+     * Returns object of files and their errors
+     * @param lines file contents
+     * @returns Errors object
+     */
+    function parse(lines: string[]): Map<string, FileError[]>;
+}

package/api/errors/handlers/old.d.ts

@@ -0,0 +1,9 @@
+import { FileError } from '../../../typings';
+export declare namespace OldHandler {
+    /**
+     * Returns object of files and their errors
+     * @param lines file contents
+     * @returns Errors object
+     */
+    function parse(lines: string[]): Map<string, FileError[]>;
+}

package/api/local/actions.d.ts

@@ -0,0 +1,7 @@
+import { WorkspaceFolder } from "vscode";
+import { Action } from "../../typings";
+export declare function getLocalActions(currentWorkspace: WorkspaceFolder): Promise<Action[]>;
+/**
+ * Gets actions from the `iproj.json` file
+ */
+export declare function getiProjActions(currentWorkspace: WorkspaceFolder): Promise<Action[]>;

package/api/local/deployment.d.ts

@@ -0,0 +1,27 @@
+import vscode from 'vscode';
+import Instance from '../Instance';
+import { Ignore } from 'ignore';
+export declare namespace Deployment {
+    interface DeploymentParameters {
+        method: Method;
+        localFolder: vscode.Uri;
+        remotePath: string;
+        ignoreRules?: Ignore;
+    }
+    enum Method {
+        "all" = 0,
+        "staged" = 1,
+        "unstaged" = 2,
+        "changed" = 3,
+        "compare" = 4
+    }
+    function initialize(context: vscode.ExtensionContext, instance: Instance): void;
+    /**
+     * Deploy a workspace to a remote IFS location.
+     * @param workspaceIndex if no index is provided, a prompt will be shown to pick one if there are multiple workspaces,
+     * otherwise the current workspace will be used.
+     * @returns the index of the deployed workspace or `undefined` if the deployment failed
+     */
+    function launchDeploy(workspaceIndex?: number): Promise<number | undefined>;
+    function deploy(parameters: DeploymentParameters): Promise<boolean>;
+}

package/api/local/env.d.ts

@@ -0,0 +1,4 @@
+import { WorkspaceFolder } from "vscode";
+export declare function getEnvConfig(currentWorkspace: WorkspaceFolder): Promise<{
+    [key: string]: string;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halcyontech/vscode-ibmi-types",
-  "version": "1.6.2",
+  "version": "1.6.13",
   "description": "Types for vscode-ibmi",
   "typings": "./typings.d.ts",
   "scripts": {

package/sandbox.d.ts

@@ -0,0 +1,3 @@
+import { ExtensionContext } from "vscode";
+export declare function registerUriHandler(context: ExtensionContext): Promise<void>;
+export declare function handleStartup(): Promise<void>;

package/typings.d.ts

@@ -1,11 +1,14 @@
 /// <reference types="node" />
 import { ExtensionContext } from "vscode";
 import Instance from "./api/Instance";
+import { Deployment } from "./api/local/deployment";
 export interface CodeForIBMi {
     instance: Instance;
     baseContext: ExtensionContext;
     CustomUI: object;
     Field: object;
+    deploy: (parameters: Deployment.DeploymentParameters) => Promise<boolean>;
+    evfeventParser: (lines: string[]) => Map<string, FileError[]>;
 }
 export interface StandardIO {
     onStdout?: (data: Buffer) => void;
@@ -52,7 +55,7 @@ export interface ConnectionData {
     username: string;
     password?: string;
     privateKey: string | null;
-    keepaliveInterval: number;
+    keepaliveInterval?: number;
 }
 export interface Server {
     name: string;
@@ -67,3 +70,36 @@ export interface IBMiObject {
     text: string;
     attribute?: string;
 }
+export interface IBMiFile extends IBMiObject {
+    count?: number;
+}
+export interface IBMiMember {
+    library: string;
+    file: string;
+    name: string;
+    extension: string;
+    recordLength: number;
+    text: string;
+    asp?: string;
+}
+export interface IFSFile {
+    type: "directory" | "streamfile";
+    name: string;
+    path: string;
+}
+export interface IBMiError {
+    code: string;
+    text: string;
+}
+export interface Filter {
+    library: string;
+    filter: string;
+}
+export interface FileError {
+    sev: number;
+    linenum: number;
+    column: number;
+    toColumn: number;
+    text: string;
+    code: string;
+}