@hpcc-js/comms 3.8.1 → 3.9.0

package/src/services/wsdl/ws_machine/v1.19/ws_machine.ts

@@ -0,0 +1,497 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsMachine {
+
+    export type int = number;
+    export type long = number;
+    export type unsignedInt = number;
+
+    export enum ThresholdType {
+        THRESHOLD_PERCENTAGE = 0,
+        THRESHOLD_MB = 1
+    }
+
+    export enum TpMachineType {
+        ALLNODES = "ALLNODES",
+        THORMACHINES = "THORMACHINES",
+        HOLEMACHINES = "HOLEMACHINES",
+        ROXIEMACHINES = "ROXIEMACHINES",
+        MACHINES = "MACHINES",
+        AVAILABLEMACHINES = "AVAILABLEMACHINES",
+        DROPZONE = "DROPZONE",
+        STANDBYNNODE = "STANDBYNNODE",
+        THORSPARENODES = "THORSPARENODES",
+        HOLESTANDBYNODES = "HOLESTANDBYNODES"
+    }
+
+    export interface GetComponentStatusRequest {
+
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface StatusReport {
+        StatusID: int;
+        Status: string;
+        StatusDetails: string;
+        Reporter: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        TimeCached: string;
+        URL: string;
+    }
+
+    export interface StatusReports {
+        StatusReport: StatusReport[];
+    }
+
+    export interface ComponentStatus {
+        ComponentTypeID: int;
+        ComponentType: string;
+        EndPoint: string;
+        StatusID: int;
+        Status: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        Reporter: string;
+        StatusReports: StatusReports;
+    }
+
+    export interface ComponentStatusList {
+        ComponentStatus: ComponentStatus[];
+    }
+
+    export interface GetComponentStatusResponse {
+        Exceptions: Exceptions;
+        StatusCode: int;
+        Status: string;
+        ComponentType: string;
+        EndPoint: string;
+        ComponentStatusID: int;
+        ComponentStatus: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        Reporter: string;
+        StatusReport: StatusReport;
+        ComponentStatusList: ComponentStatusList;
+    }
+
+    export interface Component {
+        Type: string;
+        Name: string;
+    }
+
+    export interface Components {
+        Component: Component[];
+    }
+
+    export interface GetComponentUsageRequest {
+        Components?: Components;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface DiskUsage {
+        Name: string;
+        Path: string;
+        Description: string;
+        InUse: long;
+        Available: long;
+        PercentAvailable: int;
+        Exception: string;
+    }
+
+    export interface DiskUsages {
+        DiskUsage: DiskUsage[];
+    }
+
+    export interface MachineUsage {
+        Name: string;
+        NetAddress: string;
+        Description: string;
+        Exception: string;
+        DiskUsages: DiskUsages;
+    }
+
+    export interface MachineUsages {
+        MachineUsage: MachineUsage[];
+    }
+
+    export interface ComponentUsage {
+        Type: string;
+        Name: string;
+        Description: string;
+        Exception: string;
+        MachineUsages: MachineUsages;
+    }
+
+    export interface ComponentUsages {
+        ComponentUsage: ComponentUsage[];
+    }
+
+    export interface GetComponentUsageResponse {
+        Exceptions: Exceptions;
+        ComponentUsages: ComponentUsages;
+        UsageTime: string;
+    }
+
+    export interface Addresses {
+        Item: string[];
+    }
+
+    export interface GetMachineInfoRequest {
+        Addresses?: Addresses;
+        SortBy?: string;
+        ClusterType?: TpMachineType;
+        Cluster?: string;
+        OldIP?: string;
+        Path?: string;
+        AddProcessesToFilter?: string;
+        ApplyProcessFilter?: boolean;
+        GetProcessorInfo?: boolean;
+        GetStorageInfo?: boolean;
+        LocalFileSystemsOnly?: boolean;
+        GetSoftwareInfo?: boolean;
+        MemThreshold?: int;
+        DiskThreshold?: int;
+        CpuThreshold?: int;
+        AutoRefresh?: int;
+        MemThresholdType?: ThresholdType;
+        DiskThresholdType?: ThresholdType;
+        UserName?: string;
+        Password?: string;
+        SecurityString?: string;
+    }
+
+    export interface RequestInfo {
+        Addresses: Addresses;
+        SortBy: string;
+        ClusterType: TpMachineType;
+        Cluster: string;
+        OldIP: string;
+        Path: string;
+        AddProcessesToFilter: string;
+        ApplyProcessFilter: boolean;
+        GetProcessorInfo: boolean;
+        GetStorageInfo: boolean;
+        LocalFileSystemsOnly: boolean;
+        GetSoftwareInfo: boolean;
+        MemThreshold: int;
+        DiskThreshold: int;
+        CpuThreshold: int;
+        AutoRefresh: int;
+        MemThresholdType: ThresholdType;
+        DiskThresholdType: ThresholdType;
+        SecurityString: string;
+        UserName: string;
+        Password: string;
+        EnableSNMP: boolean;
+    }
+
+    export interface Columns {
+        Item: string[];
+    }
+
+    export interface ProcessorInfo {
+        Type: string;
+        Load: int;
+    }
+
+    export interface Processors {
+        ProcessorInfo: ProcessorInfo[];
+    }
+
+    export interface StorageInfo {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface Storage {
+        StorageInfo: StorageInfo[];
+    }
+
+    export interface SWRunInfo {
+        Name: string;
+        Instances: int;
+        State: int;
+    }
+
+    export interface Running {
+        SWRunInfo: SWRunInfo[];
+    }
+
+    export interface PhysicalMemory {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface VirtualMemory {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface ComponentInfo {
+        Condition: int;
+        State: int;
+        UpTime: string;
+    }
+
+    export interface MachineInfoEx {
+        Address: string;
+        ConfigAddress: string;
+        Name: string;
+        ProcessType: string;
+        DisplayType: string;
+        Description: string;
+        AgentVersion: string;
+        Contact: string;
+        Location: string;
+        UpTime: string;
+        ComponentName: string;
+        ComponentPath: string;
+        RoxieState: string;
+        RoxieStateDetails: string;
+        OS: int;
+        ProcessNumber: int;
+        Channels: unsignedInt;
+        Processors: Processors;
+        Storage: Storage;
+        Running: Running;
+        PhysicalMemory: PhysicalMemory;
+        VirtualMemory: VirtualMemory;
+        ComponentInfo: ComponentInfo;
+        Exception: string;
+    }
+
+    export interface Machines {
+        MachineInfoEx: MachineInfoEx[];
+    }
+
+    export interface GetMachineInfoResponse {
+        Exceptions: Exceptions;
+        RequestInfo: RequestInfo;
+        Columns: Columns;
+        Machines: Machines;
+        TimeStamp: string;
+        UserName: string;
+        Password: string;
+        AcceptLanguage: string;
+    }
+
+    export interface GetMachineInfoRequestEx {
+        Addresses: Addresses;
+        ClusterType: TpMachineType;
+    }
+
+    export interface GetMachineInfoResponseEx {
+        Exceptions: Exceptions;
+        AcceptLanguage: string;
+        Machines: Machines;
+    }
+
+    export interface ShowColumns {
+        Item: string[];
+    }
+
+    export interface MetricsRequest {
+        SecurityString?: string;
+        Addresses?: Addresses;
+        ShowColumns?: ShowColumns;
+        AutoRefresh?: int;
+        SelectAllChecked?: boolean;
+        Cluster?: string;
+        AutoUpdate?: boolean;
+    }
+
+    export interface MetricsResponse {
+        Exceptions: Exceptions;
+        FieldInformation: string;
+        Metrics: string;
+        AutoRefresh: int;
+        Cluster: string;
+        SelectAllChecked: boolean;
+        AutoUpdate: boolean;
+        AcceptLanguage: string;
+    }
+
+    export interface NodeGroups {
+        Item: string[];
+    }
+
+    export interface GetNodeGroupUsageRequest {
+        NodeGroups?: NodeGroups;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface NodeGroupUsage {
+        Name: string;
+        Description: string;
+        Exception: string;
+        ComponentUsages: ComponentUsages;
+    }
+
+    export interface NodeGroupUsages {
+        NodeGroupUsage: NodeGroupUsage[];
+    }
+
+    export interface GetNodeGroupUsageResponse {
+        Exceptions: Exceptions;
+        NodeGroupUsages: NodeGroupUsages;
+        UsageTime: string;
+    }
+
+    export interface TargetClusters {
+        Item: string[];
+    }
+
+    export interface GetTargetClusterInfoRequest {
+        TargetClusters?: TargetClusters;
+        AddProcessesToFilter?: string;
+        ApplyProcessFilter?: boolean;
+        GetProcessorInfo?: boolean;
+        GetStorageInfo?: boolean;
+        LocalFileSystemsOnly?: boolean;
+        GetSoftwareInfo?: boolean;
+        MemThreshold?: int;
+        DiskThreshold?: int;
+        CpuThreshold?: int;
+        AutoRefresh?: int;
+        MemThresholdType?: ThresholdType;
+        DiskThresholdType?: ThresholdType;
+    }
+
+    export interface Processes {
+        MachineInfoEx: MachineInfoEx[];
+    }
+
+    export interface TargetClusterInfo {
+        Name: string;
+        Type: string;
+        Processes: Processes;
+    }
+
+    export interface TargetClusterInfoList {
+        TargetClusterInfo: TargetClusterInfo[];
+    }
+
+    export interface GetTargetClusterInfoResponse {
+        Exceptions: Exceptions;
+        Columns: Columns;
+        RequestInfo: RequestInfo;
+        TargetClusterInfoList: TargetClusterInfoList;
+        TimeStamp: string;
+        AcceptLanguage: string;
+    }
+
+    export interface GetTargetClusterUsageRequest {
+        TargetClusters?: TargetClusters;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface TargetClusterUsage {
+        Name: string;
+        Description: string;
+        Exception: string;
+        ComponentUsages: ComponentUsages;
+    }
+
+    export interface TargetClusterUsages {
+        TargetClusterUsage: TargetClusterUsage[];
+    }
+
+    export interface GetTargetClusterUsageResponse {
+        Exceptions: Exceptions;
+        TargetClusterUsages: TargetClusterUsages;
+        UsageTime: string;
+    }
+
+    export interface ws_machinePingRequest {
+
+    }
+
+    export interface ws_machinePingResponse {
+
+    }
+
+    export interface UpdateComponentStatusRequest {
+        Reporter?: string;
+        ComponentStatusList?: ComponentStatusList;
+    }
+
+    export interface UpdateComponentStatusResponse {
+        Exceptions: Exceptions;
+        StatusCode: int;
+        Status: string;
+    }
+
+}
+
+export class MachineServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "ws_machine", "1.19");
+    }
+
+    GetComponentStatus(request: Partial<WsMachine.GetComponentStatusRequest>): Promise<WsMachine.GetComponentStatusResponse> {
+        return this._connection.send("GetComponentStatus", request, "json", false, undefined, "GetComponentStatusResponse");
+    }
+
+    GetComponentUsage(request: Partial<WsMachine.GetComponentUsageRequest>): Promise<WsMachine.GetComponentUsageResponse> {
+        return this._connection.send("GetComponentUsage", request, "json", false, undefined, "GetComponentUsageResponse");
+    }
+
+    GetMachineInfo(request: Partial<WsMachine.GetMachineInfoRequest>): Promise<WsMachine.GetMachineInfoResponse> {
+        return this._connection.send("GetMachineInfo", request, "json", false, undefined, "GetMachineInfoResponse");
+    }
+
+    GetMachineInfoEx(request: Partial<WsMachine.GetMachineInfoRequestEx>): Promise<WsMachine.GetMachineInfoResponseEx> {
+        return this._connection.send("GetMachineInfoEx", request, "json", false, undefined, "GetMachineInfoResponseEx");
+    }
+
+    GetMetrics(request: Partial<WsMachine.MetricsRequest>): Promise<WsMachine.MetricsResponse> {
+        return this._connection.send("GetMetrics", request, "json", false, undefined, "MetricsResponse");
+    }
+
+    GetNodeGroupUsage(request: Partial<WsMachine.GetNodeGroupUsageRequest>): Promise<WsMachine.GetNodeGroupUsageResponse> {
+        return this._connection.send("GetNodeGroupUsage", request, "json", false, undefined, "GetNodeGroupUsageResponse");
+    }
+
+    GetTargetClusterInfo(request: Partial<WsMachine.GetTargetClusterInfoRequest>): Promise<WsMachine.GetTargetClusterInfoResponse> {
+        return this._connection.send("GetTargetClusterInfo", request, "json", false, undefined, "GetTargetClusterInfoResponse");
+    }
+
+    GetTargetClusterUsage(request: Partial<WsMachine.GetTargetClusterUsageRequest>): Promise<WsMachine.GetTargetClusterUsageResponse> {
+        return this._connection.send("GetTargetClusterUsage", request, "json", false, undefined, "GetTargetClusterUsageResponse");
+    }
+
+    Ping(request: Partial<WsMachine.ws_machinePingRequest>): Promise<WsMachine.ws_machinePingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "ws_machinePingResponse");
+    }
+
+    UpdateComponentStatus(request: Partial<WsMachine.UpdateComponentStatusRequest>): Promise<WsMachine.UpdateComponentStatusResponse> {
+        return this._connection.send("UpdateComponentStatus", request, "json", false, undefined, "UpdateComponentStatusResponse");
+    }
+
+}

package/src/services/wsdl/wsstore/v1.02/wsstore.ts

@@ -1,10 +1,10 @@
 import { IConnection, IOptions } from "../../../../connection.ts";
 import { Service } from "../../../../espConnection.ts";
 
-type int = number;
-
 export namespace Wsstore {
 
+    export type int = number;
+
     export interface CreateStoreRequest {
         Name?: string;
         Type?: string;
@@ -25,10 +25,7 @@ export namespace Wsstore {
     }
 
     export interface CreateStoreResponse {
-        Exceptions: {
-            Source: string;
-            Exception: Exception[];
-        };
+        Exceptions: Exceptions;
         Name: string;
         Type: string;
         Description: string;
@@ -91,9 +88,7 @@ export namespace Wsstore {
     export interface FetchAllResponse {
         Exceptions: Exceptions;
         Namespace: string;
-        Pairs: {
-            Pair: Pair[];
-        };
+        Pairs: Pairs;
     }
 
     export interface FetchKeyMDRequest {
@@ -125,9 +120,7 @@ export namespace Wsstore {
         Exceptions: Exceptions;
         StoreName: string;
         Namespace: string;
-        KeySet: {
-            Key: string[];
-        };
+        KeySet: KeySet;
     }
 
     export interface ListNamespacesRequest {
@@ -142,9 +135,7 @@ export namespace Wsstore {
     export interface ListNamespacesResponse {
         Exceptions: Exceptions;
         StoreName: string;
-        Namespaces: {
-            Namespace: string[];
-        };
+        Namespaces: Namespaces;
     }
 
     export interface ListStoresRequest {
@@ -169,9 +160,7 @@ export namespace Wsstore {
 
     export interface ListStoresResponse {
         Exceptions: Exceptions;
-        Stores: {
-            Store: Store[];
-        };
+        Stores: Stores;
     }
 
     export interface wsstorePingRequest {
@@ -203,48 +192,48 @@ export class storeServiceBase extends Service {
         super(optsConnection, "wsstore", "1.02");
     }
 
-    CreateStore(request: Wsstore.CreateStoreRequest): Promise<Wsstore.CreateStoreResponse> {
-        return this._connection.send("CreateStore", request);
+    CreateStore(request: Partial<Wsstore.CreateStoreRequest>): Promise<Wsstore.CreateStoreResponse> {
+        return this._connection.send("CreateStore", request, "json", false, undefined, "CreateStoreResponse");
     }
 
-    Delete(request: Wsstore.DeleteRequest): Promise<Wsstore.DeleteResponse> {
-        return this._connection.send("Delete", request);
+    Delete(request: Partial<Wsstore.DeleteRequest>): Promise<Wsstore.DeleteResponse> {
+        return this._connection.send("Delete", request, "json", false, undefined, "DeleteResponse");
     }
 
-    DeleteNamespace(request: Wsstore.DeleteNamespaceRequest): Promise<Wsstore.DeleteNamespaceResponse> {
-        return this._connection.send("DeleteNamespace", request);
+    DeleteNamespace(request: Partial<Wsstore.DeleteNamespaceRequest>): Promise<Wsstore.DeleteNamespaceResponse> {
+        return this._connection.send("DeleteNamespace", request, "json", false, undefined, "DeleteNamespaceResponse");
     }
 
-    Fetch(request: Wsstore.FetchRequest): Promise<Wsstore.FetchResponse> {
-        return this._connection.send("Fetch", request);
+    Fetch(request: Partial<Wsstore.FetchRequest>): Promise<Wsstore.FetchResponse> {
+        return this._connection.send("Fetch", request, "json", false, undefined, "FetchResponse");
     }
 
-    FetchAll(request: Wsstore.FetchAllRequest): Promise<Wsstore.FetchAllResponse> {
-        return this._connection.send("FetchAll", request);
+    FetchAll(request: Partial<Wsstore.FetchAllRequest>): Promise<Wsstore.FetchAllResponse> {
+        return this._connection.send("FetchAll", request, "json", false, undefined, "FetchAllResponse");
     }
 
-    FetchKeyMetadata(request: Wsstore.FetchKeyMDRequest): Promise<Wsstore.FetchKeyMDResponse> {
-        return this._connection.send("FetchKeyMetadata", request);
+    FetchKeyMetadata(request: Partial<Wsstore.FetchKeyMDRequest>): Promise<Wsstore.FetchKeyMDResponse> {
+        return this._connection.send("FetchKeyMetadata", request, "json", false, undefined, "FetchKeyMDResponse");
     }
 
-    ListKeys(request: Wsstore.ListKeysRequest): Promise<Wsstore.ListKeysResponse> {
-        return this._connection.send("ListKeys", request);
+    ListKeys(request: Partial<Wsstore.ListKeysRequest>): Promise<Wsstore.ListKeysResponse> {
+        return this._connection.send("ListKeys", request, "json", false, undefined, "ListKeysResponse");
     }
 
-    ListNamespaces(request: Wsstore.ListNamespacesRequest): Promise<Wsstore.ListNamespacesResponse> {
-        return this._connection.send("ListNamespaces", request);
+    ListNamespaces(request: Partial<Wsstore.ListNamespacesRequest>): Promise<Wsstore.ListNamespacesResponse> {
+        return this._connection.send("ListNamespaces", request, "json", false, undefined, "ListNamespacesResponse");
     }
 
-    ListStores(request: Wsstore.ListStoresRequest): Promise<Wsstore.ListStoresResponse> {
-        return this._connection.send("ListStores", request);
+    ListStores(request: Partial<Wsstore.ListStoresRequest>): Promise<Wsstore.ListStoresResponse> {
+        return this._connection.send("ListStores", request, "json", false, undefined, "ListStoresResponse");
     }
 
-    Ping(request: Wsstore.wsstorePingRequest): Promise<Wsstore.wsstorePingResponse> {
-        return this._connection.send("Ping", request);
+    Ping(request: Partial<Wsstore.wsstorePingRequest>): Promise<Wsstore.wsstorePingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "wsstorePingResponse");
     }
 
-    Set(request: Wsstore.SetRequest): Promise<Wsstore.SetResponse> {
-        return this._connection.send("Set", request);
+    Set(request: Partial<Wsstore.SetRequest>): Promise<Wsstore.SetResponse> {
+        return this._connection.send("Set", request, "json", false, undefined, "SetResponse");
     }
 
 }

package/types/__package__.d.ts

@@ -1,3 +1,3 @@
 export declare const PKG_NAME = "@hpcc-js/comms";
-export declare const PKG_VERSION = "3.8.0";
-export declare const BUILD_VERSION = "3.11.1";
+export declare const PKG_VERSION = "3.8.1";
+export declare const BUILD_VERSION = "3.11.2";

package/types/ecl/logicalFile.d.ts

@@ -77,6 +77,7 @@ export declare class LogicalFile extends StateObject<FileDetailEx, FileDetailEx>
     get StateID(): number;
     get ExpirationDate(): string;
     get ExtendedIndexInfo(): WsDfu.ExtendedIndexInfo;
+    get CompressionType(): string;
     get properties(): FileDetailEx;
     static attach(optsConnection: IOptions | IConnection | DFUService, Cluster: string, Name: string, state?: FileDetailEx): LogicalFile;
     protected constructor(optsConnection: IOptions | IConnection | DFUService, Cluster: string, Name: string);

package/types/services/fileSpray.d.ts

@@ -1,4 +1,4 @@
-import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.26/FileSpray.ts";
+import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.27/FileSpray.ts";
 export { FileSpray };
 type UpdateDFUWorkunitMinusWU = Omit<FileSpray.UpdateDFUWorkunit, "wu">;
 type UpdateDFUWorkunitWU = FileSpray.UpdateDFUWorkunit["wu"];