@hpcc-js/comms 2.90.0 → 2.91.0

package/types/services/wsdl/WsWorkunits/v1.98/WsWorkunits.d.ts

@@ -0,0 +1,2623 @@
+import { IConnection, IOptions } from "../../../../connection";
+import { Service } from "../../../../espConnection";
+export declare namespace WsWorkunits {
+    type int = number;
+    type double = number;
+    type long = number;
+    type nonNegativeInteger = number;
+    type unsignedInt = number;
+    type base64Binary = string;
+    type dateTime = string;
+    type integer = number;
+    enum ECLWUActions {
+        Abort = "Abort",
+        Delete = "Delete",
+        Deschedule = "Deschedule",
+        Reschedule = "Reschedule",
+        Pause = "Pause",
+        PauseNow = "PauseNow",
+        Protect = "Protect",
+        Unprotect = "Unprotect",
+        Restore = "Restore",
+        Resume = "Resume",
+        SetToFailed = "SetToFailed",
+        Archive = "Archive"
+    }
+    enum LogSelectColumnMode {
+        MIN = 0,
+        DEFAULT = 1,
+        ALL = 2,
+        CUSTOM = 3
+    }
+    enum SortDirection {
+        ASC = 0,
+        DSC = 1
+    }
+    enum LogEventClass {
+        ALL = "ALL",
+        DIS = "DIS",
+        ERR = "ERR",
+        WRN = "WRN",
+        INF = "INF",
+        PRO = "PRO",
+        MET = "MET",
+        EVT = "EVT"
+    }
+    enum EclDefinitionActions {
+        SyntaxCheck = "SyntaxCheck",
+        Deploy = "Deploy",
+        Publish = "Publish"
+    }
+    enum ErrorMessageFormat {
+        xml = "xml",
+        json = "json",
+        text = "text"
+    }
+    enum LogAccessLogFormat {
+        XML = 0,
+        JSON = 1,
+        CSV = 2
+    }
+    enum WUExceptionSeverity {
+        info = "info",
+        warning = "warning",
+        error = "error",
+        alert = "alert"
+    }
+    enum WUQueryFilterSuspendedType {
+        Allqueries = "Allqueries",
+        Notsuspended = "Notsuspended",
+        Suspended = "Suspended",
+        Suspendedbyuser = "Suspendedbyuser",
+        Suspendedbyfirstnode = "Suspendedbyfirstnode",
+        Suspendedbyanynode = "Suspendedbyanynode"
+    }
+    enum WUQuerySetFilterType {
+        All = "All",
+        Id = "Id",
+        Name = "Name",
+        Alias = "Alias",
+        Status = "Status"
+    }
+    enum WUProtectFilter {
+        All = "All",
+        Protected = "Protected",
+        NotProtected = "NotProtected"
+    }
+    enum QuerySetAliasActionTypes {
+        Deactivate = "Deactivate"
+    }
+    enum QuerysetImportActivation {
+        None = "None",
+        ActivateImportedActive = "ActivateImportedActive"
+    }
+    enum QuerySetQueryActionTypes {
+        Suspend = "Suspend",
+        Unsuspend = "Unsuspend",
+        ToggleSuspend = "ToggleSuspend",
+        Activate = "Activate",
+        Delete = "Delete",
+        DeleteQueriesAndWUs = "DeleteQueriesAndWUs",
+        RemoveAllAliases = "RemoveAllAliases",
+        ResetQueryStats = "ResetQueryStats"
+    }
+    enum WUQueryActivationMode {
+        DoNotActivateQuery = 0,
+        ActivateQuery = 1,
+        ActivateQuerySuspendPrevious = 2,
+        ActivateQueryDeletePrevious = 3
+    }
+    interface GVCAjaxGraph {
+        Name: string;
+        GraphName: string;
+        SubGraphId: int;
+        SubGraphOnly: boolean;
+    }
+    interface GVCAjaxGraphResponse {
+        Name: string;
+        GraphName: string;
+        GraphType: string;
+        SubGraphId: int;
+        SubGraphOnly: boolean;
+    }
+    interface Ping {
+    }
+    interface WsWorkunitsPingResponse {
+    }
+    interface Wuids {
+        Item: string[];
+    }
+    interface WUAbort {
+        Wuids: {
+            Item: string[];
+        };
+        BlockTillFinishTimer: int;
+    }
+    interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+    interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+    interface WUActionResult {
+        Wuid: string;
+        Action: string;
+        Result: string;
+    }
+    interface ActionResults {
+        WUActionResult: WUActionResult[];
+    }
+    interface WUAbortResponse {
+        Exceptions: {
+            Source: string;
+            Exception: Exception[];
+        };
+        ActionResults: {
+            WUActionResult: WUActionResult[];
+        };
+    }
+    interface WUAction {
+        Wuids: Wuids;
+        WUActionType: ECLWUActions;
+        Cluster: string;
+        Owner: string;
+        State: string;
+        StartDate: string;
+        EndDate: string;
+        ECL: string;
+        Jobname: string;
+        Test: string;
+        CurrentPage: string;
+        PageSize: string;
+        Sortby: string;
+        Descending: boolean;
+        EventServer: string;
+        EventName: string;
+        PageFrom: string;
+        BlockTillFinishTimer: int;
+    }
+    interface WUActionResponse {
+        Exceptions: Exceptions;
+        ActionResults: ActionResults;
+    }
+    interface WUAddLocalFileToWorkunit {
+        Wuid: string;
+        Name: string;
+        Val: string;
+        DefVal: string;
+        Type: int;
+        Length: int;
+    }
+    interface WUAddLocalFileToWorkunitResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Name: string;
+        Result: string;
+    }
+    interface PropertyOptions {
+        IncludeName: boolean;
+        IncludeRawValue: boolean;
+        IncludeFormatted: boolean;
+        IncludeMeasure: boolean;
+        IncludeCreator: boolean;
+        IncludeCreatorType: boolean;
+    }
+    interface WUAnalyseHotspot {
+        Wuid: string;
+        RootScope: string;
+        OptOnlyActive: boolean;
+        OnlyCriticalPath: boolean;
+        IncludeProperties: boolean;
+        IncludeStatistics: boolean;
+        ThresholdPercent: double;
+        PropertyOptions: {
+            IncludeName: boolean;
+            IncludeRawValue: boolean;
+            IncludeFormatted: boolean;
+            IncludeMeasure: boolean;
+            IncludeCreator: boolean;
+            IncludeCreatorType: boolean;
+        };
+    }
+    interface Property {
+        Name: string;
+        RawValue: string;
+        Formatted: string;
+        Measure: string;
+        Creator: string;
+        CreatorType: string;
+    }
+    interface Properties {
+        Property: Property[];
+    }
+    interface Note {
+        Source: string;
+        Message: string;
+        ErrorCode: nonNegativeInteger;
+        Severity: string;
+        Cost: nonNegativeInteger;
+    }
+    interface Notes {
+        Note: Note[];
+    }
+    interface Activity {
+        ScopeName: string;
+        Id: string;
+        ScopeType: string;
+        Properties: {
+            Property: Property[];
+        };
+        Notes: {
+            Note: Note[];
+        };
+        SinkActivity: string;
+    }
+    interface Activities {
+        Activity: Activity[];
+    }
+    interface Dependency {
+        ScopeName: string;
+        Id: string;
+        ScopeType: string;
+        Properties: Properties;
+        Notes: Notes;
+        SinkActivity: string;
+    }
+    interface Dependencies {
+        Dependency: Dependency[];
+    }
+    interface WUAnalyseHotspotResponse {
+        Exceptions: Exceptions;
+        RootScope: string;
+        RootTime: long;
+        Activities: {
+            Activity: Activity[];
+        };
+        Dependencies: {
+            Dependency: Dependency[];
+        };
+    }
+    interface WUCDebug {
+        Wuid: string;
+        Command: string;
+    }
+    interface WUDebugResponse {
+        Exceptions: Exceptions;
+        Result: string;
+    }
+    interface WUCheckFeatures {
+        IncludeFullVersion: boolean;
+    }
+    interface Deployment {
+        UseCompression: boolean;
+    }
+    interface WUCheckFeaturesResponse {
+        Exceptions: Exceptions;
+        BuildVersionMajor: int;
+        BuildVersionMinor: int;
+        BuildVersionPoint: int;
+        maxRequestEntityLength: unsignedInt;
+        Deployment: {
+            UseCompression: boolean;
+        };
+        BuildVersion: string;
+        BuildMaturity: string;
+        BuildTagTimestamp: string;
+    }
+    interface WUClusterJobQueueLOG {
+        Cluster: string;
+        StartDate: string;
+        EndDate: string;
+    }
+    interface WUClusterJobQueueLOGResponse {
+        Exceptions: Exceptions;
+        thefile: base64Binary;
+    }
+    interface WUClusterJobQueueXLS {
+        Cluster: string;
+        StartDate: string;
+        EndDate: string;
+        ShowType: string;
+    }
+    interface WUClusterJobQueueXLSResponse {
+        Exceptions: Exceptions;
+        Result: base64Binary;
+    }
+    interface WUClusterJobSummaryXLS {
+        Cluster: string;
+        StartDate: string;
+        EndDate: string;
+        ShowAll: boolean;
+        BusinessStartTime: string;
+        BusinessEndTime: string;
+    }
+    interface WUClusterJobSummaryXLSResponse {
+        Exceptions: Exceptions;
+        Result: base64Binary;
+    }
+    interface WUClusterJobXLS {
+        Cluster: string;
+        StartDate: string;
+        EndDate: string;
+        ShowAll: boolean;
+        BusinessStartTime: string;
+        BusinessEndTime: string;
+    }
+    interface WUClusterJobXLSResponse {
+        Exceptions: Exceptions;
+        Result: base64Binary;
+    }
+    interface WUCompileECL {
+        ECL: string;
+        ModuleName: string;
+        AttributeName: string;
+        Queue: string;
+        Cluster: string;
+        Snapshot: string;
+        IncludeDependencies: boolean;
+        IncludeComplexity: boolean;
+        TimeToWait: int;
+    }
+    interface ECLException {
+        Source: string;
+        Severity: string;
+        Code: int;
+        Message: string;
+        FileName: string;
+        LineNo: int;
+        Column: int;
+        Activity: int;
+        Scope: string;
+        Priority: int;
+    }
+    interface Errors {
+        ECLException: ECLException[];
+    }
+    interface WUCompileECLResponse {
+        Exceptions: Exceptions;
+        Complexity: string;
+        Errors: {
+            ECLException: ECLException[];
+        };
+        Dependencies: Dependencies;
+    }
+    interface WUCopyLogicalFiles {
+        Wuid: string;
+        Cluster: string;
+        CopyLocal: boolean;
+    }
+    interface Clusters {
+        Item: string[];
+    }
+    interface WULogicalFileCopyInfo {
+        IsIndex: boolean;
+        LogicalName: string;
+        DfuCopyWuid: string;
+        DfuCopyError: string;
+        Clusters: {
+            Item: string[];
+        };
+    }
+    interface OnCluster {
+        WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+    }
+    interface NotOnCluster {
+        WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+    }
+    interface Foreign {
+        WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+    }
+    interface NotFound {
+        WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+    }
+    interface Cluster {
+        ClusterName: string;
+        OnCluster: {
+            WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+        };
+        NotOnCluster: {
+            WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+        };
+        Foreign: {
+            WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+        };
+        NotFound: {
+            WULogicalFileCopyInfo: WULogicalFileCopyInfo[];
+        };
+    }
+    interface ClusterFiles {
+        Cluster: Cluster[];
+    }
+    interface WUCopyLogicalFilesResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        ClusterFiles: {
+            Cluster: Cluster[];
+        };
+    }
+    interface WUCopyQuerySet {
+        Source: string;
+        Target: string;
+        ActiveOnly: boolean;
+        CloneActiveState: boolean;
+        AllowForeignFiles: boolean;
+        DfsServer: string;
+        CopyFiles: boolean;
+        OverwriteDfs: boolean;
+        SourceProcess: string;
+        UpdateSuperFiles: boolean;
+        UpdateCloneFrom: boolean;
+        AppendCluster: boolean;
+        IncludeFileErrors: boolean;
+        SourceSSL: boolean;
+        DfuCopyFiles: boolean;
+        DfuQueue: string;
+        DfuWait: nonNegativeInteger;
+        DfuOverwrite: boolean;
+        OnlyCopyFiles: boolean;
+        StopIfFilesCopied: boolean;
+        DfuPublisherWuid: string;
+        RemoteStorage: string;
+    }
+    interface CopiedQueries {
+        QueryId: string[];
+    }
+    interface ExistingQueries {
+        QueryId: string[];
+    }
+    interface File {
+        Error: string;
+        LogicalName: string;
+    }
+    interface FileErrors {
+        File: File[];
+    }
+    interface WUCopyQuerySetResponse {
+        Exceptions: Exceptions;
+        CopiedQueries: {
+            QueryId: string[];
+        };
+        ExistingQueries: {
+            QueryId: string[];
+        };
+        FileErrors: {
+            File: File[];
+        };
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+    interface WUCreate {
+    }
+    interface Query {
+        Text: string;
+        Cpp: string;
+        ResTxt: string;
+        Dll: string;
+        ThorLog: string;
+        QueryMainDefinition: string;
+    }
+    interface ECLHelpFile {
+        Name: string;
+        Type: string;
+        IPAddress: string;
+        Description: string;
+        FileSize: long;
+        PID: unsignedInt;
+        minActivityId: unsignedInt;
+        maxActivityId: unsignedInt;
+        IsAvailable: boolean;
+    }
+    interface Helpers {
+        ECLHelpFile: ECLHelpFile[];
+    }
+    interface ECLGraph {
+        Name: string;
+        Label: string;
+        Type: string;
+        Running: boolean;
+        Complete: boolean;
+        Failed: boolean;
+        RunningId: long;
+        WhenStarted: string;
+        WhenFinished: string;
+    }
+    interface Graphs {
+        ECLGraph: ECLGraph[];
+    }
+    interface ECLSourceFiles {
+        ECLSourceFile: ECLSourceFile[];
+    }
+    interface ECLSourceFile {
+        FileCluster: string;
+        Name: string;
+        IsSuperFile: boolean;
+        Subs: int;
+        Count: int;
+        ECLSourceFiles: {
+            ECLSourceFile: ECLSourceFile[];
+        };
+    }
+    interface SourceFiles {
+        ECLSourceFile: ECLSourceFile[];
+    }
+    interface ECLSchemaItem {
+        ColumnName: string;
+        ColumnType: string;
+        ColumnTypeCode: int;
+        isConditional: boolean;
+    }
+    interface ECLSchemas {
+        ECLSchemaItem: ECLSchemaItem[];
+    }
+    interface ECLResult {
+        Name: string;
+        Sequence: int;
+        Value: string;
+        Link: string;
+        FileName: string;
+        IsSupplied: boolean;
+        ShowFileContent: boolean;
+        Total: long;
+        ECLSchemas: {
+            ECLSchemaItem: ECLSchemaItem[];
+        };
+        XmlSchema: string;
+    }
+    interface Results {
+        ECLResult: ECLResult[];
+    }
+    interface Variables {
+        ECLResult: ECLResult[];
+    }
+    interface ECLTimer {
+        Name: string;
+        Value: string;
+        count: int;
+        GraphName: string;
+        SubGraphId: int;
+        Timestamp: long;
+        When: string;
+    }
+    interface Timers {
+        ECLTimer: ECLTimer[];
+    }
+    interface DebugValue {
+        Name: string;
+        Value: string;
+    }
+    interface DebugValues {
+        DebugValue: DebugValue[];
+    }
+    interface ApplicationValue {
+        Application: string;
+        Name: string;
+        Value: string;
+    }
+    interface ApplicationValues {
+        ApplicationValue: ApplicationValue[];
+    }
+    interface ECLWorkflow {
+        WFID: string;
+        EventName: string;
+        EventText: string;
+        Count: int;
+        CountRemaining: int;
+    }
+    interface Workflows {
+        ECLWorkflow: ECLWorkflow[];
+    }
+    interface ECLTimingData {
+        Name: string;
+        GraphNum: int;
+        SubGraphNum: int;
+        GID: int;
+        Min: int;
+        MS: int;
+    }
+    interface TimingData {
+        ECLTimingData: ECLTimingData[];
+    }
+    interface AllowedClusters {
+        AllowedCluster: string[];
+    }
+    interface ThorLogInfo {
+        ProcessName: string;
+        ClusterGroup: string;
+        LogDate: string;
+        NumberSlaves: int;
+    }
+    interface ThorLogList {
+        ThorLogInfo: ThorLogInfo[];
+    }
+    interface ResourceURLs {
+        URL: string[];
+    }
+    interface ServiceNames {
+        Item: string[];
+    }
+    interface ECLWUProcess {
+        Name: string;
+        Type: string;
+        PodName: string;
+        InstanceNumber: int;
+        Log: string;
+        PID: string;
+        Pattern: string;
+        Max: int;
+    }
+    interface ECLWUProcessList {
+        ECLWUProcess: ECLWUProcess[];
+    }
+    interface Workunit {
+        Wuid: string;
+        Owner: string;
+        Cluster: string;
+        RoxieCluster: string;
+        Jobname: string;
+        Queue: string;
+        StateID: int;
+        State: string;
+        StateEx: string;
+        Description: string;
+        Protected: boolean;
+        Active: boolean;
+        Action: int;
+        ActionEx: string;
+        DateTimeScheduled: dateTime;
+        PriorityClass: int;
+        PriorityLevel: int;
+        Scope: string;
+        Snapshot: string;
+        ResultLimit: int;
+        Archived: boolean;
+        IsPausing: boolean;
+        ThorLCR: boolean;
+        EventSchedule: int;
+        TotalClusterTime: string;
+        AbortBy: string;
+        AbortTime: string;
+        Query: {
+            Text: string;
+            Cpp: string;
+            ResTxt: string;
+            Dll: string;
+            ThorLog: string;
+            QueryMainDefinition: string;
+        };
+        Helpers: {
+            ECLHelpFile: ECLHelpFile[];
+        };
+        Exceptions: Exceptions;
+        Graphs: {
+            ECLGraph: ECLGraph[];
+        };
+        SourceFiles: {
+            ECLSourceFile: ECLSourceFile[];
+        };
+        Results: {
+            ECLResult: ECLResult[];
+        };
+        Variables: {
+            ECLResult: ECLResult[];
+        };
+        Timers: {
+            ECLTimer: ECLTimer[];
+        };
+        DebugValues: {
+            DebugValue: DebugValue[];
+        };
+        ApplicationValues: {
+            ApplicationValue: ApplicationValue[];
+        };
+        Workflows: {
+            ECLWorkflow: ECLWorkflow[];
+        };
+        TimingData: {
+            ECLTimingData: ECLTimingData[];
+        };
+        AllowedClusters: {
+            AllowedCluster: string[];
+        };
+        ErrorCount: int;
+        WarningCount: int;
+        InfoCount: int;
+        AlertCount: int;
+        GraphCount: int;
+        SourceFileCount: int;
+        ResultCount: int;
+        VariableCount: int;
+        TimerCount: int;
+        HasDebugValue: boolean;
+        ApplicationValueCount: int;
+        XmlParams: string;
+        AccessFlag: int;
+        ClusterFlag: int;
+        HelpersDesc: string;
+        GraphsDesc: string;
+        SourceFilesDesc: string;
+        ResultsDesc: string;
+        VariablesDesc: string;
+        TimersDesc: string;
+        DebugValuesDesc: string;
+        ApplicationValuesDesc: string;
+        WorkflowsDesc: string;
+        HasArchiveQuery: boolean;
+        ThorLogList: {
+            ThorLogInfo: ThorLogInfo[];
+        };
+        ResourceURLs: {
+            URL: string[];
+        };
+        ResultViewCount: int;
+        ResourceURLCount: int;
+        DebugValueCount: int;
+        WorkflowCount: int;
+        HelpersCount: int;
+        ServiceNames: {
+            Item: string[];
+        };
+        ExecuteCost: double;
+        FileAccessCost: double;
+        CompileCost: double;
+        NoAccess: boolean;
+        ECLWUProcessList: {
+            ECLWUProcess: ECLWUProcess[];
+        };
+    }
+    interface WUCreateResponse {
+        Exceptions: Exceptions;
+        Workunit: {
+            Wuid: string;
+            Owner: string;
+            Cluster: string;
+            RoxieCluster: string;
+            Jobname: string;
+            Queue: string;
+            StateID: int;
+            State: string;
+            StateEx: string;
+            Description: string;
+            Protected: boolean;
+            Active: boolean;
+            Action: int;
+            ActionEx: string;
+            DateTimeScheduled: dateTime;
+            PriorityClass: int;
+            PriorityLevel: int;
+            Scope: string;
+            Snapshot: string;
+            ResultLimit: int;
+            Archived: boolean;
+            IsPausing: boolean;
+            ThorLCR: boolean;
+            EventSchedule: int;
+            TotalClusterTime: string;
+            AbortBy: string;
+            AbortTime: string;
+            Query: {
+                Text: string;
+                Cpp: string;
+                ResTxt: string;
+                Dll: string;
+                ThorLog: string;
+                QueryMainDefinition: string;
+            };
+            Helpers: {
+                ECLHelpFile: ECLHelpFile[];
+            };
+            Exceptions: Exceptions;
+            Graphs: {
+                ECLGraph: ECLGraph[];
+            };
+            SourceFiles: {
+                ECLSourceFile: ECLSourceFile[];
+            };
+            Results: {
+                ECLResult: ECLResult[];
+            };
+            Variables: {
+                ECLResult: ECLResult[];
+            };
+            Timers: {
+                ECLTimer: ECLTimer[];
+            };
+            DebugValues: {
+                DebugValue: DebugValue[];
+            };
+            ApplicationValues: {
+                ApplicationValue: ApplicationValue[];
+            };
+            Workflows: {
+                ECLWorkflow: ECLWorkflow[];
+            };
+            TimingData: {
+                ECLTimingData: ECLTimingData[];
+            };
+            AllowedClusters: {
+                AllowedCluster: string[];
+            };
+            ErrorCount: int;
+            WarningCount: int;
+            InfoCount: int;
+            AlertCount: int;
+            GraphCount: int;
+            SourceFileCount: int;
+            ResultCount: int;
+            VariableCount: int;
+            TimerCount: int;
+            HasDebugValue: boolean;
+            ApplicationValueCount: int;
+            XmlParams: string;
+            AccessFlag: int;
+            ClusterFlag: int;
+            HelpersDesc: string;
+            GraphsDesc: string;
+            SourceFilesDesc: string;
+            ResultsDesc: string;
+            VariablesDesc: string;
+            TimersDesc: string;
+            DebugValuesDesc: string;
+            ApplicationValuesDesc: string;
+            WorkflowsDesc: string;
+            HasArchiveQuery: boolean;
+            ThorLogList: {
+                ThorLogInfo: ThorLogInfo[];
+            };
+            ResourceURLs: {
+                URL: string[];
+            };
+            ResultViewCount: int;
+            ResourceURLCount: int;
+            DebugValueCount: int;
+            WorkflowCount: int;
+            HelpersCount: int;
+            ServiceNames: {
+                Item: string[];
+            };
+            ExecuteCost: double;
+            FileAccessCost: double;
+            CompileCost: double;
+            NoAccess: boolean;
+            ECLWUProcessList: {
+                ECLWUProcess: ECLWUProcess[];
+            };
+        };
+    }
+    interface WUCreateAndUpdate {
+        Wuid: string;
+        State: int;
+        StateOrig: int;
+        Jobname: string;
+        JobnameOrig: string;
+        QueryText: string;
+        Action: int;
+        Description: string;
+        DescriptionOrig: string;
+        AddDrilldownFields: boolean;
+        ResultLimit: int;
+        Protected: boolean;
+        ProtectedOrig: boolean;
+        PriorityClass: int;
+        PriorityLevel: int;
+        Scope: string;
+        ScopeOrig: string;
+        ClusterSelection: string;
+        ClusterOrig: string;
+        XmlParams: string;
+        ThorSlaveIP: string;
+        QueryMainDefinition: string;
+        DebugValues: DebugValues;
+        ApplicationValues: ApplicationValues;
+    }
+    interface WUUpdateResponse {
+        Exceptions: Exceptions;
+        Workunit: Workunit;
+    }
+    interface AbsoluteTimeRange {
+        StartDate: dateTime;
+        EndDate: dateTime;
+    }
+    interface CustomColumns {
+        Item: string[];
+    }
+    interface ComponentsFilter {
+        Item: string[];
+    }
+    interface LogFilter {
+        WildcardFilter: string;
+        AbsoluteTimeRange: {
+            StartDate: dateTime;
+            EndDate: dateTime;
+        };
+        RelativeTimeRangeBuffer: unsignedInt;
+        LineLimit: unsignedInt;
+        LineStartFrom: long;
+        SelectColumnMode: LogSelectColumnMode;
+        CustomColumns: {
+            Item: string[];
+        };
+        ComponentsFilter: {
+            Item: string[];
+        };
+        Format: LogAccessLogFormat;
+        sortByTimeDirection: SortDirection;
+        LogEventType: LogEventClass;
+    }
+    interface WUCreateZAPInfo {
+        Wuid: string;
+        ESPApplication: string;
+        ThorProcesses: string;
+        BuildVersion: string;
+        ProblemDescription: string;
+        WhatChanged: string;
+        WhereSlow: string;
+        ZAPFileName: string;
+        IncludeThorSlaveLog: string;
+        ZAPPassword: string;
+        SendEmail: boolean;
+        AttachZAPReportToEmail: boolean;
+        EmailFrom: string;
+        EmailSubject: string;
+        EmailBody: string;
+        LogFilter: {
+            WildcardFilter: string;
+            AbsoluteTimeRange: {
+                StartDate: dateTime;
+                EndDate: dateTime;
+            };
+            RelativeTimeRangeBuffer: unsignedInt;
+            LineLimit: unsignedInt;
+            LineStartFrom: long;
+            SelectColumnMode: LogSelectColumnMode;
+            CustomColumns: {
+                Item: string[];
+            };
+            ComponentsFilter: {
+                Item: string[];
+            };
+            Format: LogAccessLogFormat;
+            sortByTimeDirection: SortDirection;
+            LogEventType: LogEventClass;
+        };
+    }
+    interface WUCreateZAPInfoResponse {
+        Exceptions: Exceptions;
+        thefile: base64Binary;
+        ZAPFileName: string;
+    }
+    interface WUDelete {
+        Wuids: Wuids;
+        BlockTillFinishTimer: int;
+    }
+    interface WUDeleteResponse {
+        Exceptions: Exceptions;
+        ActionResults: ActionResults;
+    }
+    interface WUDeployWorkunit {
+        Cluster: string;
+        Name: string;
+        Wait: int;
+        ObjType: string;
+        FileName: string;
+        Object: base64Binary;
+        ResultLimit: int;
+        QueryMainDefinition: string;
+        Snapshot: string;
+        DebugValues: DebugValues;
+        Protect: boolean;
+    }
+    interface WUDeployWorkunitResponse {
+        Exceptions: Exceptions;
+        Workunit: Workunit;
+    }
+    interface Scopes {
+        Scope: string[];
+    }
+    interface Ids {
+        id: string[];
+    }
+    interface ScopeTypes {
+        ScopeType: string[];
+    }
+    interface PropertyFilter {
+        Name: string;
+        ExactValue: string;
+        MinValue: string;
+        MaxValue: string;
+    }
+    interface PropertyFilters {
+        PropertyFilter: PropertyFilter[];
+    }
+    interface ScopeFilter {
+        MaxDepth: integer;
+        Scopes: {
+            Scope: string[];
+        };
+        Ids: {
+            id: string[];
+        };
+        ScopeTypes: {
+            ScopeType: string[];
+        };
+        PropertyFilters: {
+            PropertyFilter: PropertyFilter[];
+        };
+    }
+    interface NestedFilter {
+        Depth: unsignedInt;
+        ScopeTypes: ScopeTypes;
+    }
+    interface Extra {
+        scopeType: string;
+        Properties: Properties;
+    }
+    interface ExtraProperties {
+        Extra: Extra[];
+    }
+    interface PropertiesToReturn {
+        AllStatistics: boolean;
+        AllAttributes: boolean;
+        AllHints: boolean;
+        AllScopes: boolean;
+        AllProperties: boolean;
+        AllNotes: boolean;
+        MinVersion: unsignedInt;
+        Measure: string;
+        Properties: Properties;
+        ExtraProperties: {
+            Extra: Extra[];
+        };
+    }
+    interface ScopeOptions {
+        IncludeMatchedScopesInResults: boolean;
+        IncludeScope: boolean;
+        IncludeId: boolean;
+        IncludeScopeType: boolean;
+    }
+    interface WUDetails {
+        WUID: string;
+        ScopeFilter: {
+            MaxDepth: integer;
+            Scopes: {
+                Scope: string[];
+            };
+            Ids: {
+                id: string[];
+            };
+            ScopeTypes: {
+                ScopeType: string[];
+            };
+            PropertyFilters: {
+                PropertyFilter: PropertyFilter[];
+            };
+        };
+        NestedFilter: {
+            Depth: unsignedInt;
+            ScopeTypes: ScopeTypes;
+        };
+        PropertiesToReturn: {
+            AllStatistics: boolean;
+            AllAttributes: boolean;
+            AllHints: boolean;
+            AllScopes: boolean;
+            AllProperties: boolean;
+            AllNotes: boolean;
+            MinVersion: unsignedInt;
+            Measure: string;
+            Properties: Properties;
+            ExtraProperties: {
+                Extra: Extra[];
+            };
+        };
+        Filter: string;
+        ScopeOptions: {
+            IncludeMatchedScopesInResults: boolean;
+            IncludeScope: boolean;
+            IncludeId: boolean;
+            IncludeScopeType: boolean;
+        };
+        PropertyOptions: PropertyOptions;
+    }
+    interface WUDetailsResponse {
+        Exceptions: Exceptions;
+        MaxVersion: unsignedInt;
+        WUID: string;
+        Scopes: Scopes;
+    }
+    interface WUDetailsMeta {
+    }
+    interface Measures {
+        Measure: string[];
+    }
+    interface WUDetailsMetaResponse {
+        Exceptions: Exceptions;
+        Properties: Properties;
+        ScopeTypes: ScopeTypes;
+        Measures: {
+            Measure: string[];
+        };
+        Activities: Activities;
+    }
+    interface EclDefinitions {
+        Item: string[];
+    }
+    interface WUEclDefinitionAction {
+        EclDefinitions: {
+            Item: string[];
+        };
+        ActionType: EclDefinitionActions;
+        Target: string;
+        RemoteDali: string;
+        SourceProcess: string;
+        Priority: string;
+        Comment: string;
+        MemoryLimit: string;
+        DeletePrevious: boolean;
+        SuspendPrevious: boolean;
+        NoActivate: boolean;
+        NoReload: boolean;
+        DontCopyFiles: boolean;
+        AllowForeign: boolean;
+        UpdateDfs: boolean;
+        UpdateSuperfiles: boolean;
+        UpdateCloneFrom: boolean;
+        DontAppendCluster: boolean;
+        MsToWait: int;
+        TimeLimit: int;
+        WarnTimeLimit: int;
+        DfuCopyFiles: boolean;
+        DfuOverwrite: boolean;
+        DfuQueue: string;
+        OnlyCopyFiles: boolean;
+        StopIfFilesCopied: boolean;
+        DfuPublisherWuid: string;
+        RemoteStorage: string;
+    }
+    interface WUEclDefinitionActionResponse {
+        Exceptions: Exceptions;
+        ActionResults: ActionResults;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+    interface WUExport {
+        Cluster: string;
+        Owner: string;
+        State: string;
+        StartDate: string;
+        EndDate: string;
+        Jobname: string;
+    }
+    interface WUExportResponse {
+        Exceptions: Exceptions;
+        ExportData: base64Binary;
+    }
+    interface LogColumns {
+        Item: string[];
+    }
+    interface WUFile {
+        Name: string;
+        Wuid: string;
+        Type: string;
+        Option: int;
+        SlaveIP: string;
+        IPAddress: string;
+        Description: string;
+        QuerySet: string;
+        Query: string;
+        Process: string;
+        ClusterGroup: string;
+        LogDate: string;
+        SlaveNumber: int;
+        SizeLimit: long;
+        ErrorMessageFormat: ErrorMessageFormat;
+        PlainText: string;
+        MaxLogRecords: unsignedInt;
+        LogSelectColumnMode: LogSelectColumnMode;
+        LogFormat: LogAccessLogFormat;
+        LogSearchTimeBuffSecs: unsignedInt;
+        LogColumns: {
+            Item: string[];
+        };
+    }
+    interface WULogFileResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        QuerySet: string;
+        QueryName: string;
+        QueryId: string;
+        FileName: string;
+        DaliServer: string;
+        thefile: base64Binary;
+    }
+    interface WUFullResult {
+        Wuid: string;
+        NoRootTag: boolean;
+        ExceptionSeverity: WUExceptionSeverity;
+    }
+    interface WUFullResultResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Results: string;
+    }
+    interface WUGVCGraphInfo {
+        Wuid: string;
+        Name: string;
+        GID: string;
+        BatchWU: int;
+        SubgraphId: int;
+    }
+    interface WUGVCGraphInfoResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Name: string;
+        GID: string;
+        Running: boolean;
+        TheGraph: string;
+        BatchWU: int;
+    }
+    interface WUGetArchiveFile {
+        WUID: string;
+        ModuleName: string;
+        FileName: string;
+        Path: string;
+    }
+    interface WUGetArchiveFileResponse {
+        Exceptions: Exceptions;
+        File: string;
+        Message: string;
+    }
+    interface WUGetDependancyTrees {
+        Cluster: string;
+        Queue: string;
+        Snapshot: string;
+        Items: string;
+        TimeoutMilliSec: string;
+    }
+    interface WUGetDependancyTreesResponse {
+        Exceptions: Exceptions;
+        Errors: Errors;
+        DependancyTrees: base64Binary;
+    }
+    interface WUGetGraph {
+        Wuid: string;
+        GraphName: string;
+        SubGraphId: string;
+    }
+    interface WUGetGraphResponse {
+        Exceptions: Exceptions;
+        Graphs: Graphs;
+    }
+    interface WUGetGraphNameAndTypes {
+        Wuid: string;
+        Type: string;
+    }
+    interface GraphNameAndType {
+        Name: string;
+        Type: string;
+    }
+    interface GraphNameAndTypes {
+        GraphNameAndType: GraphNameAndType[];
+    }
+    interface WUGetGraphNameAndTypesResponse {
+        Exceptions: Exceptions;
+        GraphNameAndTypes: {
+            GraphNameAndType: GraphNameAndType[];
+        };
+    }
+    interface WUGetNumFileToCopy {
+        ClusterName: string;
+        TargetName: string;
+        PageSize: long;
+        PageStartFrom: long;
+        Sortby: string;
+        Descending: boolean;
+        CacheHint: long;
+    }
+    interface Endpoint {
+        URL: string;
+        Status: string;
+        NumQueryFileToCopy: int;
+    }
+    interface Endpoints {
+        Endpoint: Endpoint[];
+    }
+    interface WUGetNumFileToCopyResponse {
+        Exceptions: Exceptions;
+        Endpoints: {
+            Endpoint: Endpoint[];
+        };
+        CacheHint: long;
+        Total: long;
+    }
+    interface WUGetPlugins {
+    }
+    interface WUEclPluginsInFolder {
+        Path: string;
+        Plugins: Plugins;
+    }
+    interface Plugins {
+        WUEclPluginsInFolder: WUEclPluginsInFolder[];
+    }
+    interface WUGetPluginsResponse {
+        Exceptions: Exceptions;
+        Plugins: {
+            WUEclPluginsInFolder: WUEclPluginsInFolder[];
+        };
+    }
+    interface WUGetStats {
+        WUID: string;
+        CreatorType: string;
+        Creator: string;
+        ScopeType: string;
+        Scope: string;
+        Kind: string;
+        Measure: string;
+        MinScopeDepth: unsignedInt;
+        MaxScopeDepth: unsignedInt;
+        IncludeGraphs: boolean;
+        CreateDescriptions: boolean;
+        MinValue: long;
+        MaxValue: long;
+        Filter: string;
+    }
+    interface WUStatisticItem {
+        Creator: string;
+        CreatorType: string;
+        Scope: string;
+        ScopeType: string;
+        Description: string;
+        TimeStamp: string;
+        Measure: string;
+        Kind: string;
+        Value: string;
+        RawValue: long;
+        Count: long;
+        Max: long;
+        Wuid: string;
+    }
+    interface Statistics {
+        WUStatisticItem: WUStatisticItem[];
+    }
+    interface WUGetStatsResponse {
+        Exceptions: Exceptions;
+        WUID: string;
+        Statistics: {
+            WUStatisticItem: WUStatisticItem[];
+        };
+    }
+    interface WUGetThorJobList {
+        Cluster: string;
+        StartDate: string;
+        EndDate: string;
+        MaxJobsToReturn: unsignedInt;
+    }
+    interface ECLJob {
+        Wuid: string;
+        Graph: string;
+        State: string;
+        StartedDate: string;
+        FinishedDate: string;
+        Cluster: string;
+        GraphNum: string;
+        SubGraphNum: string;
+        NumOfRuns: string;
+        Duration: int;
+    }
+    interface JobList {
+        ECLJob: ECLJob[];
+    }
+    interface InProgressJobList {
+        ECLJob: ECLJob[];
+    }
+    interface WUGetThorJobListResponse {
+        Exceptions: Exceptions;
+        JobList: {
+            ECLJob: ECLJob[];
+        };
+        InProgressJobList: {
+            ECLJob: ECLJob[];
+        };
+        Warning: string;
+    }
+    interface WUGetThorJobQueue {
+        Cluster: string;
+        StartDate: string;
+        EndDate: string;
+        MaxJobQueueItemsToReturn: unsignedInt;
+    }
+    interface ThorQueue {
+        DT: string;
+        RunningWUs: string;
+        QueuedWUs: string;
+        WaitingThors: string;
+        ConnectedThors: string;
+        IdledThors: string;
+        RunningWU1: string;
+        RunningWU2: string;
+    }
+    interface QueueList {
+        ThorQueue: ThorQueue[];
+    }
+    interface WUGetThorJobQueueResponse {
+        Exceptions: Exceptions;
+        LongestQueue: int;
+        MaxThorConnected: int;
+        QueueList: {
+            ThorQueue: ThorQueue[];
+        };
+        Warning: string;
+    }
+    interface WUGetZAPInfo {
+        WUID: string;
+    }
+    interface WUGetZAPInfoResponse {
+        Exceptions: Exceptions;
+        WUID: string;
+        ESPApplication: string;
+        ThorProcesses: string;
+        BuildVersion: string;
+        Archive: string;
+        EmailTo: string;
+        EmailFrom: string;
+        Message: string;
+    }
+    interface WUGraphInfo {
+        Wuid: string;
+        Name: string;
+        GID: string;
+        BatchWU: int;
+    }
+    interface WUGraphInfoResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Name: string;
+        GID: string;
+        BatchWU: int;
+        Running: boolean;
+    }
+    interface WUGraphTiming {
+        Wuid: string;
+    }
+    interface WUGraphTimingResponse {
+        Exceptions: Exceptions;
+        Workunit: Workunit;
+    }
+    interface WUInfo {
+        Wuid: string;
+        TruncateEclTo64k: boolean;
+        Type: string;
+        IncludeExceptions: boolean;
+        IncludeGraphs: boolean;
+        IncludeSourceFiles: boolean;
+        IncludeResults: boolean;
+        IncludeResultsViewNames: boolean;
+        IncludeVariables: boolean;
+        IncludeTimers: boolean;
+        IncludeDebugValues: boolean;
+        IncludeApplicationValues: boolean;
+        IncludeWorkflows: boolean;
+        IncludeXmlSchemas: boolean;
+        IncludeResourceURLs: boolean;
+        IncludeECL: boolean;
+        IncludeHelpers: boolean;
+        IncludeAllowedClusters: boolean;
+        IncludeTotalClusterTime: boolean;
+        IncludeServiceNames: boolean;
+        IncludeProcesses: boolean;
+        SuppressResultSchemas: boolean;
+        ThorSlaveIP: string;
+    }
+    interface ResultViews {
+        View: string[];
+    }
+    interface WUInfoResponse {
+        Exceptions: Exceptions;
+        Workunit: Workunit;
+        AutoRefresh: int;
+        CanCompile: boolean;
+        ThorSlaveIP: string;
+        ResultViews: {
+            View: string[];
+        };
+        SecMethod: string;
+    }
+    interface WUInfoDetails {
+        Wuid: string;
+        TruncateEclTo64k: boolean;
+        Type: string;
+        IncludeExceptions: boolean;
+        IncludeGraphs: boolean;
+        IncludeSourceFiles: boolean;
+        IncludeResults: boolean;
+        IncludeResultsViewNames: boolean;
+        IncludeVariables: boolean;
+        IncludeTimers: boolean;
+        IncludeDebugValues: boolean;
+        IncludeApplicationValues: boolean;
+        IncludeWorkflows: boolean;
+        IncludeXmlSchemas: boolean;
+        IncludeResourceURLs: boolean;
+        IncludeECL: boolean;
+        IncludeHelpers: boolean;
+        IncludeAllowedClusters: boolean;
+        IncludeTotalClusterTime: boolean;
+        IncludeServiceNames: boolean;
+        IncludeProcesses: boolean;
+        SuppressResultSchemas: boolean;
+        ThorSlaveIP: string;
+    }
+    interface WUJobList {
+        Cluster: string;
+        Process: string;
+        StartDate: string;
+        EndDate: string;
+        ShowAll: boolean;
+        BusinessStartHour: int;
+        BusinessEndHour: int;
+    }
+    interface Jobs {
+        ECLJob: ECLJob[];
+    }
+    interface WUJobListResponse {
+        Exceptions: Exceptions;
+        StartDate: string;
+        EndDate: string;
+        Jobs: {
+            ECLJob: ECLJob[];
+        };
+    }
+    interface WULightWeightQuery {
+        Wuid: string;
+        Type: string;
+        Cluster: string;
+        Owner: string;
+        JobName: string;
+        StartDate: string;
+        EndDate: string;
+        BeforeWU: string;
+        AfterWU: string;
+        State: string;
+        ApplicationValues: ApplicationValues;
+        PageStartFrom: long;
+        PageSize: unsignedInt;
+        SortBy: string;
+        Descending: boolean;
+        CacheHint: long;
+    }
+    interface ECLWorkunitLW {
+        Wuid: string;
+        Owner: string;
+        JobName: string;
+        WuScope: string;
+        ClusterName: string;
+        State: int;
+        StateDesc: string;
+        Action: int;
+        ActionDesc: string;
+        Priority: int;
+        PriorityDesc: string;
+        PriorityLevel: int;
+        IsProtected: boolean;
+        DateTimeScheduled: dateTime;
+        TotalClusterTime: unsignedInt;
+        ApplicationValues: ApplicationValues;
+        NoAccess: boolean;
+    }
+    interface Workunits {
+        ECLWorkunitLW: ECLWorkunitLW[];
+    }
+    interface WULightWeightQueryResponse {
+        Exceptions: Exceptions;
+        NumWUs: int;
+        CacheHint: long;
+        Workunits: {
+            ECLWorkunitLW: ECLWorkunitLW[];
+        };
+    }
+    interface WUListArchiveFiles {
+        WUID: string;
+    }
+    interface Files {
+        File: File[];
+    }
+    interface ArchiveModule {
+        Name: string;
+        FullName: string;
+        Flags: unsignedInt;
+        Key: string;
+        Plugin: string;
+        SourcePath: string;
+        Version: string;
+        Path: string;
+        ArchiveModules: ArchiveModules;
+        Files: {
+            File: File[];
+        };
+    }
+    interface ArchiveModules {
+        ArchiveModule: ArchiveModule[];
+    }
+    interface WUListArchiveFilesResponse {
+        Exceptions: Exceptions;
+        ArchiveModules: {
+            ArchiveModule: ArchiveModule[];
+        };
+        Files: Files;
+        Message: string;
+    }
+    interface WUListLocalFileRequired {
+        Wuid: string;
+    }
+    interface LogicalFileUpload {
+        Type: int;
+        Source: string;
+        Destination: string;
+        EventTag: string;
+    }
+    interface LocalFileUploads {
+        LogicalFileUpload: LogicalFileUpload[];
+    }
+    interface WUListLocalFileRequiredResponse {
+        Exceptions: Exceptions;
+        LocalFileUploads: {
+            LogicalFileUpload: LogicalFileUpload[];
+        };
+    }
+    interface WUListQueries {
+        QuerySetName: string;
+        ClusterName: string;
+        LibraryName: string;
+        MemoryLimitLow: long;
+        MemoryLimitHigh: long;
+        TimeLimitLow: nonNegativeInteger;
+        TimeLimitHigh: nonNegativeInteger;
+        WarnTimeLimitLow: nonNegativeInteger;
+        WarnTimeLimitHigh: nonNegativeInteger;
+        PriorityLow: nonNegativeInteger;
+        PriorityHigh: nonNegativeInteger;
+        Activated: boolean;
+        SuspendedFilter: WUQueryFilterSuspendedType;
+        WUID: string;
+        QueryID: string;
+        QueryName: string;
+        PublishedBy: string;
+        PageSize: nonNegativeInteger;
+        PageStartFrom: nonNegativeInteger;
+        Sortby: string;
+        Descending: boolean;
+        CacheHint: long;
+        FileName: string;
+        CheckAllNodes: boolean;
+    }
+    interface QuerySetQuery {
+        Id: string;
+        Name: string;
+        Wuid: string;
+        Dll: string;
+        Suspended: boolean;
+        Clusters: Clusters;
+        memoryLimit: string;
+        timeLimit: nonNegativeInteger;
+        warnTimeLimit: nonNegativeInteger;
+        priority: string;
+        Comment: string;
+        QuerySetId: string;
+        IsLibrary: boolean;
+        Activated: boolean;
+        PublishedBy: string;
+        snapshot: string;
+        PriorityID: int;
+    }
+    interface QuerysetQueries {
+        QuerySetQuery: QuerySetQuery[];
+    }
+    interface WUListQueriesResponse {
+        Exceptions: Exceptions;
+        NumberOfQueries: int;
+        CacheHint: long;
+        QuerysetQueries: {
+            QuerySetQuery: QuerySetQuery[];
+        };
+    }
+    interface WUListQueriesUsingFile {
+        Target: string;
+        Process: string;
+        FileName: string;
+    }
+    interface QueryUsingFile {
+        Id: string;
+        Package: string;
+    }
+    interface Queries {
+        QueryUsingFile: QueryUsingFile[];
+    }
+    interface TargetQueriesUsingFile {
+        Target: string;
+        PackageMap: string;
+        Queries: {
+            QueryUsingFile: QueryUsingFile[];
+        };
+    }
+    interface Targets {
+        TargetQueriesUsingFile: TargetQueriesUsingFile[];
+    }
+    interface WUListQueriesUsingFileResponse {
+        Exceptions: Exceptions;
+        Process: string;
+        FileName: string;
+        Targets: {
+            TargetQueriesUsingFile: TargetQueriesUsingFile[];
+        };
+    }
+    interface WUMultiQuerysetDetails {
+        ClusterName: string;
+        QuerySetName: string;
+        Filter: string;
+        FilterType: WUQuerySetFilterType;
+        CheckAllNodes: boolean;
+    }
+    interface QuerySetAlias {
+        Id: string;
+        Name: string;
+    }
+    interface Aliases {
+        QuerySetAlias: QuerySetAlias[];
+    }
+    interface WUQuerySetDetail {
+        QuerySetName: string;
+        Queries: Queries;
+        Aliases: {
+            QuerySetAlias: QuerySetAlias[];
+        };
+    }
+    interface Querysets {
+        WUQuerySetDetail: WUQuerySetDetail[];
+    }
+    interface WUMultiQuerySetDetailsResponse {
+        Exceptions: Exceptions;
+        ClusterName: string;
+        Querysets: {
+            WUQuerySetDetail: WUQuerySetDetail[];
+        };
+    }
+    interface WUProcessGraph {
+        Wuid: string;
+        Name: string;
+    }
+    interface WUProcessGraphResponse {
+        Exceptions: Exceptions;
+        theGraph: string;
+    }
+    interface WUProtect {
+        Wuids: Wuids;
+        Protect: boolean;
+    }
+    interface WUProtectResponse {
+        Exceptions: Exceptions;
+        ActionResults: ActionResults;
+    }
+    interface WUPublishWorkunit {
+        Wuid: string;
+        Cluster: string;
+        QueryName: string;
+        WorkUnitJobName: string;
+        JobName: string;
+        Activate: int;
+        NotifyCluster: boolean;
+        Wait: int;
+        NoReload: boolean;
+        UpdateWorkUnitName: boolean;
+        memoryLimit: string;
+        TimeLimit: nonNegativeInteger;
+        WarnTimeLimit: nonNegativeInteger;
+        Priority: string;
+        RemoteDali: string;
+        Comment: string;
+        DontCopyFiles: boolean;
+        SourceProcess: string;
+        AllowForeignFiles: boolean;
+        UpdateDfs: boolean;
+        UpdateSuperFiles: boolean;
+        UpdateCloneFrom: boolean;
+        AppendCluster: boolean;
+        IncludeFileErrors: boolean;
+        DfuCopyFiles: boolean;
+        DfuQueue: string;
+        DfuWait: nonNegativeInteger;
+        DfuOverwrite: boolean;
+        OnlyCopyFiles: boolean;
+        StopIfFilesCopied: boolean;
+        DfuPublisherWuid: string;
+        RemoteStorage: string;
+    }
+    interface WUPublishWorkunitResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Result: string;
+        QuerySet: string;
+        QueryName: string;
+        QueryId: string;
+        ReloadFailed: boolean;
+        Suspended: boolean;
+        ErrorMessage: string;
+        ClusterFiles: ClusterFiles;
+        FileErrors: FileErrors;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+    interface WUPushEvent {
+        EventName: string;
+        EventText: string;
+    }
+    interface WUPushEventResponse {
+        Exceptions: Exceptions;
+    }
+    interface WUQuery {
+        Wuid: string;
+        Type: string;
+        Cluster: string;
+        RoxieCluster: string;
+        Owner: string;
+        State: string;
+        StartDate: string;
+        EndDate: string;
+        ECL: string;
+        Jobname: string;
+        LogicalFile: string;
+        LogicalFileSearchType: string;
+        ApplicationValues: ApplicationValues;
+        BeforeWU: string;
+        AfterWU: string;
+        TotalClusterTimeThresholdMilliSec: unsignedInt;
+        Count: int;
+        PageSize: long;
+        PageStartFrom: long;
+        PageEndAt: long;
+        Protected: WUProtectFilter;
+        Sortby: string;
+        Descending: boolean;
+        CacheHint: long;
+    }
+    interface WUQueryResponse {
+        Exceptions: Exceptions;
+        Type: string;
+        Cluster: string;
+        RoxieCluster: string;
+        Owner: string;
+        State: string;
+        StartDate: string;
+        EndDate: string;
+        ECL: string;
+        Jobname: string;
+        LogicalFile: string;
+        LogicalFileSearchType: string;
+        Current: string;
+        Next: string;
+        Count: int;
+        PageSize: long;
+        PrevPage: long;
+        NextPage: long;
+        LastPage: long;
+        NumWUs: int;
+        First: boolean;
+        PageStartFrom: long;
+        PageEndAt: long;
+        Sortby: string;
+        Descending: boolean;
+        BasicQuery: string;
+        Filters: string;
+        CacheHint: long;
+        Workunits: Workunits;
+    }
+    interface WUQueryConfig {
+        Target: string;
+        QueryId: string;
+        Wait: int;
+        NoReload: boolean;
+        memoryLimit: string;
+        TimeLimit: nonNegativeInteger;
+        WarnTimeLimit: nonNegativeInteger;
+        Priority: string;
+        Comment: string;
+    }
+    interface WUQueryConfigResponse {
+        Exceptions: Exceptions;
+        ReloadFailed: boolean;
+        Results: Results;
+    }
+    interface WUQueryDetails {
+        QueryId: string;
+        QuerySet: string;
+        IncludeStateOnClusters: boolean;
+        IncludeSuperFiles: boolean;
+        IncludeWsEclAddresses: boolean;
+        CheckAllNodes: boolean;
+        IncludeWUDetails: boolean;
+        IncludeWUQueryFiles: boolean;
+    }
+    interface LogicalFiles {
+        Item: string[];
+    }
+    interface SubFiles {
+        File: string[];
+    }
+    interface SuperFile {
+        Name: string;
+        SubFiles: {
+            File: string[];
+        };
+        SuperFiles: SuperFiles;
+    }
+    interface SuperFiles {
+        SuperFile: SuperFile[];
+    }
+    interface LibrariesUsed {
+        Item: string[];
+    }
+    interface WsEclAddresses {
+        Address: string[];
+    }
+    interface WUGraphs {
+        ECLGraph: ECLGraph[];
+    }
+    interface WUTimers {
+        ECLTimer: ECLTimer[];
+    }
+    interface WUQueryDetailsResponse {
+        Exceptions: Exceptions;
+        QueryId: string;
+        QuerySet: string;
+        QueryName: string;
+        Wuid: string;
+        Dll: string;
+        Suspended: boolean;
+        Activated: boolean;
+        SuspendedBy: string;
+        Clusters: Clusters;
+        PublishedBy: string;
+        Comment: string;
+        LogicalFiles: {
+            Item: string[];
+        };
+        SuperFiles: {
+            SuperFile: SuperFile[];
+        };
+        IsLibrary: boolean;
+        Priority: string;
+        PriorityID: int;
+        WUSnapShot: string;
+        CompileTime: string;
+        LibrariesUsed: {
+            Item: string[];
+        };
+        CountGraphs: int;
+        ResourceURLCount: int;
+        WsEclAddresses: {
+            Address: string[];
+        };
+        WUGraphs: {
+            ECLGraph: ECLGraph[];
+        };
+        WUTimers: {
+            ECLTimer: ECLTimer[];
+        };
+    }
+    interface WUQueryDetailsLightWeight {
+        QueryId: string;
+        QuerySet: string;
+        IncludeWUDetails: boolean;
+        IncludeWUQueryFiles: boolean;
+        IncludeSuperFiles: boolean;
+        IncludeWsEclAddresses: boolean;
+        IncludeStateOnClusters: boolean;
+        CheckAllNodes: boolean;
+    }
+    interface WUQueryFiles {
+        Target: string;
+        QueryId: string;
+    }
+    interface WUQueryFilesResponse {
+        Exceptions: Exceptions;
+        Files: Files;
+        SuperFiles: SuperFiles;
+        Queries: Queries;
+    }
+    interface WUQueryGetGraph {
+        Target: string;
+        QueryId: string;
+        GraphName: string;
+        SubGraphId: string;
+    }
+    interface WUQueryGetGraphResponse {
+        Exceptions: Exceptions;
+        Graphs: Graphs;
+    }
+    interface WUQueryGetSummaryStats {
+        Target: string;
+        QueryId: string;
+        FromTime: string;
+        ToTime: string;
+        IncludeRawStats: boolean;
+    }
+    interface QuerySummaryStats {
+        Endpoint: string;
+        Status: string;
+        StartTime: string;
+        EndTime: string;
+        CountTotal: int;
+        CountFailed: int;
+        AverageSlavesReplyLen: int;
+        AverageBytesOut: long;
+        SizeAvgPeakMemory: long;
+        TimeAvgTotalExecuteMinutes: long;
+        TimeMinTotalExecuteMinutes: long;
+        TimeMaxTotalExecuteMinutes: long;
+        Percentile97: long;
+        Percentile97Estimate: boolean;
+    }
+    interface StatsList {
+        QuerySummaryStats: QuerySummaryStats[];
+    }
+    interface EndpointQueryStats {
+        Endpoint: string;
+        Status: string;
+        QueryStatsList: QueryStatsList;
+    }
+    interface QueryStatsList {
+        EndpointQueryStats: EndpointQueryStats[];
+    }
+    interface WUQueryGetSummaryStatsResponse {
+        Exceptions: Exceptions;
+        StatsList: {
+            QuerySummaryStats: QuerySummaryStats[];
+        };
+        QueryStatsList: {
+            EndpointQueryStats: EndpointQueryStats[];
+        };
+    }
+    interface WUQuerysetAliasAction {
+        Action: QuerySetAliasActionTypes;
+        QuerySetName: string;
+        Aliases: Aliases;
+    }
+    interface WUQuerySetAliasActionResponse {
+        Exceptions: Exceptions;
+        Action: QuerySetAliasActionTypes;
+        QuerySetName: string;
+        Results: Results;
+    }
+    interface WUQuerysetCopyQuery {
+        Source: string;
+        Target: string;
+        Cluster: string;
+        DaliServer: string;
+        Activate: int;
+        Overwrite: boolean;
+        DontCopyFiles: boolean;
+        Wait: int;
+        NoReload: boolean;
+        memoryLimit: string;
+        TimeLimit: nonNegativeInteger;
+        WarnTimeLimit: nonNegativeInteger;
+        priority: string;
+        Comment: string;
+        SourceProcess: string;
+        DestName: string;
+        AllowForeignFiles: boolean;
+        UpdateSuperFiles: boolean;
+        UpdateCloneFrom: boolean;
+        AppendCluster: boolean;
+        IncludeFileErrors: boolean;
+        SourceSSL: boolean;
+        DfuCopyFiles: boolean;
+        DfuQueue: string;
+        DfuWait: nonNegativeInteger;
+        DfuOverwrite: boolean;
+        OnlyCopyFiles: boolean;
+        StopIfFilesCopied: boolean;
+        DfuPublisherWuid: string;
+        RemoteStorage: string;
+    }
+    interface WUQuerySetCopyQueryResponse {
+        Exceptions: Exceptions;
+        QueryId: string;
+        FileErrors: FileErrors;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+    interface WUQuerysetDetails {
+        QuerySetName: string;
+        Filter: string;
+        ClusterName: string;
+        FilterType: WUQuerySetFilterType;
+        CheckAllNodes: boolean;
+    }
+    interface QuerysetAliases {
+        QuerySetAlias: QuerySetAlias[];
+    }
+    interface ClusterNames {
+        Item: string[];
+    }
+    interface WUQuerySetDetailsResponse {
+        Exceptions: Exceptions;
+        QuerySetName: string;
+        QuerysetQueries: QuerysetQueries;
+        QuerysetAliases: {
+            QuerySetAlias: QuerySetAlias[];
+        };
+        ClusterName: string;
+        Filter: string;
+        FilterType: WUQuerySetFilterType;
+        ClusterNames: {
+            Item: string[];
+        };
+    }
+    interface WUQuerysetExport {
+        Target: string;
+        Compress: boolean;
+        ActiveOnly: boolean;
+        Protect: boolean;
+    }
+    interface WUQuerysetExportResponse {
+        Exceptions: Exceptions;
+        Target: string;
+        Compressed: boolean;
+        Data: base64Binary;
+    }
+    interface WUQuerysetImport {
+        Target: string;
+        QueryMask: string;
+        Replace: boolean;
+        ActiveOnly: boolean;
+        Activation: QuerysetImportActivation;
+        Compressed: boolean;
+        Data: base64Binary;
+        AllowForeignFiles: boolean;
+        DfsServer: string;
+        CopyFiles: boolean;
+        OverwriteDfs: boolean;
+        SourceProcess: string;
+        UpdateSuperFiles: boolean;
+        UpdateCloneFrom: boolean;
+        AppendCluster: boolean;
+        IncludeFileErrors: boolean;
+        DfuCopyFiles: boolean;
+        DfuQueue: string;
+        DfuWait: nonNegativeInteger;
+        DfuOverwrite: boolean;
+        OnlyCopyFiles: boolean;
+        StopIfFilesCopied: boolean;
+        DfuPublisherWuid: string;
+        RemoteStorage: string;
+    }
+    interface ImportedQueries {
+        QueryId: string[];
+    }
+    interface MissingWuids {
+        QueryId: string[];
+    }
+    interface WUQuerysetImportResponse {
+        Exceptions: Exceptions;
+        Target: string;
+        ClearedExisting: boolean;
+        Success: boolean;
+        ImportedQueries: {
+            QueryId: string[];
+        };
+        ExistingQueries: ExistingQueries;
+        MissingWuids: {
+            QueryId: string[];
+        };
+        FileErrors: FileErrors;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+    interface WUQuerysetQueryAction {
+        Action: QuerySetQueryActionTypes;
+        QuerySetName: string;
+        Queries: Queries;
+    }
+    interface WUQuerySetQueryActionResponse {
+        Exceptions: Exceptions;
+        Action: QuerySetQueryActionTypes;
+        QuerySetName: string;
+        Results: Results;
+    }
+    interface WUQuerysets {
+        test: boolean;
+    }
+    interface WUQuerysetsResponse {
+        Exceptions: Exceptions;
+        Querysets: Querysets;
+    }
+    interface WURecreateQuery {
+        Target: string;
+        QueryId: string;
+        DebugValues: DebugValues;
+        DestTarget: string;
+        Republish: boolean;
+        Activate: WUQueryActivationMode;
+        NoReload: boolean;
+        MemoryLimit: string;
+        TimeLimit: nonNegativeInteger;
+        WarnTimeLimit: nonNegativeInteger;
+        Priority: string;
+        Comment: string;
+        RemoteDali: string;
+        DontCopyFiles: boolean;
+        SourceProcess: string;
+        AllowForeignFiles: boolean;
+        UpdateDfs: boolean;
+        UpdateSuperFiles: boolean;
+        UpdateCloneFrom: boolean;
+        AppendCluster: boolean;
+        IncludeFileErrors: boolean;
+        Wait: int;
+        DfuCopyFiles: boolean;
+        DfuQueue: string;
+        DfuWait: nonNegativeInteger;
+        DfuOverwrite: boolean;
+        OnlyCopyFiles: boolean;
+        StopIfFilesCopied: boolean;
+        DfuPublisherWuid: string;
+        RemoteStorage: string;
+    }
+    interface WURecreateQueryResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        QuerySet: string;
+        QueryName: string;
+        QueryId: string;
+        MemoryLimit: string;
+        TimeLimit: nonNegativeInteger;
+        WarnTimeLimit: nonNegativeInteger;
+        Priority: string;
+        Comment: string;
+        ReloadFailed: boolean;
+        Suspended: boolean;
+        ErrorMessage: string;
+        FileErrors: FileErrors;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+    interface WUResubmit {
+        Wuids: Wuids;
+        BlockTillFinishTimer: int;
+        ResetWorkflow: boolean;
+        CloneWorkunit: boolean;
+    }
+    interface WU {
+        WUID: string;
+        ParentWUID: string;
+    }
+    interface WUs {
+        WU: WU[];
+    }
+    interface WUResubmitResponse {
+        Exceptions: Exceptions;
+        WUs: {
+            WU: WU[];
+        };
+    }
+    interface NamedValue {
+        Name: string;
+        Value: string;
+    }
+    interface FilterBy {
+        NamedValue: NamedValue[];
+    }
+    interface WUResult {
+        Wuid: string;
+        Sequence: int;
+        ResultName: string;
+        LogicalName: string;
+        Cluster: string;
+        SuppressXmlSchema: boolean;
+        BypassCachedResult: boolean;
+        FilterBy: {
+            NamedValue: NamedValue[];
+        };
+        Start: long;
+        Count: int;
+    }
+    interface WUResultResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Sequence: int;
+        LogicalName: string;
+        Cluster: string;
+        Name: string;
+        Start: long;
+        Requested: int;
+        Count: int;
+        Total: long;
+        Result: string;
+    }
+    interface WUResultBin {
+        LogicalName: string;
+        Wuid: string;
+        ResultName: string;
+        Sequence: int;
+        Format: string;
+        Cluster: string;
+        FilterBy: FilterBy;
+        Start: long;
+        Count: int;
+    }
+    interface WUResultBinResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Sequence: int;
+        Name: string;
+        Start: long;
+        Count: int;
+        Requested: int;
+        Total: long;
+        Result: base64Binary;
+        Format: string;
+    }
+    interface WUResultSummary {
+        Wuid: string;
+        Sequence: int;
+    }
+    interface Result {
+        Name: string;
+        Sequence: int;
+        Value: string;
+        Link: string;
+        FileName: string;
+        IsSupplied: boolean;
+        ShowFileContent: boolean;
+        Total: long;
+        ECLSchemas: ECLSchemas;
+        XmlSchema: string;
+    }
+    interface WUResultSummaryResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        Sequence: int;
+        Format: int;
+        Result: {
+            Name: string;
+            Sequence: int;
+            Value: string;
+            Link: string;
+            FileName: string;
+            IsSupplied: boolean;
+            ShowFileContent: boolean;
+            Total: long;
+            ECLSchemas: ECLSchemas;
+            XmlSchema: string;
+        };
+    }
+    interface WUResultView {
+        Wuid: string;
+        ViewName: string;
+        Sequence: int;
+        ResultName: string;
+    }
+    interface WUResultViewResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        ViewName: string;
+        Result: string;
+    }
+    interface WURun {
+        QuerySet: string;
+        Query: string;
+        Wuid: string;
+        CloneWorkunit: boolean;
+        Cluster: string;
+        Wait: int;
+        Input: string;
+        NoRootTag: boolean;
+        DebugValues: DebugValues;
+        Variables: Variables;
+        ApplicationValues: ApplicationValues;
+        ExceptionSeverity: WUExceptionSeverity;
+    }
+    interface WURunResponse {
+        Exceptions: Exceptions;
+        Wuid: string;
+        State: string;
+        Results: string;
+    }
+    interface WUSchedule {
+        Wuid: string;
+        Cluster: string;
+        Queue: string;
+        Snapshot: string;
+        When: dateTime;
+        MaxRunTime: int;
+    }
+    interface WUScheduleResponse {
+        Exceptions: Exceptions;
+    }
+    interface WUShowScheduled {
+        Cluster: string;
+        EventName: string;
+        PushEventName: string;
+        PushEventText: string;
+        State: string;
+        JobName: string;
+        Owner: string;
+        EventText: string;
+    }
+    interface WUShowScheduledResponse {
+        Exceptions: Exceptions;
+        ClusterSelected: int;
+        EventName: string;
+        PushEventName: string;
+        PushEventText: string;
+        Query: string;
+        Clusters: Clusters;
+        Workunits: Workunits;
+    }
+    interface WUSubmit {
+        Wuid: string;
+        Cluster: string;
+        Queue: string;
+        Snapshot: string;
+        MaxRunTime: int;
+        MaxCost: int;
+        BlockTillFinishTimer: int;
+        SyntaxCheck: boolean;
+        NotifyCluster: boolean;
+    }
+    interface WUSubmitResponse {
+        Exceptions: Exceptions;
+    }
+    interface WUSyntaxCheckECL {
+        ECL: string;
+        ModuleName: string;
+        AttributeName: string;
+        Queue: string;
+        Cluster: string;
+        Snapshot: string;
+        TimeToWait: int;
+        PersistWorkunit: boolean;
+        DebugValues: DebugValues;
+    }
+    interface WUSyntaxCheckResponse {
+        Exceptions: Exceptions;
+        Errors: Errors;
+        Message: string;
+    }
+    interface WUUpdate {
+        Wuid: string;
+        State: int;
+        StateOrig: int;
+        Jobname: string;
+        JobnameOrig: string;
+        QueryText: string;
+        Action: int;
+        Description: string;
+        DescriptionOrig: string;
+        AddDrilldownFields: boolean;
+        ResultLimit: int;
+        Protected: boolean;
+        ProtectedOrig: boolean;
+        PriorityClass: int;
+        PriorityLevel: int;
+        Scope: string;
+        ScopeOrig: string;
+        ClusterSelection: string;
+        ClusterOrig: string;
+        XmlParams: string;
+        ThorSlaveIP: string;
+        QueryMainDefinition: string;
+        DebugValues: DebugValues;
+        ApplicationValues: ApplicationValues;
+    }
+    interface WUUpdateQueryEntry {
+        QuerySet: string;
+        QueryId: string;
+        Comment: string;
+    }
+    interface WUUpdateQueryEntryResponse {
+        Exceptions: Exceptions;
+    }
+    interface WUWaitCompiled {
+        Wuid: string;
+        Wait: int;
+        ReturnOnWait: boolean;
+    }
+    interface WUWaitResponse {
+        Exceptions: Exceptions;
+        StateID: int;
+    }
+    interface WUWaitComplete {
+        Wuid: string;
+        Wait: int;
+        ReturnOnWait: boolean;
+    }
+}
+export declare class WorkunitsServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    GVCAjaxGraph(request: WsWorkunits.GVCAjaxGraph): Promise<WsWorkunits.GVCAjaxGraphResponse>;
+    Ping(request: WsWorkunits.Ping): Promise<WsWorkunits.WsWorkunitsPingResponse>;
+    WUAbort(request: WsWorkunits.WUAbort): Promise<WsWorkunits.WUAbortResponse>;
+    WUAction(request: WsWorkunits.WUAction): Promise<WsWorkunits.WUActionResponse>;
+    WUAddLocalFileToWorkunit(request: WsWorkunits.WUAddLocalFileToWorkunit): Promise<WsWorkunits.WUAddLocalFileToWorkunitResponse>;
+    WUAnalyseHotspot(request: WsWorkunits.WUAnalyseHotspot): Promise<WsWorkunits.WUAnalyseHotspotResponse>;
+    WUCDebug(request: WsWorkunits.WUCDebug): Promise<WsWorkunits.WUDebugResponse>;
+    WUCheckFeatures(request: WsWorkunits.WUCheckFeatures): Promise<WsWorkunits.WUCheckFeaturesResponse>;
+    WUClusterJobQueueLOG(request: WsWorkunits.WUClusterJobQueueLOG): Promise<WsWorkunits.WUClusterJobQueueLOGResponse>;
+    WUClusterJobQueueXLS(request: WsWorkunits.WUClusterJobQueueXLS): Promise<WsWorkunits.WUClusterJobQueueXLSResponse>;
+    WUClusterJobSummaryXLS(request: WsWorkunits.WUClusterJobSummaryXLS): Promise<WsWorkunits.WUClusterJobSummaryXLSResponse>;
+    WUClusterJobXLS(request: WsWorkunits.WUClusterJobXLS): Promise<WsWorkunits.WUClusterJobXLSResponse>;
+    WUCompileECL(request: WsWorkunits.WUCompileECL): Promise<WsWorkunits.WUCompileECLResponse>;
+    WUCopyLogicalFiles(request: WsWorkunits.WUCopyLogicalFiles): Promise<WsWorkunits.WUCopyLogicalFilesResponse>;
+    WUCopyQuerySet(request: WsWorkunits.WUCopyQuerySet): Promise<WsWorkunits.WUCopyQuerySetResponse>;
+    WUCreate(request: WsWorkunits.WUCreate): Promise<WsWorkunits.WUCreateResponse>;
+    WUCreateAndUpdate(request: WsWorkunits.WUCreateAndUpdate): Promise<WsWorkunits.WUUpdateResponse>;
+    WUCreateZAPInfo(request: WsWorkunits.WUCreateZAPInfo): Promise<WsWorkunits.WUCreateZAPInfoResponse>;
+    WUDelete(request: WsWorkunits.WUDelete): Promise<WsWorkunits.WUDeleteResponse>;
+    WUDeployWorkunit(request: WsWorkunits.WUDeployWorkunit): Promise<WsWorkunits.WUDeployWorkunitResponse>;
+    WUDetails(request: WsWorkunits.WUDetails): Promise<WsWorkunits.WUDetailsResponse>;
+    WUDetailsMeta(request: WsWorkunits.WUDetailsMeta): Promise<WsWorkunits.WUDetailsMetaResponse>;
+    WUEclDefinitionAction(request: WsWorkunits.WUEclDefinitionAction): Promise<WsWorkunits.WUEclDefinitionActionResponse>;
+    WUExport(request: WsWorkunits.WUExport): Promise<WsWorkunits.WUExportResponse>;
+    WUFile(request: WsWorkunits.WUFile): Promise<WsWorkunits.WULogFileResponse>;
+    WUFullResult(request: WsWorkunits.WUFullResult): Promise<WsWorkunits.WUFullResultResponse>;
+    WUGVCGraphInfo(request: WsWorkunits.WUGVCGraphInfo): Promise<WsWorkunits.WUGVCGraphInfoResponse>;
+    WUGetArchiveFile(request: WsWorkunits.WUGetArchiveFile): Promise<WsWorkunits.WUGetArchiveFileResponse>;
+    WUGetDependancyTrees(request: WsWorkunits.WUGetDependancyTrees): Promise<WsWorkunits.WUGetDependancyTreesResponse>;
+    WUGetGraph(request: WsWorkunits.WUGetGraph): Promise<WsWorkunits.WUGetGraphResponse>;
+    WUGetGraphNameAndTypes(request: WsWorkunits.WUGetGraphNameAndTypes): Promise<WsWorkunits.WUGetGraphNameAndTypesResponse>;
+    WUGetNumFileToCopy(request: WsWorkunits.WUGetNumFileToCopy): Promise<WsWorkunits.WUGetNumFileToCopyResponse>;
+    WUGetPlugins(request: WsWorkunits.WUGetPlugins): Promise<WsWorkunits.WUGetPluginsResponse>;
+    WUGetStats(request: WsWorkunits.WUGetStats): Promise<WsWorkunits.WUGetStatsResponse>;
+    WUGetThorJobList(request: WsWorkunits.WUGetThorJobList): Promise<WsWorkunits.WUGetThorJobListResponse>;
+    WUGetThorJobQueue(request: WsWorkunits.WUGetThorJobQueue): Promise<WsWorkunits.WUGetThorJobQueueResponse>;
+    WUGetZAPInfo(request: WsWorkunits.WUGetZAPInfo): Promise<WsWorkunits.WUGetZAPInfoResponse>;
+    WUGraphInfo(request: WsWorkunits.WUGraphInfo): Promise<WsWorkunits.WUGraphInfoResponse>;
+    WUGraphTiming(request: WsWorkunits.WUGraphTiming): Promise<WsWorkunits.WUGraphTimingResponse>;
+    WUInfo(request: WsWorkunits.WUInfo): Promise<WsWorkunits.WUInfoResponse>;
+    WUInfoDetails(request: WsWorkunits.WUInfoDetails): Promise<WsWorkunits.WUInfoResponse>;
+    WUJobList(request: WsWorkunits.WUJobList): Promise<WsWorkunits.WUJobListResponse>;
+    WULightWeightQuery(request: WsWorkunits.WULightWeightQuery): Promise<WsWorkunits.WULightWeightQueryResponse>;
+    WUListArchiveFiles(request: WsWorkunits.WUListArchiveFiles): Promise<WsWorkunits.WUListArchiveFilesResponse>;
+    WUListLocalFileRequired(request: WsWorkunits.WUListLocalFileRequired): Promise<WsWorkunits.WUListLocalFileRequiredResponse>;
+    WUListQueries(request: WsWorkunits.WUListQueries): Promise<WsWorkunits.WUListQueriesResponse>;
+    WUListQueriesUsingFile(request: WsWorkunits.WUListQueriesUsingFile): Promise<WsWorkunits.WUListQueriesUsingFileResponse>;
+    WUMultiQuerysetDetails(request: WsWorkunits.WUMultiQuerysetDetails): Promise<WsWorkunits.WUMultiQuerySetDetailsResponse>;
+    WUProcessGraph(request: WsWorkunits.WUProcessGraph): Promise<WsWorkunits.WUProcessGraphResponse>;
+    WUProtect(request: WsWorkunits.WUProtect): Promise<WsWorkunits.WUProtectResponse>;
+    WUPublishWorkunit(request: WsWorkunits.WUPublishWorkunit): Promise<WsWorkunits.WUPublishWorkunitResponse>;
+    WUPushEvent(request: WsWorkunits.WUPushEvent): Promise<WsWorkunits.WUPushEventResponse>;
+    WUQuery(request: WsWorkunits.WUQuery): Promise<WsWorkunits.WUQueryResponse>;
+    WUQueryConfig(request: WsWorkunits.WUQueryConfig): Promise<WsWorkunits.WUQueryConfigResponse>;
+    WUQueryDetails(request: WsWorkunits.WUQueryDetails): Promise<WsWorkunits.WUQueryDetailsResponse>;
+    WUQueryDetailsLightWeight(request: WsWorkunits.WUQueryDetailsLightWeight): Promise<WsWorkunits.WUQueryDetailsResponse>;
+    WUQueryFiles(request: WsWorkunits.WUQueryFiles): Promise<WsWorkunits.WUQueryFilesResponse>;
+    WUQueryGetGraph(request: WsWorkunits.WUQueryGetGraph): Promise<WsWorkunits.WUQueryGetGraphResponse>;
+    WUQueryGetSummaryStats(request: WsWorkunits.WUQueryGetSummaryStats): Promise<WsWorkunits.WUQueryGetSummaryStatsResponse>;
+    WUQuerysetAliasAction(request: WsWorkunits.WUQuerysetAliasAction): Promise<WsWorkunits.WUQuerySetAliasActionResponse>;
+    WUQuerysetCopyQuery(request: WsWorkunits.WUQuerysetCopyQuery): Promise<WsWorkunits.WUQuerySetCopyQueryResponse>;
+    WUQuerysetDetails(request: WsWorkunits.WUQuerysetDetails): Promise<WsWorkunits.WUQuerySetDetailsResponse>;
+    WUQuerysetExport(request: WsWorkunits.WUQuerysetExport): Promise<WsWorkunits.WUQuerysetExportResponse>;
+    WUQuerysetImport(request: WsWorkunits.WUQuerysetImport): Promise<WsWorkunits.WUQuerysetImportResponse>;
+    WUQuerysetQueryAction(request: WsWorkunits.WUQuerysetQueryAction): Promise<WsWorkunits.WUQuerySetQueryActionResponse>;
+    WUQuerysets(request: WsWorkunits.WUQuerysets): Promise<WsWorkunits.WUQuerysetsResponse>;
+    WURecreateQuery(request: WsWorkunits.WURecreateQuery): Promise<WsWorkunits.WURecreateQueryResponse>;
+    WUResubmit(request: WsWorkunits.WUResubmit): Promise<WsWorkunits.WUResubmitResponse>;
+    WUResult(request: WsWorkunits.WUResult): Promise<WsWorkunits.WUResultResponse>;
+    WUResultBin(request: WsWorkunits.WUResultBin): Promise<WsWorkunits.WUResultBinResponse>;
+    WUResultSummary(request: WsWorkunits.WUResultSummary): Promise<WsWorkunits.WUResultSummaryResponse>;
+    WUResultView(request: WsWorkunits.WUResultView): Promise<WsWorkunits.WUResultViewResponse>;
+    WURun(request: WsWorkunits.WURun): Promise<WsWorkunits.WURunResponse>;
+    WUSchedule(request: WsWorkunits.WUSchedule): Promise<WsWorkunits.WUScheduleResponse>;
+    WUShowScheduled(request: WsWorkunits.WUShowScheduled): Promise<WsWorkunits.WUShowScheduledResponse>;
+    WUSubmit(request: WsWorkunits.WUSubmit): Promise<WsWorkunits.WUSubmitResponse>;
+    WUSyntaxCheckECL(request: WsWorkunits.WUSyntaxCheckECL): Promise<WsWorkunits.WUSyntaxCheckResponse>;
+    WUUpdate(request: WsWorkunits.WUUpdate): Promise<WsWorkunits.WUUpdateResponse>;
+    WUUpdateQueryEntry(request: WsWorkunits.WUUpdateQueryEntry): Promise<WsWorkunits.WUUpdateQueryEntryResponse>;
+    WUWaitCompiled(request: WsWorkunits.WUWaitCompiled): Promise<WsWorkunits.WUWaitResponse>;
+    WUWaitComplete(request: WsWorkunits.WUWaitComplete): Promise<WsWorkunits.WUWaitResponse>;
+}
+//# sourceMappingURL=WsWorkunits.d.ts.map