@hpcc-js/comms 3.15.4 → 3.15.6

package/types/services/wsdl/WsWorkunits/v2.05/WsWorkunits.d.ts

@@ -0,0 +1,2571 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+export declare namespace WsWorkunits {
+    type int = number;
+    type double = number;
+    type long = number;
+    type nonNegativeInteger = number;
+    type uint64 = 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 WUDetailsAttrValueType {
+        Single = "Single",
+        List = "List",
+        Multi = "Multi"
+    }
+    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 = "All queries",
+        Notsuspended = "Not suspended",
+        Suspended = "Suspended",
+        Suspendedbyuser = "Suspended by user",
+        Suspendedbyfirstnode = "Suspended by first node",
+        Suspendedbyanynode = "Suspended by any node"
+    }
+    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?: Wuids;
+        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?: Exceptions;
+        ActionResults?: ActionResults;
+    }
+    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?: PropertyOptions;
+    }
+    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;
+        Id?: uint64;
+    }
+    interface Notes {
+        Note?: Note[];
+    }
+    interface Activity {
+        ScopeName?: string;
+        Id?: string;
+        ScopeType?: string;
+        Properties?: Properties;
+        Notes?: Notes;
+        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?: Activities;
+        Dependencies?: Dependencies;
+    }
+    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?: Deployment;
+        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 {
+        Severity?: string;
+        Source?: string;
+        Code?: int;
+        Message?: string;
+        Column?: int;
+        LineNo?: int;
+        FileName?: string;
+        Activity?: int;
+        Scope?: string;
+        Priority?: int;
+        Cost?: double;
+    }
+    interface Errors {
+        ECLException?: ECLException[];
+    }
+    interface ECLAttribute {
+        ModuleName?: string;
+        AttributeName?: string;
+        IsLocked?: boolean;
+        IsCheckedOut?: boolean;
+        IsSandbox?: boolean;
+        IsOrphaned?: boolean;
+    }
+    interface Dependencies2 {
+        ECLAttribute?: ECLAttribute[];
+    }
+    interface WUCompileECLResponse {
+        Exceptions?: Exceptions;
+        Complexity?: string;
+        Errors?: Errors;
+        Dependencies?: Dependencies2;
+    }
+    interface WUCopyLogicalFiles {
+        Wuid?: string;
+        Cluster?: string;
+        CopyLocal?: boolean;
+    }
+    interface Clusters {
+        Item?: string[];
+    }
+    interface WULogicalFileCopyInfo {
+        IsIndex?: boolean;
+        LogicalName?: string;
+        DfuCopyWuid?: string;
+        DfuCopyError?: string;
+        Clusters?: Clusters;
+    }
+    interface OnCluster {
+        WULogicalFileCopyInfo?: WULogicalFileCopyInfo[];
+    }
+    interface NotOnCluster {
+        WULogicalFileCopyInfo?: WULogicalFileCopyInfo[];
+    }
+    interface Foreign {
+        WULogicalFileCopyInfo?: WULogicalFileCopyInfo[];
+    }
+    interface NotFound {
+        WULogicalFileCopyInfo?: WULogicalFileCopyInfo[];
+    }
+    interface Cluster {
+        ClusterName?: string;
+        OnCluster?: OnCluster;
+        NotOnCluster?: NotOnCluster;
+        Foreign?: Foreign;
+        NotFound?: NotFound;
+    }
+    interface ClusterFiles {
+        Cluster?: Cluster[];
+    }
+    interface WUCopyLogicalFilesResponse {
+        Exceptions?: Exceptions;
+        Wuid?: string;
+        ClusterFiles?: ClusterFiles;
+    }
+    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;
+        KeyCompression?: string;
+        DfuTargetPlane?: string;
+    }
+    interface CopiedQueries {
+        QueryId?: string[];
+    }
+    interface ExistingQueries {
+        QueryId?: string[];
+    }
+    interface File {
+        Error?: string;
+        LogicalName?: string;
+    }
+    interface FileErrors {
+        File?: File[];
+    }
+    interface WUCopyQuerySetResponse {
+        Exceptions?: Exceptions;
+        CopiedQueries?: CopiedQueries;
+        ExistingQueries?: ExistingQueries;
+        FileErrors?: FileErrors;
+        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 Exceptions2 {
+        ECLException?: ECLException[];
+    }
+    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?: ECLSourceFiles;
+    }
+    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?: ECLSchemas;
+        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 Graphs2 {
+        Graph?: string[];
+    }
+    interface ECLWUProcess {
+        Name?: string;
+        Type?: string;
+        PodName?: string;
+        ContainerName?: string;
+        Graphs?: Graphs2;
+        InstanceNumber?: int;
+        Sequence?: string;
+        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?: Query;
+        Helpers?: Helpers;
+        Exceptions?: Exceptions2;
+        Graphs?: Graphs;
+        SourceFiles?: SourceFiles;
+        Results?: Results;
+        Variables?: Variables;
+        Timers?: Timers;
+        DebugValues?: DebugValues;
+        ApplicationValues?: ApplicationValues;
+        Workflows?: Workflows;
+        TimingData?: TimingData;
+        AllowedClusters?: AllowedClusters;
+        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?: ThorLogList;
+        ResourceURLs?: ResourceURLs;
+        ResultViewCount?: int;
+        ResourceURLCount?: int;
+        DebugValueCount?: int;
+        WorkflowCount?: int;
+        HelpersCount?: int;
+        ServiceNames?: ServiceNames;
+        ExecuteCost?: double;
+        FileAccessCost?: double;
+        CostSavingPotential?: double;
+        CompileCost?: double;
+        NoAccess?: boolean;
+        ECLWUProcessList?: ECLWUProcessList;
+    }
+    interface WUCreateResponse {
+        Exceptions?: Exceptions;
+        Workunit?: Workunit;
+    }
+    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?: AbsoluteTimeRange;
+        RelativeTimeRangeBuffer?: unsignedInt;
+        LineLimit?: unsignedInt;
+        LineStartFrom?: long;
+        SelectColumnMode?: LogSelectColumnMode;
+        CustomColumns?: CustomColumns;
+        ComponentsFilter?: ComponentsFilter;
+        Format?: string;
+        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?: LogFilter;
+        IncludeRelatedLogs?: boolean;
+        IncludePerComponentLogs?: boolean;
+    }
+    interface WUCreateZAPInfoResponse {
+        Exceptions?: Exceptions;
+        thefile?: base64Binary;
+        ZAPFileName?: string;
+    }
+    interface WUDelete {
+        Wuids?: Wuids;
+        BlockTillFinishTimer?: int;
+    }
+    interface WUDeleteResponse {
+        Exceptions?: Exceptions;
+        ActionResults?: ActionResults;
+    }
+    interface NamedValue {
+        Name?: string;
+        Value?: string;
+    }
+    interface DebugValues2 {
+        NamedValue?: NamedValue[];
+    }
+    interface WUDeployWorkunit {
+        Cluster?: string;
+        Name?: string;
+        Wait?: int;
+        ObjType?: string;
+        FileName?: string;
+        Object?: base64Binary;
+        ResultLimit?: int;
+        QueryMainDefinition?: string;
+        Snapshot?: string;
+        DebugValues?: DebugValues2;
+        Protect?: boolean;
+    }
+    interface WUDeployWorkunitResponse {
+        Exceptions?: Exceptions;
+        Workunit?: Workunit;
+    }
+    interface PropertyFilter {
+        Name?: string;
+        ExactValue?: string;
+        MinValue?: string;
+        MaxValue?: string;
+    }
+    interface PropertyFilters {
+        PropertyFilter?: PropertyFilter[];
+    }
+    interface ScopeFilter {
+        MaxDepth?: integer;
+        Scopes?: string[];
+        Ids?: string[];
+        ScopeTypes?: string[];
+        PropertyFilters?: PropertyFilters;
+    }
+    interface NestedFilter {
+        Depth?: unsignedInt;
+        ScopeTypes?: string[];
+    }
+    interface Extra {
+        scopeType?: string;
+        Properties?: string[];
+    }
+    interface ExtraProperties {
+        Extra?: Extra[];
+    }
+    interface PropertiesToReturn {
+        AllStatistics?: boolean;
+        AllAttributes?: boolean;
+        AllHints?: boolean;
+        AllScopes?: boolean;
+        AllProperties?: boolean;
+        AllNotes?: boolean;
+        MinVersion?: uint64;
+        Measure?: string;
+        Properties?: string[];
+        ExtraProperties?: ExtraProperties;
+    }
+    interface ScopeOptions {
+        IncludeMatchedScopesInResults?: boolean;
+        IncludeScope?: boolean;
+        IncludeId?: boolean;
+        IncludeScopeType?: boolean;
+    }
+    interface WUDetails {
+        WUID?: string;
+        ScopeFilter?: ScopeFilter;
+        NestedFilter?: NestedFilter;
+        PropertiesToReturn?: PropertiesToReturn;
+        Filter?: string;
+        ScopeOptions?: ScopeOptions;
+        PropertyOptions?: PropertyOptions;
+    }
+    interface Scope {
+        ScopeName?: string;
+        Id?: string;
+        ScopeType?: string;
+        Properties?: Properties;
+        Notes?: Notes;
+        SinkActivity?: string;
+    }
+    interface Scopes {
+        Scope?: Scope[];
+    }
+    interface WUDetailsResponse {
+        Exceptions?: Exceptions;
+        MaxVersion?: uint64;
+        WUID?: string;
+        Scopes?: Scopes;
+    }
+    interface WUDetailsMeta {
+    }
+    interface Property2 {
+        Name?: string;
+        ValueType?: WUDetailsAttrValueType;
+        Description?: string;
+    }
+    interface Properties2 {
+        Property?: Property2[];
+    }
+    interface ScopeTypes {
+        ScopeType?: string[];
+    }
+    interface Measures {
+        Measure?: string[];
+    }
+    interface Activity2 {
+        Kind?: unsignedInt;
+        Name?: string;
+        IsSink?: boolean;
+        IsSource?: boolean;
+    }
+    interface Activities2 {
+        Activity?: Activity2[];
+    }
+    interface WUDetailsMetaResponse {
+        Exceptions?: Exceptions;
+        Properties?: Properties2;
+        ScopeTypes?: ScopeTypes;
+        Measures?: Measures;
+        Activities?: Activities2;
+    }
+    interface EclDefinitions {
+        Item?: string[];
+    }
+    interface WUEclDefinitionAction {
+        EclDefinitions?: EclDefinitions;
+        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;
+        DfuTargetPlane?: string;
+    }
+    interface WUEclDefinitionActionResult {
+        EclDefinition?: string;
+        Action?: string;
+        WUID?: string;
+        QueryID?: string;
+        Result?: string;
+    }
+    interface ActionResults2 {
+        WUEclDefinitionActionResult?: WUEclDefinitionActionResult[];
+    }
+    interface WUEclDefinitionActionResponse {
+        Exceptions?: Exceptions;
+        ActionResults?: ActionResults2;
+        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?: LogColumns;
+    }
+    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 ECLGraphEx {
+        Name?: string;
+        Label?: string;
+        Type?: string;
+        Graph?: string;
+        Running?: boolean;
+        RunningId?: long;
+        Complete?: boolean;
+        Failed?: boolean;
+    }
+    interface Graphs3 {
+        ECLGraphEx?: ECLGraphEx[];
+    }
+    interface WUGetGraphResponse {
+        Exceptions?: Exceptions;
+        Graphs?: Graphs3;
+    }
+    interface WUGetGraphNameAndTypes {
+        Wuid?: string;
+        Type?: string;
+    }
+    interface GraphNameAndType {
+        Name?: string;
+        Type?: string;
+    }
+    interface GraphNameAndTypes {
+        GraphNameAndType?: GraphNameAndType[];
+    }
+    interface WUGetGraphNameAndTypesResponse {
+        Exceptions?: Exceptions;
+        GraphNameAndTypes?: GraphNameAndTypes;
+    }
+    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?: Endpoints;
+        CacheHint?: long;
+        Total?: long;
+    }
+    interface WUGetPlugins {
+    }
+    interface Plugins {
+        WUEclPluginsInFolder?: WUEclPluginsInFolder[];
+    }
+    interface WUEclPluginsInFolder {
+        Path?: string;
+        Plugins?: Plugins;
+    }
+    interface WUGetPluginsResponse {
+        Exceptions?: Exceptions;
+        Plugins?: Plugins;
+    }
+    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?: Statistics;
+    }
+    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?: JobList;
+        InProgressJobList?: InProgressJobList;
+        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?: QueueList;
+        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;
+        IsContainerized?: boolean;
+    }
+    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?: ResultViews;
+        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?: Jobs;
+    }
+    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?: Workunits;
+    }
+    interface WUListArchiveFiles {
+        WUID?: string;
+    }
+    interface ArchiveModules {
+        ArchiveModule?: ArchiveModule[];
+    }
+    interface File2 {
+        Name?: string;
+        Key?: string;
+        SourcePath?: string;
+        Path?: string;
+    }
+    interface Files {
+        File?: File2[];
+    }
+    interface ArchiveModule {
+        Name?: string;
+        FullName?: string;
+        Flags?: unsignedInt;
+        Key?: string;
+        Plugin?: string;
+        SourcePath?: string;
+        Version?: string;
+        Path?: string;
+        ArchiveModules?: ArchiveModules;
+        Files?: Files;
+    }
+    interface WUListArchiveFilesResponse {
+        Exceptions?: Exceptions;
+        ArchiveModules?: ArchiveModules;
+        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?: LocalFileUploads;
+    }
+    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 ClusterQueryState {
+        Cluster?: string;
+        State?: string;
+        Errors?: string;
+        MixedNodeStates?: boolean;
+    }
+    interface Clusters2 {
+        ClusterQueryState?: ClusterQueryState[];
+    }
+    interface QuerySetQuery {
+        Id?: string;
+        Name?: string;
+        Wuid?: string;
+        Dll?: string;
+        Suspended?: boolean;
+        Clusters?: Clusters2;
+        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?: QuerysetQueries;
+    }
+    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?: Queries;
+    }
+    interface Targets {
+        TargetQueriesUsingFile?: TargetQueriesUsingFile[];
+    }
+    interface WUListQueriesUsingFileResponse {
+        Exceptions?: Exceptions;
+        Process?: string;
+        FileName?: string;
+        Targets?: Targets;
+    }
+    interface WUMultiQuerysetDetails {
+        ClusterName?: string;
+        QuerySetName?: string;
+        Filter?: string;
+        FilterType?: WUQuerySetFilterType;
+        CheckAllNodes?: boolean;
+    }
+    interface Queries2 {
+        QuerySetQuery?: QuerySetQuery[];
+    }
+    interface QuerySetAlias {
+        Id?: string;
+        Name?: string;
+    }
+    interface Aliases {
+        QuerySetAlias?: QuerySetAlias[];
+    }
+    interface WUQuerySetDetail {
+        QuerySetName?: string;
+        Queries?: Queries2;
+        Aliases?: Aliases;
+    }
+    interface Querysets {
+        WUQuerySetDetail?: WUQuerySetDetail[];
+    }
+    interface WUMultiQuerySetDetailsResponse {
+        Exceptions?: Exceptions;
+        ClusterName?: string;
+        Querysets?: Querysets;
+    }
+    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;
+        KeyCompression?: string;
+        DfuTargetPlane?: 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;
+        MinimumExecuteCost?: double;
+        MinimumFileAccessCost?: double;
+        MinimumCompileCost?: double;
+        Sortby?: string;
+        Descending?: boolean;
+        CacheHint?: long;
+    }
+    interface ECLWorkunit {
+        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?: Query;
+        Helpers?: Helpers;
+        Exceptions?: Exceptions2;
+        Graphs?: Graphs;
+        SourceFiles?: SourceFiles;
+        Results?: Results;
+        Variables?: Variables;
+        Timers?: Timers;
+        DebugValues?: DebugValues;
+        ApplicationValues?: ApplicationValues;
+        Workflows?: Workflows;
+        TimingData?: TimingData;
+        AllowedClusters?: AllowedClusters;
+        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?: ThorLogList;
+        ResourceURLs?: ResourceURLs;
+        ResultViewCount?: int;
+        ResourceURLCount?: int;
+        DebugValueCount?: int;
+        WorkflowCount?: int;
+        HelpersCount?: int;
+        ServiceNames?: ServiceNames;
+        ExecuteCost?: double;
+        FileAccessCost?: double;
+        CostSavingPotential?: double;
+        CompileCost?: double;
+        NoAccess?: boolean;
+        ECLWUProcessList?: ECLWUProcessList;
+    }
+    interface Workunits2 {
+        ECLWorkunit?: ECLWorkunit[];
+    }
+    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?: Workunits2;
+    }
+    interface WUQueryConfig {
+        Target?: string;
+        QueryId?: string;
+        Wait?: int;
+        NoReload?: boolean;
+        memoryLimit?: string;
+        TimeLimit?: nonNegativeInteger;
+        WarnTimeLimit?: nonNegativeInteger;
+        Priority?: string;
+        Comment?: string;
+    }
+    interface Result {
+        QueryId?: string;
+    }
+    interface Results2 {
+        Result?: Result[];
+    }
+    interface WUQueryConfigResponse {
+        Exceptions?: Exceptions;
+        ReloadFailed?: boolean;
+        Results?: Results2;
+    }
+    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 SuperFiles {
+        SuperFile?: SuperFile[];
+    }
+    interface SuperFile {
+        Name?: string;
+        SubFiles?: SubFiles;
+        SuperFiles?: SuperFiles;
+    }
+    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?: Clusters2;
+        PublishedBy?: string;
+        Comment?: string;
+        LogicalFiles?: LogicalFiles;
+        SuperFiles?: SuperFiles;
+        IsLibrary?: boolean;
+        Priority?: string;
+        PriorityID?: int;
+        WUSnapShot?: string;
+        CompileTime?: string;
+        LibrariesUsed?: LibrariesUsed;
+        CountGraphs?: int;
+        ResourceURLCount?: int;
+        WsEclAddresses?: WsEclAddresses;
+        WUGraphs?: WUGraphs;
+        WUTimers?: WUTimers;
+    }
+    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 File3 {
+        FileName?: string;
+        FileSize?: long;
+        NumberOfParts?: unsignedInt;
+    }
+    interface Files2 {
+        File?: File3[];
+    }
+    interface Query2 {
+        QueryId?: string;
+        Files?: Files2;
+        SuperFiles?: SuperFiles;
+    }
+    interface Queries3 {
+        Query?: Query2[];
+    }
+    interface WUQueryFilesResponse {
+        Exceptions?: Exceptions;
+        Files?: Files2;
+        SuperFiles?: SuperFiles;
+        Queries?: Queries3;
+    }
+    interface WUQueryGetGraph {
+        Target?: string;
+        QueryId?: string;
+        GraphName?: string;
+        SubGraphId?: string;
+    }
+    interface WUQueryGetGraphResponse {
+        Exceptions?: Exceptions;
+        Graphs?: Graphs3;
+    }
+    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 AggregateQueryStatsList {
+        QuerySummaryStats?: QuerySummaryStats[];
+    }
+    interface QueryStatsRecord {
+        StartTime?: string;
+        ElapsedTimeMs?: long;
+        MemoryUsed?: long;
+        BytesOut?: long;
+        SlavesReplyLen?: int;
+        Failed?: boolean;
+    }
+    interface QueryStatsRecordList {
+        QueryStatsRecord?: QueryStatsRecord[];
+    }
+    interface QueryStats {
+        ID?: string;
+        AggregateQueryStatsList?: AggregateQueryStatsList;
+        QueryStatsRecordList?: QueryStatsRecordList;
+    }
+    interface QueryStatsList {
+        EndpointQueryStats?: EndpointQueryStats[];
+    }
+    interface EndpointQueryStats {
+        Endpoint?: string;
+        Status?: string;
+        QueryStatsList?: QueryStatsList;
+    }
+    interface WUQueryGetSummaryStatsResponse {
+        Exceptions?: Exceptions;
+        StatsList?: StatsList;
+        QueryStatsList?: QueryStatsList;
+    }
+    interface Alias {
+        Name?: string;
+    }
+    interface Aliases2 {
+        Alias?: Alias[];
+    }
+    interface WUQuerysetAliasAction {
+        Action?: QuerySetAliasActionTypes;
+        QuerySetName?: string;
+        Aliases?: Aliases2;
+    }
+    interface Result2 {
+        Name?: string;
+        Success?: boolean;
+        Code?: int;
+        Message?: string;
+    }
+    interface Results3 {
+        Result?: Result2[];
+    }
+    interface WUQuerySetAliasActionResponse {
+        Exceptions?: Exceptions;
+        Action?: QuerySetAliasActionTypes;
+        QuerySetName?: string;
+        Results?: Results3;
+    }
+    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;
+        KeyCompression?: string;
+        DfuTargetPlane?: 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?: QuerysetAliases;
+        ClusterName?: string;
+        Filter?: string;
+        FilterType?: WUQuerySetFilterType;
+        ClusterNames?: ClusterNames;
+    }
+    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;
+        KeyCompression?: string;
+        DfuTargetPlane?: string;
+    }
+    interface ImportedQueries {
+        QueryId?: string[];
+    }
+    interface MissingWuids {
+        QueryId?: string[];
+    }
+    interface WUQuerysetImportResponse {
+        Exceptions?: Exceptions;
+        Target?: string;
+        ClearedExisting?: boolean;
+        Success?: boolean;
+        ImportedQueries?: ImportedQueries;
+        ExistingQueries?: ExistingQueries;
+        MissingWuids?: MissingWuids;
+        FileErrors?: FileErrors;
+        DfuPublisherWuid?: string;
+        DfuPublisherState?: string;
+    }
+    interface ClientState {
+        Suspended?: string;
+    }
+    interface Query3 {
+        QueryId?: string;
+        Activated?: boolean;
+        SuspendedByUser?: boolean;
+        ClientState?: ClientState;
+    }
+    interface Queries4 {
+        Query?: Query3[];
+    }
+    interface WUQuerysetQueryAction {
+        Action?: QuerySetQueryActionTypes;
+        QuerySetName?: string;
+        Queries?: Queries4;
+    }
+    interface Result3 {
+        QueryId?: string;
+        WUID?: string;
+        Suspended?: boolean;
+        Success?: boolean;
+        Code?: int;
+        Message?: string;
+    }
+    interface Results4 {
+        Result?: Result3[];
+    }
+    interface WUQuerySetQueryActionResponse {
+        Exceptions?: Exceptions;
+        Action?: QuerySetQueryActionTypes;
+        QuerySetName?: string;
+        Results?: Results4;
+    }
+    interface WUQuerysets {
+        test?: boolean;
+    }
+    interface QuerySet {
+        QuerySetName?: string;
+    }
+    interface Querysets2 {
+        QuerySet?: QuerySet[];
+    }
+    interface WUQuerysetsResponse {
+        Exceptions?: Exceptions;
+        Querysets?: Querysets2;
+    }
+    interface WURecreateQuery {
+        Target?: string;
+        QueryId?: string;
+        DebugValues?: DebugValues2;
+        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;
+        KeyCompression?: string;
+        DfuTargetPlane?: 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?: WUs;
+    }
+    interface FilterBy {
+        NamedValue?: NamedValue[];
+    }
+    interface WUResult {
+        Wuid?: string;
+        Sequence?: int;
+        ResultName?: string;
+        LogicalName?: string;
+        Cluster?: string;
+        SuppressXmlSchema?: boolean;
+        BypassCachedResult?: boolean;
+        FilterBy?: FilterBy;
+        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 Result4 {
+        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?: Result4;
+    }
+    interface WUResultView {
+        Wuid?: string;
+        ViewName?: string;
+        Sequence?: int;
+        ResultName?: string;
+    }
+    interface WUResultViewResponse {
+        Exceptions?: Exceptions;
+        Wuid?: string;
+        ViewName?: string;
+        Result?: string;
+    }
+    interface Variables2 {
+        NamedValue?: NamedValue[];
+    }
+    interface WURun {
+        QuerySet?: string;
+        Query?: string;
+        Wuid?: string;
+        CloneWorkunit?: boolean;
+        Cluster?: string;
+        Wait?: int;
+        Input?: string;
+        NoRootTag?: boolean;
+        DebugValues?: DebugValues2;
+        Variables?: Variables2;
+        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 ServerInfo {
+        Name?: string;
+        NetAddress?: string;
+    }
+    interface Clusters3 {
+        ServerInfo?: ServerInfo[];
+    }
+    interface ScheduledWU {
+        Wuid?: string;
+        Cluster?: string;
+        EventName?: string;
+        EventText?: string;
+        JobName?: string;
+        StateID?: int;
+        State?: string;
+        Owner?: string;
+    }
+    interface Workunits3 {
+        ScheduledWU?: ScheduledWU[];
+    }
+    interface WUShowScheduledResponse {
+        Exceptions?: Exceptions;
+        ClusterSelected?: int;
+        EventName?: string;
+        PushEventName?: string;
+        PushEventText?: string;
+        Query?: string;
+        Clusters?: Clusters3;
+        Workunits?: Workunits3;
+    }
+    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, abortSignal?: AbortSignal): Promise<WsWorkunits.GVCAjaxGraphResponse>;
+    Ping(request: WsWorkunits.Ping, abortSignal?: AbortSignal): Promise<WsWorkunits.WsWorkunitsPingResponse>;
+    WUAbort(request: WsWorkunits.WUAbort, abortSignal?: AbortSignal): Promise<WsWorkunits.WUAbortResponse>;
+    WUAction(request: WsWorkunits.WUAction, abortSignal?: AbortSignal): Promise<WsWorkunits.WUActionResponse>;
+    WUAddLocalFileToWorkunit(request: WsWorkunits.WUAddLocalFileToWorkunit, abortSignal?: AbortSignal): Promise<WsWorkunits.WUAddLocalFileToWorkunitResponse>;
+    WUAnalyseHotspot(request: WsWorkunits.WUAnalyseHotspot, abortSignal?: AbortSignal): Promise<WsWorkunits.WUAnalyseHotspotResponse>;
+    WUCDebug(request: WsWorkunits.WUCDebug, abortSignal?: AbortSignal): Promise<WsWorkunits.WUDebugResponse>;
+    WUCheckFeatures(request: WsWorkunits.WUCheckFeatures, abortSignal?: AbortSignal): Promise<WsWorkunits.WUCheckFeaturesResponse>;
+    WUClusterJobQueueLOG(request: WsWorkunits.WUClusterJobQueueLOG, abortSignal?: AbortSignal): Promise<WsWorkunits.WUClusterJobQueueLOGResponse>;
+    WUClusterJobQueueXLS(request: WsWorkunits.WUClusterJobQueueXLS, abortSignal?: AbortSignal): Promise<WsWorkunits.WUClusterJobQueueXLSResponse>;
+    WUClusterJobSummaryXLS(request: WsWorkunits.WUClusterJobSummaryXLS, abortSignal?: AbortSignal): Promise<WsWorkunits.WUClusterJobSummaryXLSResponse>;
+    WUClusterJobXLS(request: WsWorkunits.WUClusterJobXLS, abortSignal?: AbortSignal): Promise<WsWorkunits.WUClusterJobXLSResponse>;
+    WUCompileECL(request: WsWorkunits.WUCompileECL, abortSignal?: AbortSignal): Promise<WsWorkunits.WUCompileECLResponse>;
+    WUCopyLogicalFiles(request: WsWorkunits.WUCopyLogicalFiles, abortSignal?: AbortSignal): Promise<WsWorkunits.WUCopyLogicalFilesResponse>;
+    WUCopyQuerySet(request: WsWorkunits.WUCopyQuerySet, abortSignal?: AbortSignal): Promise<WsWorkunits.WUCopyQuerySetResponse>;
+    WUCreate(request: WsWorkunits.WUCreate, abortSignal?: AbortSignal): Promise<WsWorkunits.WUCreateResponse>;
+    WUCreateAndUpdate(request: WsWorkunits.WUCreateAndUpdate, abortSignal?: AbortSignal): Promise<WsWorkunits.WUUpdateResponse>;
+    WUCreateZAPInfo(request: WsWorkunits.WUCreateZAPInfo, abortSignal?: AbortSignal): Promise<WsWorkunits.WUCreateZAPInfoResponse>;
+    WUDelete(request: WsWorkunits.WUDelete, abortSignal?: AbortSignal): Promise<WsWorkunits.WUDeleteResponse>;
+    WUDeployWorkunit(request: WsWorkunits.WUDeployWorkunit, abortSignal?: AbortSignal): Promise<WsWorkunits.WUDeployWorkunitResponse>;
+    WUDetails(request: WsWorkunits.WUDetails, abortSignal?: AbortSignal): Promise<WsWorkunits.WUDetailsResponse>;
+    WUDetailsMeta(request: WsWorkunits.WUDetailsMeta, abortSignal?: AbortSignal): Promise<WsWorkunits.WUDetailsMetaResponse>;
+    WUEclDefinitionAction(request: WsWorkunits.WUEclDefinitionAction, abortSignal?: AbortSignal): Promise<WsWorkunits.WUEclDefinitionActionResponse>;
+    WUExport(request: WsWorkunits.WUExport, abortSignal?: AbortSignal): Promise<WsWorkunits.WUExportResponse>;
+    WUFile(request: WsWorkunits.WUFile, abortSignal?: AbortSignal): Promise<WsWorkunits.WULogFileResponse>;
+    WUFullResult(request: WsWorkunits.WUFullResult, abortSignal?: AbortSignal): Promise<WsWorkunits.WUFullResultResponse>;
+    WUGVCGraphInfo(request: WsWorkunits.WUGVCGraphInfo, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGVCGraphInfoResponse>;
+    WUGetArchiveFile(request: WsWorkunits.WUGetArchiveFile, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetArchiveFileResponse>;
+    WUGetDependancyTrees(request: WsWorkunits.WUGetDependancyTrees, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetDependancyTreesResponse>;
+    WUGetGraph(request: WsWorkunits.WUGetGraph, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetGraphResponse>;
+    WUGetGraphNameAndTypes(request: WsWorkunits.WUGetGraphNameAndTypes, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetGraphNameAndTypesResponse>;
+    WUGetNumFileToCopy(request: WsWorkunits.WUGetNumFileToCopy, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetNumFileToCopyResponse>;
+    WUGetPlugins(request: WsWorkunits.WUGetPlugins, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetPluginsResponse>;
+    WUGetStats(request: WsWorkunits.WUGetStats, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetStatsResponse>;
+    WUGetThorJobList(request: WsWorkunits.WUGetThorJobList, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetThorJobListResponse>;
+    WUGetThorJobQueue(request: WsWorkunits.WUGetThorJobQueue, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetThorJobQueueResponse>;
+    WUGetZAPInfo(request: WsWorkunits.WUGetZAPInfo, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGetZAPInfoResponse>;
+    WUGraphInfo(request: WsWorkunits.WUGraphInfo, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGraphInfoResponse>;
+    WUGraphTiming(request: WsWorkunits.WUGraphTiming, abortSignal?: AbortSignal): Promise<WsWorkunits.WUGraphTimingResponse>;
+    WUInfo(request: WsWorkunits.WUInfo, abortSignal?: AbortSignal): Promise<WsWorkunits.WUInfoResponse>;
+    WUInfoDetails(request: WsWorkunits.WUInfoDetails, abortSignal?: AbortSignal): Promise<WsWorkunits.WUInfoResponse>;
+    WUJobList(request: WsWorkunits.WUJobList, abortSignal?: AbortSignal): Promise<WsWorkunits.WUJobListResponse>;
+    WULightWeightQuery(request: WsWorkunits.WULightWeightQuery, abortSignal?: AbortSignal): Promise<WsWorkunits.WULightWeightQueryResponse>;
+    WUListArchiveFiles(request: WsWorkunits.WUListArchiveFiles, abortSignal?: AbortSignal): Promise<WsWorkunits.WUListArchiveFilesResponse>;
+    WUListLocalFileRequired(request: WsWorkunits.WUListLocalFileRequired, abortSignal?: AbortSignal): Promise<WsWorkunits.WUListLocalFileRequiredResponse>;
+    WUListQueries(request: WsWorkunits.WUListQueries, abortSignal?: AbortSignal): Promise<WsWorkunits.WUListQueriesResponse>;
+    WUListQueriesUsingFile(request: WsWorkunits.WUListQueriesUsingFile, abortSignal?: AbortSignal): Promise<WsWorkunits.WUListQueriesUsingFileResponse>;
+    WUMultiQuerysetDetails(request: WsWorkunits.WUMultiQuerysetDetails, abortSignal?: AbortSignal): Promise<WsWorkunits.WUMultiQuerySetDetailsResponse>;
+    WUProcessGraph(request: WsWorkunits.WUProcessGraph, abortSignal?: AbortSignal): Promise<WsWorkunits.WUProcessGraphResponse>;
+    WUProtect(request: WsWorkunits.WUProtect, abortSignal?: AbortSignal): Promise<WsWorkunits.WUProtectResponse>;
+    WUPublishWorkunit(request: WsWorkunits.WUPublishWorkunit, abortSignal?: AbortSignal): Promise<WsWorkunits.WUPublishWorkunitResponse>;
+    WUPushEvent(request: WsWorkunits.WUPushEvent, abortSignal?: AbortSignal): Promise<WsWorkunits.WUPushEventResponse>;
+    WUQuery(request: WsWorkunits.WUQuery, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryResponse>;
+    WUQueryConfig(request: WsWorkunits.WUQueryConfig, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryConfigResponse>;
+    WUQueryDetails(request: WsWorkunits.WUQueryDetails, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryDetailsResponse>;
+    WUQueryDetailsLightWeight(request: WsWorkunits.WUQueryDetailsLightWeight, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryDetailsResponse>;
+    WUQueryFiles(request: WsWorkunits.WUQueryFiles, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryFilesResponse>;
+    WUQueryGetGraph(request: WsWorkunits.WUQueryGetGraph, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryGetGraphResponse>;
+    WUQueryGetSummaryStats(request: WsWorkunits.WUQueryGetSummaryStats, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQueryGetSummaryStatsResponse>;
+    WUQuerysetAliasAction(request: WsWorkunits.WUQuerysetAliasAction, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerySetAliasActionResponse>;
+    WUQuerysetCopyQuery(request: WsWorkunits.WUQuerysetCopyQuery, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerySetCopyQueryResponse>;
+    WUQuerysetDetails(request: WsWorkunits.WUQuerysetDetails, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerySetDetailsResponse>;
+    WUQuerysetExport(request: WsWorkunits.WUQuerysetExport, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerysetExportResponse>;
+    WUQuerysetImport(request: WsWorkunits.WUQuerysetImport, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerysetImportResponse>;
+    WUQuerysetQueryAction(request: WsWorkunits.WUQuerysetQueryAction, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerySetQueryActionResponse>;
+    WUQuerysets(request: WsWorkunits.WUQuerysets, abortSignal?: AbortSignal): Promise<WsWorkunits.WUQuerysetsResponse>;
+    WURecreateQuery(request: WsWorkunits.WURecreateQuery, abortSignal?: AbortSignal): Promise<WsWorkunits.WURecreateQueryResponse>;
+    WUResubmit(request: WsWorkunits.WUResubmit, abortSignal?: AbortSignal): Promise<WsWorkunits.WUResubmitResponse>;
+    WUResult(request: WsWorkunits.WUResult, abortSignal?: AbortSignal): Promise<WsWorkunits.WUResultResponse>;
+    WUResultBin(request: WsWorkunits.WUResultBin, abortSignal?: AbortSignal): Promise<WsWorkunits.WUResultBinResponse>;
+    WUResultSummary(request: WsWorkunits.WUResultSummary, abortSignal?: AbortSignal): Promise<WsWorkunits.WUResultSummaryResponse>;
+    WUResultView(request: WsWorkunits.WUResultView, abortSignal?: AbortSignal): Promise<WsWorkunits.WUResultViewResponse>;
+    WURun(request: WsWorkunits.WURun, abortSignal?: AbortSignal): Promise<WsWorkunits.WURunResponse>;
+    WUSchedule(request: WsWorkunits.WUSchedule, abortSignal?: AbortSignal): Promise<WsWorkunits.WUScheduleResponse>;
+    WUShowScheduled(request: WsWorkunits.WUShowScheduled, abortSignal?: AbortSignal): Promise<WsWorkunits.WUShowScheduledResponse>;
+    WUSubmit(request: WsWorkunits.WUSubmit, abortSignal?: AbortSignal): Promise<WsWorkunits.WUSubmitResponse>;
+    WUSyntaxCheckECL(request: WsWorkunits.WUSyntaxCheckECL, abortSignal?: AbortSignal): Promise<WsWorkunits.WUSyntaxCheckResponse>;
+    WUUpdate(request: WsWorkunits.WUUpdate, abortSignal?: AbortSignal): Promise<WsWorkunits.WUUpdateResponse>;
+    WUUpdateQueryEntry(request: WsWorkunits.WUUpdateQueryEntry, abortSignal?: AbortSignal): Promise<WsWorkunits.WUUpdateQueryEntryResponse>;
+    WUWaitCompiled(request: WsWorkunits.WUWaitCompiled, abortSignal?: AbortSignal): Promise<WsWorkunits.WUWaitResponse>;
+    WUWaitComplete(request: WsWorkunits.WUWaitComplete, abortSignal?: AbortSignal): Promise<WsWorkunits.WUWaitResponse>;
+}