diff --git a/packages/comms/src/ecl/logicalFile.ts b/packages/comms/src/ecl/logicalFile.ts
index 39b3b53692..44127479e8 100644
--- a/packages/comms/src/ecl/logicalFile.ts
+++ b/packages/comms/src/ecl/logicalFile.ts
@@ -88,6 +88,7 @@ export class LogicalFile extends StateObject<FileDetailEx, FileDetailEx> impleme
     get StateID(): number { return this.get("StateID"); }
     get ExpirationDate(): string { return this.get("ExpirationDate"); }
     get ExtendedIndexInfo(): WsDfu.ExtendedIndexInfo { return this.get("ExtendedIndexInfo"); }
+    get CompressionType(): string { return this.get("CompressionType"); }
 
     get properties(): FileDetailEx { return this.get(); }
 
diff --git a/packages/comms/src/ecl/store.ts b/packages/comms/src/ecl/store.ts
index 288357ec49..368448d8a8 100644
--- a/packages/comms/src/ecl/store.ts
+++ b/packages/comms/src/ecl/store.ts
@@ -61,7 +61,7 @@ export class Store {
     private _knownValues: { [key: string]: any } = {};
 
     protected create() {
-        this.connection.CreateStore({ Name: this.Name, UserSpecific: this.UserSpecific, Type: "", Description: "" });
+        this.connection.CreateStore({ Name: this.Name, Type: "", Description: "" });
     }
 
     set(key: string, value: string, broadcast = true): Promise<void> {
diff --git a/packages/comms/src/services/fileSpray.ts b/packages/comms/src/services/fileSpray.ts
index ee685bf4e9..8881040978 100644
--- a/packages/comms/src/services/fileSpray.ts
+++ b/packages/comms/src/services/fileSpray.ts
@@ -1,4 +1,4 @@
-import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.26/FileSpray.ts";
+import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.27/FileSpray.ts";
 
 export {
     FileSpray
diff --git a/packages/comms/src/services/wsCodesign.ts b/packages/comms/src/services/wsCodesign.ts
index 4c514accb4..0d1ea3122b 100644
--- a/packages/comms/src/services/wsCodesign.ts
+++ b/packages/comms/src/services/wsCodesign.ts
@@ -1,94 +1,18 @@
-import { IConnection, IOptions } from "../connection.ts";
-import { ESPConnection } from "../espConnection.ts";
+import { CodesignServiceBase, WsCodesign } from "./wsdl/ws_codesign/v1.1/ws_codesign.ts";
 
-/*
-    Response structures generated via:
-    * http://localhost:8010/ws_codesign/?ver_=1.1&respjson_
-    * http://json2ts.com/
-*/
-export namespace WsCodesign {
+export { WsCodesign };
 
-    export interface ListUserIDsRequest {
-    }
-
-    export interface WsCodesignPingRequest {
-    }
-
-    export interface SignRequest {
-        SigningMethod?: string;
-        UserID: string;
-        KeyPass: string;
-        Text: string;
-    }
-
-    export interface VerifyRequest {
-        Text: string;
-    }
-
-    export interface Exception {
-        Code: string;
-        Audience: string;
-        Source: string;
-        Message: string;
-    }
-
-    export interface Exceptions {
-        Source: string;
-        Exception: Exception[];
-    }
-
-    export interface UserIDs {
-        Item: string[];
-    }
-
-    export interface ListUserIDsResponse {
-        Exceptions: Exceptions;
-        UserIDs: UserIDs;
-    }
+export class CodesignService extends CodesignServiceBase {
 
-    export interface WsCodesignPingResponse {
-    }
-
-    export interface SignResponse {
-        Exceptions: Exceptions;
-        RetCode: number;
-        ErrMsg: string;
-        SignedText: string;
-    }
-
-    export interface VerifyResponse {
-        Exceptions: Exceptions;
-        RetCode: number;
-        ErrMsg: string;
-        IsVerified: boolean;
-        SignedBy: string;
-    }
-}
-
-export class CodesignService {
-    private _connection: ESPConnection;
-
-    constructor(optsConnection: IOptions | IConnection) {
-        this._connection = new ESPConnection(optsConnection, "ws_codesign", "1.1");
-    }
-
-    connectionOptions(): IOptions {
-        return this._connection.opts();
-    }
-
-    ListUserIDs(request: WsCodesign.ListUserIDsRequest): Promise<string[]> {
-        return this._connection.send("ListUserIDs", request).then((response: WsCodesign.ListUserIDsResponse) => {
+    ListUserIDsEx(request: Partial<WsCodesign.ListUserIDsRequest>): Promise<string[]> {
+        return super.ListUserIDs(request).then((response: WsCodesign.ListUserIDsResponse) => {
             return response.UserIDs.Item;
         }).catch(e => {
             return [];
         });
     }
 
-    Sign(request: WsCodesign.SignRequest): Promise<WsCodesign.SignResponse> {
-        return this._connection.send("Sign", { SigningMethod: "gpg", ...request });
-    }
-
-    Verify(request: WsCodesign.VerifyRequest): Promise<WsCodesign.VerifyResponse> {
-        return this._connection.send("Verify", request);
+    Sign(request: Partial<WsCodesign.SignRequest>): Promise<WsCodesign.SignResponse> {
+        return super.Sign({ SigningMethod: WsCodesign.SigningMethodType.gpg, ...request });
     }
 }
diff --git a/packages/comms/src/services/wsDFU.ts b/packages/comms/src/services/wsDFU.ts
index 37ea32c37c..e65bf4e8e7 100644
--- a/packages/comms/src/services/wsDFU.ts
+++ b/packages/comms/src/services/wsDFU.ts
@@ -1,4 +1,4 @@
-import { DfuServiceBase, WsDfu } from "./wsdl/WsDfu/v1.65/WsDfu.ts";
+import { DfuServiceBase, WsDfu } from "./wsdl/WsDfu/v1.67/WsDfu.ts";
 
 export { WsDfu };
 
diff --git a/packages/comms/src/services/wsDFUXRef.ts b/packages/comms/src/services/wsDFUXRef.ts
index a1b20ce071..b53eb7ae69 100644
--- a/packages/comms/src/services/wsDFUXRef.ts
+++ b/packages/comms/src/services/wsDFUXRef.ts
@@ -1,308 +1,7 @@
-import { IConnection, IOptions } from "../connection.ts";
-import { Service } from "../espConnection.ts";
+import { DFUXRefServiceBase, type WsDFUXRef } from "./wsdl/WsDFUXRef/v1.04/WsDFUXRef.ts";
 
-/*
-    Response structures generated via:
-    * http://localhost:8010/WsDFUXRef/?ver_=1.01&reqjson_
-    * http://localhost:8010/WsDFUXRef/?ver_=1.01&respjson_
-    * http://json2ts.com/
-*/
+export { type WsDFUXRef };
 
-export namespace WsDFUXRef {
+export class DFUXRefService extends DFUXRefServiceBase {
 
-    export interface XRefFiles {
-        Item: string[];
-    }
-
-    export interface DFUXRefArrayActionRequest {
-        Type: string;
-        Cluster: string;
-        Action: string;
-        XRefFiles: XRefFiles;
-    }
-
-    export interface DFUXRefBuildRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefBuildCancelRequest {
-    }
-
-    export interface DFUXRefCleanDirectoriesRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefDirectoriesQueryRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefFoundFilesQueryRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefListRequest {
-    }
-
-    export interface DFUXRefLostFilesQueryRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefMessagesQueryRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefOrphanFilesQueryRequest {
-        Cluster: string;
-    }
-
-    export interface DFUXRefUnusedFilesRequest {
-        ProcessCluster: string;
-        CheckPackageMaps: boolean;
-        GetFileDetails: boolean;
-    }
-
-    export interface WsDFUXRefPingRequest {
-    }
-
-    export interface Request {
-        DFUXRefArrayActionRequest: DFUXRefArrayActionRequest;
-        DFUXRefBuildRequest: DFUXRefBuildRequest;
-        DFUXRefBuildCancelRequest: DFUXRefBuildCancelRequest;
-        DFUXRefCleanDirectoriesRequest: DFUXRefCleanDirectoriesRequest;
-        DFUXRefDirectoriesQueryRequest: DFUXRefDirectoriesQueryRequest;
-        DFUXRefFoundFilesQueryRequest: DFUXRefFoundFilesQueryRequest;
-        DFUXRefListRequest: DFUXRefListRequest;
-        DFUXRefLostFilesQueryRequest: DFUXRefLostFilesQueryRequest;
-        DFUXRefMessagesQueryRequest: DFUXRefMessagesQueryRequest;
-        DFUXRefOrphanFilesQueryRequest: DFUXRefOrphanFilesQueryRequest;
-        DFUXRefUnusedFilesRequest: DFUXRefUnusedFilesRequest;
-        WsDFUXRefPingRequest: WsDFUXRefPingRequest;
-    }
-
-    export interface DFUXRefArrayActionResponse {
-        DFUXRefArrayActionResult: string;
-    }
-
-    export interface DFUXRefBuildResponse {
-        DFUXRefActionResult: string;
-    }
-
-    export interface DFUXRefBuildCancelResponse {
-        DFUXRefBuildCancelResult: string;
-    }
-
-    export interface Exception {
-        Code: string;
-        Audience: string;
-        Source: string;
-        Message: string;
-    }
-
-    export interface Exceptions {
-        Source: string;
-        Exception: Exception[];
-    }
-
-    export interface Directory {
-        Num: string;
-        Name: string;
-        MaxSize: string;
-        MaxIP: string;
-        MinSize: string;
-        MinIP: string;
-        Size: string;
-        PositiveSkew: string;
-    }
-
-    export interface DFUXRefDirectoriesQueryResult {
-        Directory: Directory[];
-        Cluster: string;
-    }
-
-    export interface DFUXRefDirectoriesQueryResponse {
-        DFUXRefDirectoriesQueryResult: DFUXRefDirectoriesQueryResult;
-    }
-
-    export interface Part {
-        Num: string;
-        Node: string;
-    }
-
-    export interface File {
-        Size: string;
-        Partmask: string;
-        Modified: Date;
-        Numparts: string;
-        Part: Part[];
-    }
-
-    export interface DFUXRefFoundFilesQueryResult {
-        File: File[];
-        Cluster: string;
-    }
-
-    export interface DFUXRefFoundFilesQueryResponse {
-        DFUXRefFoundFilesQueryResult: DFUXRefFoundFilesQueryResult;
-    }
-
-    export interface XRefNode {
-        Name: string;
-        Modified: string;
-        Status: string;
-    }
-
-    export interface DFUXRefListResult {
-        XRefNode: XRefNode[];
-    }
-
-    export interface DFUXRefListResponse {
-        DFUXRefListResult: DFUXRefListResult;
-    }
-
-    export interface File2 {
-        Partslost: string;
-        Name: string;
-        Partmask: string;
-        Modified: Date;
-        Numparts: string;
-        Part: any;
-        Cluster: string;
-        Size: string;
-        Primarylost: string;
-        Replicatedlost: string;
-    }
-
-    export interface DFUXRefLostFilesQueryResult {
-        File: File2[];
-        Cluster: string;
-    }
-
-    export interface DFUXRefLostFilesQueryResponse {
-        DFUXRefLostFilesQueryResult: DFUXRefLostFilesQueryResult;
-    }
-
-    export interface Warning {
-        Text: string;
-        File: string;
-    }
-
-    export interface DFUXRefMessagesQueryResult {
-        Warning: Warning[];
-        Cluster: string;
-    }
-
-    export interface DFUXRefMessagesQueryResponse {
-        DFUXRefMessagesQueryResult: DFUXRefMessagesQueryResult;
-    }
-
-    export interface DFUXRefOrphanFilesQueryResult {
-        File: File[];
-        Cluster: string;
-    }
-
-    export interface DFUXRefOrphanFilesQueryResponse {
-        DFUXRefOrphanFilesQueryResult: DFUXRefOrphanFilesQueryResult;
-    }
-
-    export interface Exception2 {
-        Code: string;
-        Audience: string;
-        Source: string;
-        Message: string;
-    }
-
-    export interface Exceptions2 {
-        Source: string;
-        Exception: Exception2[];
-    }
-
-    export interface UnusedFiles {
-        File: string[];
-    }
-
-    export interface DFULogicalFile {
-        Prefix: string;
-        ClusterName: string;
-        Directory: string;
-        Description: string;
-        Parts: string;
-        Name: string;
-        Owner: string;
-        Totalsize: string;
-        RecordCount: string;
-        Modified: string;
-        LongSize: string;
-        LongRecordCount: string;
-        isSuperfile: boolean;
-        isZipfile: boolean;
-        isDirectory: boolean;
-        Replicate: boolean;
-        IntSize: number;
-        IntRecordCount: number;
-    }
-
-    export interface UnusedFilesWithDetails {
-        DFULogicalFile: DFULogicalFile[];
-    }
-
-    export interface DFUXRefUnusedFilesResponse {
-        Exceptions: Exceptions2;
-        UnusedFileCount: number;
-        UnusedFiles: UnusedFiles;
-        UnusedFilesWithDetails: UnusedFilesWithDetails;
-    }
-
-    export interface WsDFUXRefPingResponse {
-    }
-}
-
-export class DFUXRefService extends Service {
-
-    constructor(optsConnection: IOptions | IConnection) {
-        super(optsConnection, "WsDFUXRef", "1.01");
-    }
-
-    DFUXRefArrayAction(request: WsDFUXRef.DFUXRefArrayActionRequest): Promise<WsDFUXRef.DFUXRefArrayActionResponse> {
-        return this._connection.send("DFUXRefArrayAction", request);
-    }
-
-    DFUXRefBuild(request: WsDFUXRef.DFUXRefBuildRequest): Promise<WsDFUXRef.DFUXRefBuildResponse> {
-        return this._connection.send("DFUXRefBuild", request);
-    }
-
-    DFUXRefBuildCancel(request: WsDFUXRef.DFUXRefBuildCancelRequest): Promise<WsDFUXRef.DFUXRefBuildCancelResponse> {
-        return this._connection.send("DFUXRefBuildCancel", request);
-    }
-
-    DFUXRefCleanDirectories(request: WsDFUXRef.DFUXRefCleanDirectoriesRequest): Promise<WsDFUXRef.DFUXRefDirectoriesQueryResponse> {
-        return this._connection.send("DFUXRefCleanDirectories", request);
-    }
-
-    DFUXRefDirectories(request: WsDFUXRef.DFUXRefDirectoriesQueryRequest): Promise<WsDFUXRef.DFUXRefDirectoriesQueryResponse> {
-        return this._connection.send("DFUXRefDirectories", request, undefined, undefined, undefined, "DFUXRefDirectoriesQueryResponse");
-    }
-
-    DFUXRefFoundFiles(request: WsDFUXRef.DFUXRefFoundFilesQueryRequest): Promise<WsDFUXRef.DFUXRefFoundFilesQueryResponse> {
-        return this._connection.send("DFUXRefFoundFiles", request, undefined, undefined, undefined, "DFUXRefFoundFilesQueryResponse");
-    }
-
-    DFUXRefList(request: WsDFUXRef.DFUXRefListRequest = {}): Promise<WsDFUXRef.DFUXRefListResponse> {
-        return this._connection.send("DFUXRefList", request);
-    }
-
-    DFUXRefLostFiles(request: WsDFUXRef.DFUXRefLostFilesQueryRequest): Promise<WsDFUXRef.DFUXRefLostFilesQueryResponse> {
-        return this._connection.send("DFUXRefLostFiles", request, undefined, undefined, undefined, "DFUXRefLostFilesQueryResponse");
-    }
-
-    DFUXRefMessages(request: WsDFUXRef.DFUXRefMessagesQueryRequest): Promise<WsDFUXRef.DFUXRefMessagesQueryResponse> {
-        return this._connection.send("DFUXRefMessages", request, undefined, undefined, undefined, "DFUXRefMessagesQueryResponse");
-    }
-
-    DFUXRefOrphanFiles(request: WsDFUXRef.DFUXRefOrphanFilesQueryRequest): Promise<WsDFUXRef.DFUXRefOrphanFilesQueryResponse> {
-        return this._connection.send("DFUXRefOrphanFiles", request, undefined, undefined, undefined, "DFUXRefOrphanFilesQueryResponse");
-    }
-
-    DFUXRefUnusedFiles(request: WsDFUXRef.DFUXRefUnusedFilesRequest): Promise<WsDFUXRef.DFUXRefUnusedFilesResponse> {
-        return this._connection.send("DFUXRefUnusedFiles", request);
-    }
 }
diff --git a/packages/comms/src/services/wsMachine.ts b/packages/comms/src/services/wsMachine.ts
index b1f9ce9957..88532bfbca 100644
--- a/packages/comms/src/services/wsMachine.ts
+++ b/packages/comms/src/services/wsMachine.ts
@@ -1,7 +1,7 @@
 import { exists } from "@hpcc-js/util";
 import { max as d3Max, mean as d3Mean } from "d3-array";
 
-import { MachineServiceBase, WsMachine } from "./wsdl/ws_machine/v1.17/ws_machine.ts";
+import { MachineServiceBase, WsMachine } from "./wsdl/ws_machine/v1.19/ws_machine.ts";
 
 export {
     type WsMachine
diff --git a/packages/comms/src/services/wsPackageProcess.ts b/packages/comms/src/services/wsPackageProcess.ts
index e184dafa51..2aead15682 100644
--- a/packages/comms/src/services/wsPackageProcess.ts
+++ b/packages/comms/src/services/wsPackageProcess.ts
@@ -1,4 +1,4 @@
-import { PackageProcessServiceBase, WsPackageProcess } from "./wsdl/WsPackageProcess/v1.04/WsPackageProcess.ts";
+import { PackageProcessServiceBase, WsPackageProcess } from "./wsdl/WsPackageProcess/v1.07/WsPackageProcess.ts";
 
 export {
     type WsPackageProcess
diff --git a/packages/comms/src/services/wsSMC.ts b/packages/comms/src/services/wsSMC.ts
index 4bc6428bc7..f96c73ebcd 100644
--- a/packages/comms/src/services/wsSMC.ts
+++ b/packages/comms/src/services/wsSMC.ts
@@ -1,4 +1,4 @@
-import { SMCServiceBase, WsSMC } from "./wsdl/WsSMC/v1.27/WsSMC.ts";
+import { SMCServiceBase, WsSMC } from "./wsdl/WsSMC/v1.28/WsSMC.ts";
 import { IOptions } from "../connection.ts";
 
 export {
diff --git a/packages/comms/src/services/wsStore.ts b/packages/comms/src/services/wsStore.ts
index 611b58e031..be6ccca147 100644
--- a/packages/comms/src/services/wsStore.ts
+++ b/packages/comms/src/services/wsStore.ts
@@ -1,185 +1,11 @@
-import { IConnection, IOptions } from "../connection.ts";
-import { Service } from "../espConnection.ts";
+import { storeServiceBase as StoreServiceBase, Wsstore as WsStore } from "./wsdl/wsstore/v1.02/wsstore.ts";
 
-/*
-    Response structures generated via:
-    * http://localhost:8010/wsstore/Fetch?reqjson_
-    * http://localhost:8010/wsstore/Fetch?respjson_
-    * http://json2ts.com/
-*/
+export { type WsStore };
 
-export namespace WsStore {
+export class StoreService extends StoreServiceBase {
 
-    export interface CreateStoreRequest {
-        Name: string;
-        Type: string;
-        Description: string;
-        UserSpecific: boolean;
-    }
-
-    export interface DeleteRequest {
-        StoreName: string;
-        Namespace: string;
-        Key: string;
-        UserSpecific: boolean;
-        TargetUser?: string;
-    }
-
-    export interface DeleteNamespaceRequest {
-        StoreName: string;
-        Namespace: string;
-        UserSpecific: boolean;
-        TargetUser: string;
-    }
-
-    export interface FetchRequest {
-        StoreName: string;
-        Namespace: string;
-        Key: string;
-        UserSpecific: boolean;
-    }
-
-    export interface FetchAllRequest {
-        StoreName: string;
-        Namespace: string;
-        UserSpecific: boolean;
-    }
-
-    export interface FetchKeyMDRequest {
-        StoreName: string;
-        Namespace: string;
-        Key: string;
-        UserSpecific: boolean;
-    }
-
-    export interface ListKeysRequest {
-        StoreName: string;
-        Namespace: string;
-        UserSpecific: boolean;
-    }
-
-    export interface ListNamespacesRequest {
-        StoreName: string;
-        UserSpecific: boolean;
-    }
-
-    export interface SetRequest {
-        StoreName: string;
-        Namespace: string;
-        Key: string;
-        Value: string;
-        UserSpecific: boolean;
-    }
-
-    export interface Exception {
-        Code: string;
-        Audience: string;
-        Source: string;
-        Message: string;
-    }
-
-    export interface Exceptions {
-        Source: string;
-        Exception: Exception[];
-    }
-
-    export interface CreateStoreResponse {
-        Exceptions: Exceptions;
-        Name: string;
-        Type: string;
-        Description: string;
-        Owner: string;
-    }
-
-    export interface DeleteResponse {
-        Exceptions: Exceptions;
-        Success: boolean;
-    }
-
-    export interface DeleteNamespaceResponse {
-        Exceptions: Exceptions;
-        Success: boolean;
-    }
-
-    export interface FetchResponse {
-        Exceptions: Exceptions;
-        Value: string;
-    }
-
-    export interface Pair {
-        Key: string;
-        Value: string;
-    }
-
-    export interface Pairs {
-        Pair: Pair[];
-    }
-
-    export interface FetchAllResponse {
-        Exceptions: Exceptions;
-        Namespace: string;
-        Pairs: Pairs;
-    }
-
-    export interface Pair2 {
-        Key: string;
-        Value: string;
-    }
-
-    export interface Pairs2 {
-        Pair: Pair2[];
-    }
-
-    export interface FetchKeyMDResponse {
-        Exceptions: Exceptions;
-        StoreName: string;
-        Namespace: string;
-        Key: string;
-        Pairs: Pairs2;
-    }
-
-    export interface KeySet {
-        Key: string[];
-    }
-
-    export interface ListKeysResponse {
-        Exceptions: Exceptions;
-        StoreName: string;
-        Namespace: string;
-        KeySet: KeySet;
-    }
-
-    export interface Namespaces {
-        Namespace: string[];
-    }
-
-    export interface ListNamespacesResponse {
-        Exceptions: Exceptions;
-        StoreName: string;
-        Namespaces: Namespaces;
-    }
-
-    export interface WsstorePingResponse {
-    }
-
-    export interface SetResponse {
-        Exceptions: Exceptions;
-        Success: boolean;
-    }
-}
-
-export class StoreService extends Service {
-
-    constructor(optsConnection: IOptions | IConnection) {
-        super(optsConnection, "WsStore", "1");
-    }
-
-    CreateStore(request: WsStore.CreateStoreRequest): Promise<WsStore.CreateStoreResponse> {
-        return this._connection.send("Fetch", request);
-    }
-
-    Delete(request: WsStore.DeleteRequest): Promise<WsStore.DeleteResponse> {
-        return this._connection.send("Delete", request).catch(e => {
+    Delete(request: Partial<WsStore.DeleteRequest>): Promise<WsStore.DeleteResponse> {
+        return super.Delete(request).catch(e => {
             if (e.isESPExceptions && e.Exception.some(e => e.Code === -1)) {
                 //  "Delete" item does not exist  ---
                 return {
@@ -191,12 +17,8 @@ export class StoreService extends Service {
         });
     }
 
-    DeleteNamespace(request: WsStore.DeleteNamespaceRequest): Promise<WsStore.DeleteNamespaceResponse> {
-        return this._connection.send("DeleteNamespace", request);
-    }
-
-    Fetch(request: WsStore.FetchRequest): Promise<WsStore.FetchResponse> {
-        return this._connection.send("Fetch", request).catch(e => {
+    Fetch(request: Partial<WsStore.FetchRequest>): Promise<WsStore.FetchResponse> {
+        return super.Fetch(request).catch(e => {
             if (e.isESPExceptions && e.Exception.some(e => e.Code === -1)) {
                 //  "Fetch" item does not exist  ---
                 return {
@@ -207,24 +29,4 @@ export class StoreService extends Service {
             throw e;
         });
     }
-
-    FetchAll(request: WsStore.FetchAllRequest): Promise<WsStore.FetchAllResponse> {
-        return this._connection.send("FetchAll", request);
-    }
-
-    FetchKeyMD(request: WsStore.FetchKeyMDRequest): Promise<WsStore.FetchKeyMDResponse> {
-        return this._connection.send("FetchKeyMD", request);
-    }
-
-    ListKeys(request: WsStore.ListKeysRequest): Promise<WsStore.ListKeysResponse> {
-        return this._connection.send("ListKeys", request);
-    }
-
-    ListNamespaces(request: WsStore.ListNamespacesRequest): Promise<WsStore.ListNamespacesResponse> {
-        return this._connection.send("ListNamespaces", request);
-    }
-
-    Set(request: WsStore.SetRequest): Promise<WsStore.SetResponse> {
-        return this._connection.send("Set", request);
-    }
 }
diff --git a/packages/comms/src/services/wsTopology.ts b/packages/comms/src/services/wsTopology.ts
index 0b176a2d2b..ac369212c9 100644
--- a/packages/comms/src/services/wsTopology.ts
+++ b/packages/comms/src/services/wsTopology.ts
@@ -1,5 +1,5 @@
 import { IOptions } from "../connection.ts";
-import { TopologyServiceBase, WsTopology } from "./wsdl/WsTopology/v1.32/WsTopology.ts";
+import { TopologyServiceBase, WsTopology } from "./wsdl/WsTopology/v1.33/WsTopology.ts";
 
 export {
     WsTopology
diff --git a/packages/comms/src/services/wsWorkunits.ts b/packages/comms/src/services/wsWorkunits.ts
index cb971f51a6..7ccd7dca4c 100644
--- a/packages/comms/src/services/wsWorkunits.ts
+++ b/packages/comms/src/services/wsWorkunits.ts
@@ -1,14 +1,6 @@
 import { deepMixin, xml2json, XMLNode } from "@hpcc-js/util";
 import { WsWorkunits, WorkunitsServiceBase } from "./wsdl/WsWorkunits/v2.02/WsWorkunits.ts";
 import { IConnection, IOptions } from "../connection.ts";
-import { ESPConnection } from "../espConnection.ts";
-
-/*
-    Response structures generated via:
-    * http://localhost:8010/WsWorkunits/WUInfo?reqjson_
-    * http://localhost:8010/WsWorkunits/WUInfo?respjson_
-    * http://json2ts.com/
-*/
 
 export {
     WsWorkunits
diff --git a/packages/comms/src/services/wsdl/FileSpray/v1.27/FileSpray.ts b/packages/comms/src/services/wsdl/FileSpray/v1.27/FileSpray.ts
new file mode 100644
index 0000000000..cff5939c76
--- /dev/null
+++ b/packages/comms/src/services/wsdl/FileSpray/v1.27/FileSpray.ts
@@ -0,0 +1,930 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace FileSpray {
+
+    export type int = number;
+    export type double = number;
+    export type base64Binary = string;
+    export type long = number;
+    export type dateTime = string;
+
+    export enum DFUWUActions {
+        Delete = "Delete",
+        Protect = "Protect",
+        Unprotect = "Unprotect",
+        Restore = "Restore",
+        SetToFailed = "SetToFailed",
+        Archive = "Archive"
+    }
+
+    export interface AbortDFUWorkunit {
+        wuid: string;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface AbortDFUWorkunitResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface Copy {
+        sourceLogicalName: string;
+        destGroup: string;
+        destGroupRoxie: string;
+        destLogicalName: string;
+        sourceDali: string;
+        srcusername: string;
+        srcpassword: string;
+        overwrite: boolean;
+        ensure: boolean;
+        replicate: boolean;
+        ReplicateOffset: int;
+        maxConnections: int;
+        throttle: int;
+        transferBufferSize: int;
+        nosplit: boolean;
+        norecover: boolean;
+        compress: boolean;
+        Wrap: boolean;
+        Multicopy: boolean;
+        SourceDiffKeyName: string;
+        DestDiffKeyName: string;
+        superCopy: boolean;
+        push: boolean;
+        pull: boolean;
+        ifnewer: boolean;
+        noCommon: boolean;
+        encrypt: string;
+        decrypt: string;
+        preserveCompression: boolean;
+        DFUServerQueue: string;
+        ExpireDays: int;
+        KeyCompression: string;
+    }
+
+    export interface CopyResponse {
+        Exceptions: Exceptions;
+        result: string;
+    }
+
+    export interface CreateDFUPublisherWorkunit {
+        DFUServerQueue: string;
+    }
+
+    export interface result {
+        ID: string;
+        DFUServerName: string;
+        ClusterName: string;
+        JobName: string;
+        Queue: string;
+        User: string;
+        isProtected: boolean;
+        Command: int;
+        CommandMessage: string;
+        PercentDone: int;
+        SecsLeft: int;
+        ProgressMessage: string;
+        SummaryMessage: string;
+        State: int;
+        SourceLogicalName: string;
+        SourceIP: string;
+        SourceFilePath: string;
+        SourceDali: string;
+        SourceRecordSize: int;
+        SourceFormat: int;
+        RowTag: string;
+        SourceNumParts: int;
+        SourceDirectory: string;
+        DestLogicalName: string;
+        DestGroupName: string;
+        DestDirectory: string;
+        DestIP: string;
+        DestFilePath: string;
+        DestFormat: int;
+        DestNumParts: int;
+        DestRecordSize: int;
+        Replicate: boolean;
+        Overwrite: boolean;
+        Compress: boolean;
+        SourceCsvSeparate: string;
+        SourceCsvQuote: string;
+        SourceCsvTerminate: string;
+        SourceCsvEscape: string;
+        TimeStarted: string;
+        TimeStopped: string;
+        StateMessage: string;
+        MonitorEventName: string;
+        MonitorSub: boolean;
+        MonitorShotLimit: int;
+        SourceDiffKeyName: string;
+        DestDiffKeyName: string;
+        Archived: boolean;
+        encrypt: string;
+        decrypt: string;
+        failIfNoSourceFile: boolean;
+        recordStructurePresent: boolean;
+        quotedTerminator: boolean;
+        preserveCompression: boolean;
+        expireDays: int;
+        PreserveFileParts: boolean;
+        FileAccessCost: double;
+        KbPerSecAve: int;
+        KbPerSec: int;
+    }
+
+    export interface CreateDFUPublisherWorkunitResponse {
+        Exceptions: Exceptions;
+        result: result;
+    }
+
+    export interface CreateDFUWorkunit {
+        DFUServerQueue: string;
+    }
+
+    export interface CreateDFUWorkunitResponse {
+        Exceptions: Exceptions;
+        result: result;
+    }
+
+    export interface DFUWUFileRequest {
+        Wuid?: string;
+        Type?: string;
+        PlainText?: string;
+    }
+
+    export interface DFUWUFileResponse {
+        Exceptions: Exceptions;
+        file: string;
+    }
+
+    export interface DFUWUSearchRequest {
+
+    }
+
+    export interface ClusterNames {
+        ClusterName: string[];
+    }
+
+    export interface DFUWUSearchResponse {
+        Exceptions: Exceptions;
+        ClusterNames: ClusterNames;
+    }
+
+    export interface wuids {
+        Item: string[];
+    }
+
+    export interface DFUWorkunitsActionRequest {
+        wuids?: wuids;
+        Type?: DFUWUActions;
+    }
+
+    export interface DFUActionResult {
+        ID: string;
+        Action: string;
+        Result: string;
+    }
+
+    export interface DFUActionResults {
+        DFUActionResult: DFUActionResult[];
+    }
+
+    export interface DFUWorkunitsActionResponse {
+        Exceptions: Exceptions;
+        FirstColumn: string;
+        DFUActionResults: DFUActionResults;
+    }
+
+    export interface DeleteDFUWorkunit {
+        wuid: string;
+    }
+
+    export interface DeleteDFUWorkunitResponse {
+        Exceptions: Exceptions;
+        result: boolean;
+    }
+
+    export interface DeleteDFUWorkunits {
+        wuids: wuids;
+    }
+
+    export interface DeleteDFUWorkunitsResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface Names {
+        Item: string[];
+    }
+
+    export interface DeleteDropZoneFilesRequest {
+        DropZoneName?: string;
+        NetAddress?: string;
+        Path?: string;
+        OS?: string;
+        Names?: Names;
+    }
+
+    export interface Despray {
+        destGroup: string;
+        sourceLogicalName: string;
+        destIP: string;
+        destPath: string;
+        destPlane: string;
+        dstxml: base64Binary;
+        overwrite: boolean;
+        maxConnections: int;
+        throttle: int;
+        transferBufferSize: int;
+        splitprefix: string;
+        norecover: boolean;
+        wrap: boolean;
+        multiCopy: boolean;
+        SingleConnection: boolean;
+        DFUServerQueue: string;
+        compress: boolean;
+        encrypt: string;
+        decrypt: string;
+    }
+
+    export interface DesprayResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+    }
+
+    export interface DfuMonitorRequest {
+        EventName?: string;
+        LogicalName?: string;
+        Ip?: string;
+        Filename?: string;
+        Sub?: boolean;
+        ShotLimit?: int;
+    }
+
+    export interface DfuMonitorResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+    }
+
+    export interface DropZoneFileSearchRequest {
+        DropZoneName?: string;
+        Server?: string;
+        ECLWatchVisibleOnly?: boolean;
+        NameFilter?: string;
+    }
+
+    export interface PhysicalFileStruct {
+        name: string;
+        Server: string;
+        isDir: boolean;
+        filesize: long;
+        modifiedtime: string;
+        Path: string;
+        Files: Files;
+    }
+
+    export interface Files {
+        PhysicalFileStruct: PhysicalFileStruct[];
+    }
+
+    export interface DropZoneFileSearchResponse {
+        Exceptions: Exceptions;
+        Files: Files;
+        Warning: string;
+    }
+
+    export interface DropZoneFilesRequest {
+        DropZoneName?: string;
+        NetAddress?: string;
+        Path?: string;
+        OS?: string;
+        Subfolder?: string;
+        ECLWatchVisibleOnly?: boolean;
+        DirectoryOnly?: boolean;
+    }
+
+    export interface DropZone {
+        Name: string;
+        NetAddress: string;
+        Path: string;
+        Computer: string;
+        Linux: string;
+    }
+
+    export interface DropZones {
+        DropZone: DropZone[];
+    }
+
+    export interface DropZoneFilesResponse {
+        Exceptions: Exceptions;
+        DropZoneName: string;
+        NetAddress: string;
+        Path: string;
+        OS: int;
+        ECLWatchVisibleOnly: boolean;
+        DropZones: DropZones;
+        Files: Files;
+    }
+
+    export interface EchoDateTime {
+        dt: dateTime;
+    }
+
+    export interface EchoDateTimeResponse {
+        result: dateTime;
+    }
+
+    export interface FileListRequest {
+        DropZoneName?: string;
+        Netaddr?: string;
+        Path?: string;
+        Mask?: string;
+        OS?: string;
+        DirectoryOnly?: boolean;
+    }
+
+    export interface files {
+        PhysicalFileStruct: PhysicalFileStruct[];
+    }
+
+    export interface FileListResponse {
+        Exceptions: Exceptions;
+        Netaddr: string;
+        Path: string;
+        Mask: string;
+        OS: int;
+        DirectoryOnly: boolean;
+        AcceptLanguage: string;
+        files: files;
+    }
+
+    export interface GetDFUExceptions {
+        wuid: string;
+    }
+
+    export interface DFUException {
+        Code: int;
+        Message: string;
+    }
+
+    export interface result2 {
+        DFUException: DFUException[];
+    }
+
+    export interface GetDFUExceptionsResponse {
+        Exceptions: Exceptions;
+        result: result2;
+    }
+
+    export interface ProgressRequest {
+        wuid?: string;
+    }
+
+    export interface ProgressResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+        PercentDone: int;
+        SecsLeft: int;
+        KbPerSecAve: int;
+        KbPerSec: int;
+        SlavesDone: int;
+        TimeTaken: string;
+        ProgressMessage: string;
+        SummaryMessage: string;
+        State: string;
+    }
+
+    export interface GetDFUServerQueuesRequest {
+        DFUServerName?: string;
+    }
+
+    export interface GetDFUServerQueuesResponse {
+        Exceptions: Exceptions;
+        Names: Names;
+    }
+
+    export interface GetDFUWorkunit {
+        wuid: string;
+    }
+
+    export interface GetDFUWorkunitResponse {
+        Exceptions: Exceptions;
+        result: result;
+        AutoRefresh: int;
+    }
+
+    export interface GetDFUWorkunits {
+        Wuid: string;
+        Owner: string;
+        Cluster: string;
+        StateReq: string;
+        Type: string;
+        Jobname: string;
+        PageSize: long;
+        CurrentPage: int;
+        PageStartFrom: long;
+        Sortby: string;
+        Descending: boolean;
+        CacheHint: long;
+        ParentWuid: string;
+        PublisherWuid: string;
+        includeProgressMessages: boolean;
+        includeTimings: boolean;
+        includeTransferRate: boolean;
+    }
+
+    export interface DFUWorkunit {
+        ID: string;
+        DFUServerName: string;
+        ClusterName: string;
+        JobName: string;
+        Queue: string;
+        User: string;
+        isProtected: boolean;
+        Command: int;
+        CommandMessage: string;
+        PercentDone: int;
+        SecsLeft: int;
+        ProgressMessage: string;
+        SummaryMessage: string;
+        State: int;
+        SourceLogicalName: string;
+        SourceIP: string;
+        SourceFilePath: string;
+        SourceDali: string;
+        SourceRecordSize: int;
+        SourceFormat: int;
+        RowTag: string;
+        SourceNumParts: int;
+        SourceDirectory: string;
+        DestLogicalName: string;
+        DestGroupName: string;
+        DestDirectory: string;
+        DestIP: string;
+        DestFilePath: string;
+        DestFormat: int;
+        DestNumParts: int;
+        DestRecordSize: int;
+        Replicate: boolean;
+        Overwrite: boolean;
+        Compress: boolean;
+        SourceCsvSeparate: string;
+        SourceCsvQuote: string;
+        SourceCsvTerminate: string;
+        SourceCsvEscape: string;
+        TimeStarted: string;
+        TimeStopped: string;
+        StateMessage: string;
+        MonitorEventName: string;
+        MonitorSub: boolean;
+        MonitorShotLimit: int;
+        SourceDiffKeyName: string;
+        DestDiffKeyName: string;
+        Archived: boolean;
+        encrypt: string;
+        decrypt: string;
+        failIfNoSourceFile: boolean;
+        recordStructurePresent: boolean;
+        quotedTerminator: boolean;
+        preserveCompression: boolean;
+        expireDays: int;
+        PreserveFileParts: boolean;
+        FileAccessCost: double;
+        KbPerSecAve: int;
+        KbPerSec: int;
+    }
+
+    export interface results {
+        DFUWorkunit: DFUWorkunit[];
+    }
+
+    export interface GetDFUWorkunitsResponse {
+        Exceptions: Exceptions;
+        results: results;
+        Type: string;
+        Owner: string;
+        Cluster: string;
+        StateReq: string;
+        PageSize: long;
+        PrevPage: long;
+        NextPage: long;
+        LastPage: long;
+        NumWUs: long;
+        PageStartFrom: long;
+        PageEndAt: long;
+        First: boolean;
+        Sortby: string;
+        Descending: boolean;
+        BasicQuery: string;
+        Filters: string;
+        CacheHint: long;
+    }
+
+    export interface GetRemoteTargetsRequest {
+
+    }
+
+    export interface TargetNames {
+        Item: string[];
+    }
+
+    export interface GetRemoteTargetsResponse {
+        Exceptions: Exceptions;
+        TargetNames: TargetNames;
+        AllowForeign: boolean;
+    }
+
+    export interface GetSprayTargetsRequest {
+
+    }
+
+    export interface GroupNode {
+        Name: string;
+        ClusterType: string;
+        ReplicateOutputs: boolean;
+    }
+
+    export interface GroupNodes {
+        GroupNode: GroupNode[];
+    }
+
+    export interface GetSprayTargetsResponse {
+        Exceptions: Exceptions;
+        GroupNodes: GroupNodes;
+    }
+
+    export interface OpenSaveRequest {
+        Location?: string;
+        Path?: string;
+        Name?: string;
+        Type?: string;
+        DateTime?: string;
+        BinaryFile?: boolean;
+    }
+
+    export interface OpenSaveResponse {
+        Exceptions: Exceptions;
+        Location: string;
+        Path: string;
+        Name: string;
+        Type: string;
+        DateTime: string;
+        Viewable: boolean;
+    }
+
+    export interface FileSprayPingRequest {
+
+    }
+
+    export interface FileSprayPingResponse {
+
+    }
+
+    export interface Rename {
+        srcname: string;
+        dstname: string;
+        overwrite: boolean;
+        DFUServerQueue: string;
+    }
+
+    export interface RenameResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+    }
+
+    export interface Replicate {
+        sourceLogicalName: string;
+        replicateOffset: int;
+        cluster: string;
+        repeatLast: boolean;
+        onlyRepeated: boolean;
+        DFUServerQueue: string;
+    }
+
+    export interface ReplicateResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+    }
+
+    export interface ShowResultRequest {
+        Result?: string;
+    }
+
+    export interface ShowResultResponse {
+        Exceptions: Exceptions;
+        Result: string;
+    }
+
+    export interface SprayFixed {
+        sourceIP: string;
+        sourcePlane: string;
+        sourcePath: string;
+        srcxml: base64Binary;
+        sourceFormat: string;
+        sourceRecordSize: int;
+        destGroup: string;
+        destLogicalName: string;
+        destNumParts: int;
+        overwrite: boolean;
+        replicate: boolean;
+        ReplicateOffset: int;
+        maxConnections: int;
+        throttle: int;
+        transferBufferSize: int;
+        prefix: string;
+        nosplit: boolean;
+        norecover: boolean;
+        compress: boolean;
+        push: boolean;
+        pull: boolean;
+        noCommon: boolean;
+        encrypt: string;
+        decrypt: string;
+        wrap: boolean;
+        failIfNoSourceFile: boolean;
+        recordStructurePresent: boolean;
+        quotedTerminator: boolean;
+        expireDays: int;
+        DFUServerQueue: string;
+    }
+
+    export interface SprayFixedResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+    }
+
+    export interface SprayVariable {
+        sourceIP: string;
+        sourcePlane: string;
+        sourcePath: string;
+        srcxml: base64Binary;
+        sourceMaxRecordSize: int;
+        sourceFormat: int;
+        NoSourceCsvSeparator: boolean;
+        sourceCsvSeparate: string;
+        sourceCsvTerminate: string;
+        sourceCsvQuote: string;
+        sourceCsvEscape: string;
+        sourceRowTag: string;
+        destGroup: string;
+        destLogicalName: string;
+        destNumParts: int;
+        overwrite: boolean;
+        replicate: boolean;
+        ReplicateOffset: int;
+        maxConnections: int;
+        throttle: int;
+        transferBufferSize: int;
+        prefix: string;
+        nosplit: boolean;
+        norecover: boolean;
+        compress: boolean;
+        push: boolean;
+        pull: boolean;
+        noCommon: boolean;
+        encrypt: string;
+        decrypt: string;
+        failIfNoSourceFile: boolean;
+        recordStructurePresent: boolean;
+        quotedTerminator: boolean;
+        sourceRowPath: string;
+        isJSON: boolean;
+        expireDays: int;
+        DFUServerQueue: string;
+        srcUsername: string;
+        srcPassword: string;
+    }
+
+    export interface SprayResponse {
+        Exceptions: Exceptions;
+        wuid: string;
+    }
+
+    export interface SubmitDFUWorkunit {
+        wuid: string;
+    }
+
+    export interface SubmitDFUWorkunitResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface wu {
+        ID: string;
+        DFUServerName: string;
+        ClusterName: string;
+        JobName: string;
+        Queue: string;
+        User: string;
+        isProtected: boolean;
+        Command: int;
+        CommandMessage: string;
+        PercentDone: int;
+        SecsLeft: int;
+        ProgressMessage: string;
+        SummaryMessage: string;
+        State: int;
+        SourceLogicalName: string;
+        SourceIP: string;
+        SourceFilePath: string;
+        SourceDali: string;
+        SourceRecordSize: int;
+        SourceFormat: int;
+        RowTag: string;
+        SourceNumParts: int;
+        SourceDirectory: string;
+        DestLogicalName: string;
+        DestGroupName: string;
+        DestDirectory: string;
+        DestIP: string;
+        DestFilePath: string;
+        DestFormat: int;
+        DestNumParts: int;
+        DestRecordSize: int;
+        Replicate: boolean;
+        Overwrite: boolean;
+        Compress: boolean;
+        SourceCsvSeparate: string;
+        SourceCsvQuote: string;
+        SourceCsvTerminate: string;
+        SourceCsvEscape: string;
+        TimeStarted: string;
+        TimeStopped: string;
+        StateMessage: string;
+        MonitorEventName: string;
+        MonitorSub: boolean;
+        MonitorShotLimit: int;
+        SourceDiffKeyName: string;
+        DestDiffKeyName: string;
+        Archived: boolean;
+        encrypt: string;
+        decrypt: string;
+        failIfNoSourceFile: boolean;
+        recordStructurePresent: boolean;
+        quotedTerminator: boolean;
+        preserveCompression: boolean;
+        expireDays: int;
+        PreserveFileParts: boolean;
+        FileAccessCost: double;
+        KbPerSecAve: int;
+        KbPerSec: int;
+    }
+
+    export interface UpdateDFUWorkunit {
+        wu: wu;
+        ClusterOrig: string;
+        JobNameOrig: string;
+        isProtectedOrig: boolean;
+        StateOrig: int;
+    }
+
+    export interface UpdateDFUWorkunitResponse {
+        Exceptions: Exceptions;
+    }
+
+}
+
+export class FileSprayServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "FileSpray", "1.27");
+    }
+
+    AbortDFUWorkunit(request: Partial<FileSpray.AbortDFUWorkunit>): Promise<FileSpray.AbortDFUWorkunitResponse> {
+        return this._connection.send("AbortDFUWorkunit", request, "json", false, undefined, "AbortDFUWorkunitResponse");
+    }
+
+    Copy(request: Partial<FileSpray.Copy>): Promise<FileSpray.CopyResponse> {
+        return this._connection.send("Copy", request, "json", false, undefined, "CopyResponse");
+    }
+
+    CreateDFUPublisherWorkunit(request: Partial<FileSpray.CreateDFUPublisherWorkunit>): Promise<FileSpray.CreateDFUPublisherWorkunitResponse> {
+        return this._connection.send("CreateDFUPublisherWorkunit", request, "json", false, undefined, "CreateDFUPublisherWorkunitResponse");
+    }
+
+    CreateDFUWorkunit(request: Partial<FileSpray.CreateDFUWorkunit>): Promise<FileSpray.CreateDFUWorkunitResponse> {
+        return this._connection.send("CreateDFUWorkunit", request, "json", false, undefined, "CreateDFUWorkunitResponse");
+    }
+
+    DFUWUFile(request: Partial<FileSpray.DFUWUFileRequest>): Promise<FileSpray.DFUWUFileResponse> {
+        return this._connection.send("DFUWUFile", request, "json", false, undefined, "DFUWUFileResponse");
+    }
+
+    DFUWUSearch(request: Partial<FileSpray.DFUWUSearchRequest>): Promise<FileSpray.DFUWUSearchResponse> {
+        return this._connection.send("DFUWUSearch", request, "json", false, undefined, "DFUWUSearchResponse");
+    }
+
+    DFUWorkunitsAction(request: Partial<FileSpray.DFUWorkunitsActionRequest>): Promise<FileSpray.DFUWorkunitsActionResponse> {
+        return this._connection.send("DFUWorkunitsAction", request, "json", false, undefined, "DFUWorkunitsActionResponse");
+    }
+
+    DeleteDFUWorkunit(request: Partial<FileSpray.DeleteDFUWorkunit>): Promise<FileSpray.DeleteDFUWorkunitResponse> {
+        return this._connection.send("DeleteDFUWorkunit", request, "json", false, undefined, "DeleteDFUWorkunitResponse");
+    }
+
+    DeleteDFUWorkunits(request: Partial<FileSpray.DeleteDFUWorkunits>): Promise<FileSpray.DeleteDFUWorkunitsResponse> {
+        return this._connection.send("DeleteDFUWorkunits", request, "json", false, undefined, "DeleteDFUWorkunitsResponse");
+    }
+
+    DeleteDropZoneFiles(request: Partial<FileSpray.DeleteDropZoneFilesRequest>): Promise<FileSpray.DFUWorkunitsActionResponse> {
+        return this._connection.send("DeleteDropZoneFiles", request, "json", false, undefined, "DFUWorkunitsActionResponse");
+    }
+
+    Despray(request: Partial<FileSpray.Despray>): Promise<FileSpray.DesprayResponse> {
+        return this._connection.send("Despray", request, "json", false, undefined, "DesprayResponse");
+    }
+
+    DfuMonitor(request: Partial<FileSpray.DfuMonitorRequest>): Promise<FileSpray.DfuMonitorResponse> {
+        return this._connection.send("DfuMonitor", request, "json", false, undefined, "DfuMonitorResponse");
+    }
+
+    DropZoneFileSearch(request: Partial<FileSpray.DropZoneFileSearchRequest>): Promise<FileSpray.DropZoneFileSearchResponse> {
+        return this._connection.send("DropZoneFileSearch", request, "json", false, undefined, "DropZoneFileSearchResponse");
+    }
+
+    DropZoneFiles(request: Partial<FileSpray.DropZoneFilesRequest>): Promise<FileSpray.DropZoneFilesResponse> {
+        return this._connection.send("DropZoneFiles", request, "json", false, undefined, "DropZoneFilesResponse");
+    }
+
+    EchoDateTime(request: Partial<FileSpray.EchoDateTime>): Promise<FileSpray.EchoDateTimeResponse> {
+        return this._connection.send("EchoDateTime", request, "json", false, undefined, "EchoDateTimeResponse");
+    }
+
+    FileList(request: Partial<FileSpray.FileListRequest>): Promise<FileSpray.FileListResponse> {
+        return this._connection.send("FileList", request, "json", false, undefined, "FileListResponse");
+    }
+
+    GetDFUExceptions(request: Partial<FileSpray.GetDFUExceptions>): Promise<FileSpray.GetDFUExceptionsResponse> {
+        return this._connection.send("GetDFUExceptions", request, "json", false, undefined, "GetDFUExceptionsResponse");
+    }
+
+    GetDFUProgress(request: Partial<FileSpray.ProgressRequest>): Promise<FileSpray.ProgressResponse> {
+        return this._connection.send("GetDFUProgress", request, "json", false, undefined, "ProgressResponse");
+    }
+
+    GetDFUServerQueues(request: Partial<FileSpray.GetDFUServerQueuesRequest>): Promise<FileSpray.GetDFUServerQueuesResponse> {
+        return this._connection.send("GetDFUServerQueues", request, "json", false, undefined, "GetDFUServerQueuesResponse");
+    }
+
+    GetDFUWorkunit(request: Partial<FileSpray.GetDFUWorkunit>): Promise<FileSpray.GetDFUWorkunitResponse> {
+        return this._connection.send("GetDFUWorkunit", request, "json", false, undefined, "GetDFUWorkunitResponse");
+    }
+
+    GetDFUWorkunits(request: Partial<FileSpray.GetDFUWorkunits>): Promise<FileSpray.GetDFUWorkunitsResponse> {
+        return this._connection.send("GetDFUWorkunits", request, "json", false, undefined, "GetDFUWorkunitsResponse");
+    }
+
+    GetRemoteTargets(request: Partial<FileSpray.GetRemoteTargetsRequest>): Promise<FileSpray.GetRemoteTargetsResponse> {
+        return this._connection.send("GetRemoteTargets", request, "json", false, undefined, "GetRemoteTargetsResponse");
+    }
+
+    GetSprayTargets(request: Partial<FileSpray.GetSprayTargetsRequest>): Promise<FileSpray.GetSprayTargetsResponse> {
+        return this._connection.send("GetSprayTargets", request, "json", false, undefined, "GetSprayTargetsResponse");
+    }
+
+    OpenSave(request: Partial<FileSpray.OpenSaveRequest>): Promise<FileSpray.OpenSaveResponse> {
+        return this._connection.send("OpenSave", request, "json", false, undefined, "OpenSaveResponse");
+    }
+
+    Ping(request: Partial<FileSpray.FileSprayPingRequest>): Promise<FileSpray.FileSprayPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "FileSprayPingResponse");
+    }
+
+    Rename(request: Partial<FileSpray.Rename>): Promise<FileSpray.RenameResponse> {
+        return this._connection.send("Rename", request, "json", false, undefined, "RenameResponse");
+    }
+
+    Replicate(request: Partial<FileSpray.Replicate>): Promise<FileSpray.ReplicateResponse> {
+        return this._connection.send("Replicate", request, "json", false, undefined, "ReplicateResponse");
+    }
+
+    ShowResult(request: Partial<FileSpray.ShowResultRequest>): Promise<FileSpray.ShowResultResponse> {
+        return this._connection.send("ShowResult", request, "json", false, undefined, "ShowResultResponse");
+    }
+
+    SprayFixed(request: Partial<FileSpray.SprayFixed>): Promise<FileSpray.SprayFixedResponse> {
+        return this._connection.send("SprayFixed", request, "json", false, undefined, "SprayFixedResponse");
+    }
+
+    SprayVariable(request: Partial<FileSpray.SprayVariable>): Promise<FileSpray.SprayResponse> {
+        return this._connection.send("SprayVariable", request, "json", false, undefined, "SprayResponse");
+    }
+
+    SubmitDFUWorkunit(request: Partial<FileSpray.SubmitDFUWorkunit>): Promise<FileSpray.SubmitDFUWorkunitResponse> {
+        return this._connection.send("SubmitDFUWorkunit", request, "json", false, undefined, "SubmitDFUWorkunitResponse");
+    }
+
+    UpdateDFUWorkunit(request: Partial<FileSpray.UpdateDFUWorkunit>): Promise<FileSpray.UpdateDFUWorkunitResponse> {
+        return this._connection.send("UpdateDFUWorkunit", request, "json", false, undefined, "UpdateDFUWorkunitResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsDFUXRef/v1.04/WsDFUXRef.ts b/packages/comms/src/services/wsdl/WsDFUXRef/v1.04/WsDFUXRef.ts
new file mode 100644
index 0000000000..0d71b6b12a
--- /dev/null
+++ b/packages/comms/src/services/wsdl/WsDFUXRef/v1.04/WsDFUXRef.ts
@@ -0,0 +1,227 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsDFUXRef {
+
+    export type unsignedInt = number;
+    export type long = number;
+
+    export interface XRefFiles {
+        Item: string[];
+    }
+
+    export interface DFUXRefArrayActionRequest {
+        Type?: string;
+        Cluster?: string;
+        Action?: string;
+        XRefFiles?: XRefFiles;
+        RemoveFromSuperfiles?: boolean;
+    }
+
+    export interface DFUXRefArrayActionResponse {
+        DFUXRefArrayActionResult: string;
+    }
+
+    export interface DFUXRefBuildRequest {
+        Cluster?: string;
+    }
+
+    export interface DFUXRefBuildResponse {
+        DFUXRefActionResult: string;
+    }
+
+    export interface DFUXRefBuildCancelRequest {
+
+    }
+
+    export interface DFUXRefBuildCancelResponse {
+        DFUXRefBuildCancelResult: string;
+    }
+
+    export interface DFUXRefCleanDirectoriesRequest {
+        Cluster?: string;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface DFUXRefCleanDirectoriesResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface DFUXRefDirectoriesQueryRequest {
+        Cluster?: string;
+    }
+
+    export interface DFUXRefDirectoriesQueryResponse {
+        DFUXRefDirectoriesQueryResult: string;
+    }
+
+    export interface DFUXRefFoundFilesQueryRequest {
+        Cluster?: string;
+    }
+
+    export interface DFUXRefFoundFilesQueryResponse {
+        DFUXRefFoundFilesQueryResult: string;
+    }
+
+    export interface DFUXRefListRequest {
+
+    }
+
+    export interface DFUXRefListResponse {
+        DFUXRefListResult: string;
+    }
+
+    export interface DFUXRefLostFilesQueryRequest {
+        Cluster?: string;
+    }
+
+    export interface DFUXRefLostFilesQueryResponse {
+        DFUXRefLostFilesQueryResult: string;
+    }
+
+    export interface DFUXRefMessagesQueryRequest {
+        Cluster?: string;
+    }
+
+    export interface DFUXRefMessagesQueryResponse {
+        DFUXRefMessagesQueryResult: string;
+    }
+
+    export interface DFUXRefOrphanFilesQueryRequest {
+        Cluster?: string;
+    }
+
+    export interface DFUXRefOrphanFilesQueryResponse {
+        DFUXRefOrphanFilesQueryResult: string;
+    }
+
+    export interface ProcessClusterList {
+        Item: string[];
+    }
+
+    export interface CheckPlanes {
+        Item: string[];
+    }
+
+    export interface DFUXRefUnusedFilesRequest {
+        ProcessCluster?: string;
+        CheckPackageMaps?: boolean;
+        GetFileDetails?: boolean;
+        ProcessClusterList?: ProcessClusterList;
+        CheckPlanes?: CheckPlanes;
+    }
+
+    export interface UnusedFiles {
+        File: string[];
+    }
+
+    export interface DFULogicalFile {
+        Prefix: string;
+        ClusterName: string;
+        Directory: string;
+        Description: string;
+        Parts: string;
+        Name: string;
+        Owner: string;
+        Totalsize: string;
+        RecordCount: string;
+        Modified: string;
+        LongSize: string;
+        LongRecordCount: string;
+        isSuperfile: boolean;
+        isZipfile: boolean;
+        isDirectory: boolean;
+        Replicate: boolean;
+        IntSize: long;
+        IntRecordCount: long;
+        FromRoxieCluster: boolean;
+        BrowseData: boolean;
+    }
+
+    export interface UnusedFilesWithDetails {
+        DFULogicalFile: DFULogicalFile[];
+    }
+
+    export interface DFUXRefUnusedFilesResponse {
+        Exceptions: Exceptions;
+        UnusedFileCount: unsignedInt;
+        UnusedFiles: UnusedFiles;
+        UnusedFilesWithDetails: UnusedFilesWithDetails;
+    }
+
+    export interface WsDFUXRefPingRequest {
+
+    }
+
+    export interface WsDFUXRefPingResponse {
+
+    }
+
+}
+
+export class DFUXRefServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsDFUXRef", "1.04");
+    }
+
+    DFUXRefArrayAction(request: Partial<WsDFUXRef.DFUXRefArrayActionRequest>): Promise<WsDFUXRef.DFUXRefArrayActionResponse> {
+        return this._connection.send("DFUXRefArrayAction", request, "json", false, undefined, "DFUXRefArrayActionResponse");
+    }
+
+    DFUXRefBuild(request: Partial<WsDFUXRef.DFUXRefBuildRequest>): Promise<WsDFUXRef.DFUXRefBuildResponse> {
+        return this._connection.send("DFUXRefBuild", request, "json", false, undefined, "DFUXRefBuildResponse");
+    }
+
+    DFUXRefBuildCancel(request: Partial<WsDFUXRef.DFUXRefBuildCancelRequest>): Promise<WsDFUXRef.DFUXRefBuildCancelResponse> {
+        return this._connection.send("DFUXRefBuildCancel", request, "json", false, undefined, "DFUXRefBuildCancelResponse");
+    }
+
+    DFUXRefCleanDirectories(request: Partial<WsDFUXRef.DFUXRefCleanDirectoriesRequest>): Promise<WsDFUXRef.DFUXRefCleanDirectoriesResponse> {
+        return this._connection.send("DFUXRefCleanDirectories", request, "json", false, undefined, "DFUXRefCleanDirectoriesResponse");
+    }
+
+    DFUXRefDirectories(request: Partial<WsDFUXRef.DFUXRefDirectoriesQueryRequest>): Promise<WsDFUXRef.DFUXRefDirectoriesQueryResponse> {
+        return this._connection.send("DFUXRefDirectories", request, "json", false, undefined, "DFUXRefDirectoriesQueryResponse");
+    }
+
+    DFUXRefFoundFiles(request: Partial<WsDFUXRef.DFUXRefFoundFilesQueryRequest>): Promise<WsDFUXRef.DFUXRefFoundFilesQueryResponse> {
+        return this._connection.send("DFUXRefFoundFiles", request, "json", false, undefined, "DFUXRefFoundFilesQueryResponse");
+    }
+
+    DFUXRefList(request: Partial<WsDFUXRef.DFUXRefListRequest>): Promise<WsDFUXRef.DFUXRefListResponse> {
+        return this._connection.send("DFUXRefList", request, "json", false, undefined, "DFUXRefListResponse");
+    }
+
+    DFUXRefLostFiles(request: Partial<WsDFUXRef.DFUXRefLostFilesQueryRequest>): Promise<WsDFUXRef.DFUXRefLostFilesQueryResponse> {
+        return this._connection.send("DFUXRefLostFiles", request, "json", false, undefined, "DFUXRefLostFilesQueryResponse");
+    }
+
+    DFUXRefMessages(request: Partial<WsDFUXRef.DFUXRefMessagesQueryRequest>): Promise<WsDFUXRef.DFUXRefMessagesQueryResponse> {
+        return this._connection.send("DFUXRefMessages", request, "json", false, undefined, "DFUXRefMessagesQueryResponse");
+    }
+
+    DFUXRefOrphanFiles(request: Partial<WsDFUXRef.DFUXRefOrphanFilesQueryRequest>): Promise<WsDFUXRef.DFUXRefOrphanFilesQueryResponse> {
+        return this._connection.send("DFUXRefOrphanFiles", request, "json", false, undefined, "DFUXRefOrphanFilesQueryResponse");
+    }
+
+    DFUXRefUnusedFiles(request: Partial<WsDFUXRef.DFUXRefUnusedFilesRequest>): Promise<WsDFUXRef.DFUXRefUnusedFilesResponse> {
+        return this._connection.send("DFUXRefUnusedFiles", request, "json", false, undefined, "DFUXRefUnusedFilesResponse");
+    }
+
+    Ping(request: Partial<WsDFUXRef.WsDFUXRefPingRequest>): Promise<WsDFUXRef.WsDFUXRefPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsDFUXRefPingResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsDfu/v1.66/WsDfu.ts b/packages/comms/src/services/wsdl/WsDfu/v1.66/WsDfu.ts
new file mode 100644
index 0000000000..b1bfd8636e
--- /dev/null
+++ b/packages/comms/src/services/wsdl/WsDfu/v1.66/WsDfu.ts
@@ -0,0 +1,1267 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsDfu {
+
+    export type base64Binary = string;
+    export type long = number;
+    export type int = number;
+    export type double = number;
+
+    export enum DFUArrayActions {
+        Delete = "Delete",
+        AddToSuperfile = "Add To Superfile",
+        ChangeProtection = "Change Protection",
+        ChangeRestriction = "Change Restriction"
+    }
+
+    export enum DFUChangeProtection {
+        NoChange = 0,
+        Protect = 1,
+        Unprotect = 2,
+        UnprotectAll = 3
+    }
+
+    export enum DFUChangeRestriction {
+        NoChange = 0,
+        Restrict = 1,
+        Unrestricted = 2
+    }
+
+    export enum DFUDefFileFormat {
+        xml = "xml",
+        def = "def"
+    }
+
+    export enum FileAccessRole {
+        Token = "Token",
+        Engine = "Engine",
+        External = "External"
+    }
+
+    export enum SecAccessType {
+        None = "None",
+        Access = "Access",
+        Read = "Read",
+        Write = "Write",
+        Full = "Full"
+    }
+
+    export enum DFUFileType {
+        Flat = "Flat",
+        Index = "Index",
+        Xml = "Xml",
+        Csv = "Csv",
+        Json = "Json",
+        IndexLocal = "IndexLocal",
+        IndexPartitioned = "IndexPartitioned",
+        Unset = "Unset"
+    }
+
+    export interface AddRequest {
+        dstname?: string;
+        xmlmap?: base64Binary;
+        dstcluster?: string;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface AddResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface AddRemoteRequest {
+        dstname?: string;
+        srcname?: string;
+        srcdali?: string;
+        srcusername?: string;
+        srcpassword?: string;
+    }
+
+    export interface AddRemoteResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface names {
+        Item: string[];
+    }
+
+    export interface AddtoSuperfileRequest {
+        Superfile?: string;
+        Subfiles?: string;
+        names?: names;
+        ExistingFile?: boolean;
+        BackToPage?: string;
+    }
+
+    export interface SubfileNames {
+        SubfileName: string[];
+    }
+
+    export interface AddtoSuperfileResponse {
+        Exceptions: Exceptions;
+        Subfiles: string;
+        BackToPage: string;
+        SubfileNames: SubfileNames;
+    }
+
+    export interface LogicalFiles {
+        Item: string[];
+    }
+
+    export interface DFUArrayActionRequest {
+        Type?: DFUArrayActions;
+        NoDelete?: boolean;
+        BackToPage?: string;
+        LogicalFiles?: LogicalFiles;
+        removeFromSuperfiles?: boolean;
+        removeRecursively?: boolean;
+        Protect?: DFUChangeProtection;
+        Restrict?: DFUChangeRestriction;
+    }
+
+    export interface DFUActionInfo {
+        FileName: string;
+        NodeGroup: string;
+        ActionResult: string;
+        Failed: boolean;
+    }
+
+    export interface ActionResults {
+        DFUActionInfo: DFUActionInfo[];
+    }
+
+    export interface DFUArrayActionResponse {
+        Exceptions: Exceptions;
+        BackToPage: string;
+        RedirectTo: string;
+        ActionResults: ActionResults;
+    }
+
+    export interface DFUBrowseDataRequest {
+        LogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        SchemaOnly?: boolean;
+        StartForGoback?: long;
+        CountForGoback?: int;
+        ChooseFile?: int;
+        Cluster?: string;
+        ClusterType?: string;
+        ParentName?: string;
+        Start?: long;
+        Count?: int;
+        DisableUppercaseTranslation?: boolean;
+    }
+
+    export interface DFUDataColumn {
+        ColumnID: int;
+        ColumnLabel: string;
+        ColumnType: string;
+        ColumnValue: string;
+        ColumnSize: int;
+        MaxSize: int;
+        ColumnEclType: string;
+        ColumnRawSize: int;
+        IsNaturalColumn: boolean;
+        IsKeyedColumn: boolean;
+        DataColumns: DataColumns;
+    }
+
+    export interface DataColumns {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface ColumnHidden {
+        ColumnID: int;
+        ColumnLabel: string;
+        ColumnType: string;
+        ColumnValue: string;
+        ColumnSize: int;
+        MaxSize: int;
+        ColumnEclType: string;
+        ColumnRawSize: int;
+        IsNaturalColumn: boolean;
+        IsKeyedColumn: boolean;
+        DataColumns: DataColumns;
+    }
+
+    export interface ColumnsHidden {
+        ColumnHidden: ColumnHidden[];
+    }
+
+    export interface DFUBrowseDataResponse {
+        Exceptions: Exceptions;
+        Name: string;
+        LogicalName: string;
+        FilterBy: string;
+        FilterForGoBack: string;
+        ColumnsHidden: ColumnsHidden;
+        ColumnCount: int;
+        StartForGoback: long;
+        CountForGoback: int;
+        ChooseFile: int;
+        SchemaOnly: boolean;
+        Cluster: string;
+        ClusterType: string;
+        ParentName: string;
+        Start: long;
+        Count: long;
+        PageSize: long;
+        Total: long;
+        Result: string;
+        MsgToDisplay: string;
+        DisableUppercaseTranslation: boolean;
+    }
+
+    export interface DFUDefFileRequest {
+        Name?: string;
+        Format?: DFUDefFileFormat;
+    }
+
+    export interface DFUDefFileResponse {
+        Exceptions: Exceptions;
+        defFile: base64Binary;
+    }
+
+    export interface RequestBase {
+        Name: string;
+        Cluster: string;
+        JobId: string;
+        ExpirySeconds: int;
+        AccessRole: FileAccessRole;
+        AccessType: SecAccessType;
+        ReturnJsonTypeInfo: boolean;
+        ReturnBinTypeInfo: boolean;
+    }
+
+    export interface DFUFileAccessRequest {
+        RequestBase?: RequestBase;
+    }
+
+    export interface DFUPartLocation {
+        LocationIndex: int;
+        Host: string;
+    }
+
+    export interface FileLocations {
+        DFUPartLocation: DFUPartLocation[];
+    }
+
+    export interface DFUFileCopy {
+        CopyIndex: int;
+        LocationIndex: int;
+        Path: string;
+    }
+
+    export interface Copies {
+        DFUFileCopy: DFUFileCopy[];
+    }
+
+    export interface DFUFilePart {
+        PartIndex: int;
+        Copies: Copies;
+        TopLevelKey: boolean;
+    }
+
+    export interface FileParts {
+        DFUFilePart: DFUFilePart[];
+    }
+
+    export interface AccessInfo {
+        MetaInfoBlob: string;
+        ExpiryTime: string;
+        NumParts: int;
+        FileLocations: FileLocations;
+        FileParts: FileParts;
+        RecordTypeInfoJson: string;
+        fileAccessPort: int;
+        fileAccessSSL: boolean;
+    }
+
+    export interface DFUFileAccessResponse {
+        Exceptions: Exceptions;
+        AccessInfo: AccessInfo;
+        Type: DFUFileType;
+    }
+
+    export interface DFUFileAccessV2Request {
+        Name?: string;
+        Cluster?: string;
+        RequestId?: string;
+        ExpirySeconds?: int;
+        ReturnTextResponse?: boolean;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+    }
+
+    export interface PartLocations {
+        Item: string[];
+    }
+
+    export interface DFUFileCreateRequest {
+        ECLRecordDefinition?: string;
+        PartLocations?: PartLocations;
+        RequestBase?: RequestBase;
+    }
+
+    export interface DFUFileCreateResponse {
+        Exceptions: Exceptions;
+        FileId: string;
+        Warning: string;
+        AccessInfo: AccessInfo;
+    }
+
+    export interface DFUFileCreateV2Request {
+        Name?: string;
+        Cluster?: string;
+        Type?: DFUFileType;
+        ECLRecordDefinition?: string;
+        RequestId?: string;
+        ExpirySeconds?: int;
+        ReturnTextResponse?: boolean;
+        Compressed?: boolean;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+    }
+
+    export interface DFUFilePublishRequest {
+        FileId?: string;
+        Overwrite?: boolean;
+        FileDescriptorBlob?: base64Binary;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+        ECLRecordDefinition?: string;
+        RecordCount?: long;
+        FileSize?: long;
+    }
+
+    export interface DFUFilePublishResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface DFUFileViewRequest {
+        Scope?: string;
+        IncludeSuperOwner?: boolean;
+    }
+
+    export interface DFULogicalFile {
+        Prefix: string;
+        NodeGroup: string;
+        Directory: string;
+        Description: string;
+        Parts: string;
+        Name: string;
+        Owner: string;
+        Totalsize: string;
+        RecordCount: string;
+        Modified: string;
+        LongSize: string;
+        LongRecordCount: string;
+        isSuperfile: boolean;
+        isDirectory: boolean;
+        Replicate: boolean;
+        IntSize: long;
+        IntRecordCount: long;
+        FromRoxieCluster: boolean;
+        BrowseData: boolean;
+        IsCompressed: boolean;
+        ContentType: string;
+        CompressedFileSize: long;
+        SuperOwners: string;
+        Persistent: boolean;
+        IsProtected: boolean;
+        KeyType: string;
+        NumOfSubfiles: int;
+        Accessed: string;
+        AtRestCost: double;
+        AccessCost: double;
+        MinSkew: long;
+        MaxSkew: long;
+        MinSkewPart: long;
+        MaxSkewPart: long;
+    }
+
+    export interface DFULogicalFiles {
+        DFULogicalFile: DFULogicalFile[];
+    }
+
+    export interface DFUFileViewResponse {
+        Exceptions: Exceptions;
+        Scope: string;
+        NumFiles: int;
+        DFULogicalFiles: DFULogicalFiles;
+    }
+
+    export interface DFUGetDataColumnsRequest {
+        OpenLogicalName?: string;
+        LogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        ChooseFile?: int;
+        Cluster?: string;
+        ClusterType?: string;
+        StartIndex?: long;
+        EndIndex?: long;
+    }
+
+    export interface DFUDataKeyedColumns1 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns2 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns3 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns4 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns5 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns6 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns7 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns8 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns9 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns10 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns11 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns12 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns13 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns14 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns15 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns16 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns17 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns18 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns19 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns20 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns1 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns2 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns3 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns4 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns5 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns6 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns7 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns8 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns9 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns10 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns11 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns12 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns13 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns14 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns15 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns16 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns17 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns18 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns19 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns20 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUGetDataColumnsResponse {
+        Exceptions: Exceptions;
+        LogicalName: string;
+        StartIndex: long;
+        EndIndex: long;
+        DFUDataKeyedColumns1: DFUDataKeyedColumns1;
+        DFUDataKeyedColumns2: DFUDataKeyedColumns2;
+        DFUDataKeyedColumns3: DFUDataKeyedColumns3;
+        DFUDataKeyedColumns4: DFUDataKeyedColumns4;
+        DFUDataKeyedColumns5: DFUDataKeyedColumns5;
+        DFUDataKeyedColumns6: DFUDataKeyedColumns6;
+        DFUDataKeyedColumns7: DFUDataKeyedColumns7;
+        DFUDataKeyedColumns8: DFUDataKeyedColumns8;
+        DFUDataKeyedColumns9: DFUDataKeyedColumns9;
+        DFUDataKeyedColumns10: DFUDataKeyedColumns10;
+        DFUDataKeyedColumns11: DFUDataKeyedColumns11;
+        DFUDataKeyedColumns12: DFUDataKeyedColumns12;
+        DFUDataKeyedColumns13: DFUDataKeyedColumns13;
+        DFUDataKeyedColumns14: DFUDataKeyedColumns14;
+        DFUDataKeyedColumns15: DFUDataKeyedColumns15;
+        DFUDataKeyedColumns16: DFUDataKeyedColumns16;
+        DFUDataKeyedColumns17: DFUDataKeyedColumns17;
+        DFUDataKeyedColumns18: DFUDataKeyedColumns18;
+        DFUDataKeyedColumns19: DFUDataKeyedColumns19;
+        DFUDataKeyedColumns20: DFUDataKeyedColumns20;
+        DFUDataNonKeyedColumns1: DFUDataNonKeyedColumns1;
+        DFUDataNonKeyedColumns2: DFUDataNonKeyedColumns2;
+        DFUDataNonKeyedColumns3: DFUDataNonKeyedColumns3;
+        DFUDataNonKeyedColumns4: DFUDataNonKeyedColumns4;
+        DFUDataNonKeyedColumns5: DFUDataNonKeyedColumns5;
+        DFUDataNonKeyedColumns6: DFUDataNonKeyedColumns6;
+        DFUDataNonKeyedColumns7: DFUDataNonKeyedColumns7;
+        DFUDataNonKeyedColumns8: DFUDataNonKeyedColumns8;
+        DFUDataNonKeyedColumns9: DFUDataNonKeyedColumns9;
+        DFUDataNonKeyedColumns10: DFUDataNonKeyedColumns10;
+        DFUDataNonKeyedColumns11: DFUDataNonKeyedColumns11;
+        DFUDataNonKeyedColumns12: DFUDataNonKeyedColumns12;
+        DFUDataNonKeyedColumns13: DFUDataNonKeyedColumns13;
+        DFUDataNonKeyedColumns14: DFUDataNonKeyedColumns14;
+        DFUDataNonKeyedColumns15: DFUDataNonKeyedColumns15;
+        DFUDataNonKeyedColumns16: DFUDataNonKeyedColumns16;
+        DFUDataNonKeyedColumns17: DFUDataNonKeyedColumns17;
+        DFUDataNonKeyedColumns18: DFUDataNonKeyedColumns18;
+        DFUDataNonKeyedColumns19: DFUDataNonKeyedColumns19;
+        DFUDataNonKeyedColumns20: DFUDataNonKeyedColumns20;
+        RowCount: long;
+        ShowColumns: string;
+        ChooseFile: int;
+        Cluster: string;
+        ClusterType: string;
+    }
+
+    export interface DFUGetFileMetaDataRequest {
+        LogicalFileName?: string;
+        ClusterName?: string;
+        IncludeXmlSchema?: boolean;
+        AddHeaderInXmlSchema?: boolean;
+        IncludeXmlXPathSchema?: boolean;
+        AddHeaderInXmlXPathSchema?: boolean;
+    }
+
+    export interface DFUGetFileMetaDataResponse {
+        Exceptions: Exceptions;
+        TotalColumnCount: int;
+        KeyedColumnCount: int;
+        DataColumns: DataColumns;
+        XmlSchema: string;
+        XmlXPathSchema: string;
+        TotalResultRows: long;
+    }
+
+    export interface DFUMetaInquiryRequest {
+
+    }
+
+    export interface DFUMetaFieldInfo {
+        Name: string;
+        Type: string;
+    }
+
+    export interface Fields {
+        DFUMetaFieldInfo: DFUMetaFieldInfo[];
+    }
+
+    export interface DFUMetaInquiryResponse {
+        Exceptions: Exceptions;
+        Fields: Fields;
+    }
+
+    export interface DFUInfoRequest {
+        Name?: string;
+        Cluster?: string;
+        UpdateDescription?: boolean;
+        QuerySet?: string;
+        Query?: string;
+        FileDesc?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+        Protect?: DFUChangeProtection;
+        Restrict?: DFUChangeRestriction;
+        ForceIndexInfo?: boolean;
+    }
+
+    export interface Stat {
+        MinSkew: string;
+        MaxSkew: string;
+        MinSkewInt64: long;
+        MaxSkewInt64: long;
+        MinSkewPart: long;
+        MaxSkewPart: long;
+    }
+
+    export interface DFUPart {
+        Id: int;
+        Copy: int;
+        Ip: string;
+        Partsize: string;
+        PartSizeInt64: long;
+        CompressedSize: long;
+    }
+
+    export interface DFUFileParts {
+        DFUPart: DFUPart[];
+    }
+
+    export interface DFUFilePartsOnCluster {
+        Cluster: string;
+        BaseDir: string;
+        ReplicateDir: string;
+        Replicate: boolean;
+        CanReplicate: boolean;
+        DFUFileParts: DFUFileParts;
+    }
+
+    export interface DFUFilePartsOnClusters {
+        DFUFilePartsOnCluster: DFUFilePartsOnCluster[];
+    }
+
+    export interface subfiles {
+        Item: string[];
+    }
+
+    export interface Superfiles {
+        DFULogicalFile: DFULogicalFile[];
+    }
+
+    export interface DFUFileProtect {
+        Owner: string;
+        Modified: string;
+    }
+
+    export interface ProtectList {
+        DFUFileProtect: DFUFileProtect[];
+    }
+
+    export interface Graphs {
+        ECLGraph: string[];
+    }
+
+    export interface FieldNames {
+        Item: string[];
+    }
+
+    export interface Partition {
+        FieldMask: long;
+        FieldNames: FieldNames;
+    }
+
+    export interface DFUFileBloom {
+        FieldMask: long;
+        FieldNames: FieldNames;
+        Limit: long;
+        Probability: string;
+    }
+
+    export interface Blooms {
+        DFUFileBloom: DFUFileBloom[];
+    }
+
+    export interface ExtendedIndexInfo {
+        IsLeafCountEstimated: boolean;
+        NumLeafNodes: long;
+        NumBlobNodes: long;
+        NumBranchNodes: long;
+        SizeDiskLeaves: long;
+        SizeDiskBlobs: long;
+        SizeDiskBranches: long;
+        SizeOriginalData: long;
+        SizeOriginalBranches: long;
+        SizeMemoryLeaves: long;
+        SizeMemoryBranches: long;
+        BranchCompressionPercent: double;
+        DataCompressionPercent: double;
+    }
+
+    export interface FileDetail {
+        Name: string;
+        Filename: string;
+        Prefix: string;
+        NodeGroup: string;
+        NumParts: int;
+        Description: string;
+        Dir: string;
+        PathMask: string;
+        Filesize: string;
+        FileSizeInt64: long;
+        RecordSize: string;
+        RecordCount: string;
+        RecordSizeInt64: long;
+        RecordCountInt64: long;
+        Wuid: string;
+        Owner: string;
+        JobName: string;
+        Persistent: string;
+        Format: string;
+        MaxRecordSize: string;
+        CsvSeparate: string;
+        CsvQuote: string;
+        CsvTerminate: string;
+        CsvEscape: string;
+        Modified: string;
+        Ecl: string;
+        Stat: Stat;
+        DFUFilePartsOnClusters: DFUFilePartsOnClusters;
+        isSuperfile: boolean;
+        ShowFileContent: boolean;
+        subfiles: subfiles;
+        Superfiles: Superfiles;
+        ProtectList: ProtectList;
+        FromRoxieCluster: boolean;
+        Graphs: Graphs;
+        UserPermission: string;
+        ContentType: string;
+        CompressedFileSize: long;
+        PercentCompressed: string;
+        IsCompressed: boolean;
+        IsRestricted: boolean;
+        BrowseData: boolean;
+        jsonInfo: string;
+        binInfo: base64Binary;
+        PackageID: string;
+        Partition: Partition;
+        Blooms: Blooms;
+        ExpireDays: int;
+        KeyType: string;
+        AtRestCost: double;
+        AccessCost: double;
+        ExpirationDate: string;
+        ExtendedIndexInfo: ExtendedIndexInfo;
+    }
+
+    export interface DFUInfoResponse {
+        Exceptions: Exceptions;
+        FileDetail: FileDetail;
+    }
+
+    export interface DFUQueryRequest {
+        Prefix?: string;
+        NodeGroup?: string;
+        ContentType?: string;
+        InvertContent?: boolean;
+        LogicalName?: string;
+        Owner?: string;
+        StartDate?: string;
+        EndDate?: string;
+        FileType?: string;
+        FileSizeFrom?: long;
+        FileSizeTo?: long;
+        FirstN?: int;
+        PageSize?: int;
+        PageStartFrom?: int;
+        Sortby?: string;
+        Fields?: string;
+        Descending?: boolean;
+        OneLevelDirFileReturn?: boolean;
+        CacheHint?: long;
+        MaxNumberOfFiles?: int;
+        IncludeSuperOwner?: boolean;
+        StartAccessedTime?: string;
+        EndAccessedTime?: string;
+        MaxSkewFrom?: long;
+        MaxSkewTo?: long;
+        MinSkewFrom?: long;
+        MinSkewTo?: long;
+    }
+
+    export interface DFUQueryResponse {
+        Exceptions: Exceptions;
+        DFULogicalFiles: DFULogicalFiles;
+        Prefix: string;
+        NodeGroup: string;
+        LogicalName: string;
+        Description: string;
+        Owner: string;
+        StartDate: string;
+        EndDate: string;
+        FileType: string;
+        FileSizeFrom: long;
+        FileSizeTo: long;
+        FirstN: int;
+        PageSize: int;
+        PageStartFrom: long;
+        LastPageFrom: long;
+        PageEndAt: long;
+        PrevPageFrom: long;
+        NextPageFrom: long;
+        NumFiles: long;
+        Sortby: string;
+        Descending: boolean;
+        BasicQuery: string;
+        ParametersForPaging: string;
+        Filters: string;
+        CacheHint: long;
+        IsSubsetOfFiles: boolean;
+        Warning: string;
+    }
+
+    export interface DFURecordTypeInfoRequest {
+        Name?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+    }
+
+    export interface DFURecordTypeInfoResponse {
+        jsonInfo: string;
+        binInfo: base64Binary;
+    }
+
+    export interface DFUSearchRequest {
+        ShowExample?: string;
+    }
+
+    export interface ClusterNames {
+        ClusterName: string[];
+    }
+
+    export interface FileTypes {
+        FileType: string[];
+    }
+
+    export interface DFUSearchResponse {
+        Exceptions: Exceptions;
+        ShowExample: string;
+        ClusterNames: ClusterNames;
+        FileTypes: FileTypes;
+    }
+
+    export interface DFUSearchDataRequest {
+        Cluster?: string;
+        ClusterType?: string;
+        OpenLogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        ChooseFile?: int;
+        StartIndex?: long;
+        EndIndex?: long;
+        LogicalName?: string;
+        ParentName?: string;
+        StartForGoback?: long;
+        CountForGoback?: int;
+        Start?: long;
+        Count?: int;
+        File?: string;
+        Key?: string;
+        SchemaOnly?: boolean;
+        RoxieSelections?: boolean;
+        DisableUppercaseTranslation?: boolean;
+        SelectedKey?: string;
+    }
+
+    export interface DFUSearchDataResponse {
+        Exceptions: Exceptions;
+        OpenLogicalName: string;
+        LogicalName: string;
+        ParentName: string;
+        StartIndex: long;
+        EndIndex: long;
+        DFUDataKeyedColumns1: DFUDataKeyedColumns1;
+        DFUDataKeyedColumns2: DFUDataKeyedColumns2;
+        DFUDataKeyedColumns3: DFUDataKeyedColumns3;
+        DFUDataKeyedColumns4: DFUDataKeyedColumns4;
+        DFUDataKeyedColumns5: DFUDataKeyedColumns5;
+        DFUDataKeyedColumns6: DFUDataKeyedColumns6;
+        DFUDataKeyedColumns7: DFUDataKeyedColumns7;
+        DFUDataKeyedColumns8: DFUDataKeyedColumns8;
+        DFUDataKeyedColumns9: DFUDataKeyedColumns9;
+        DFUDataKeyedColumns10: DFUDataKeyedColumns10;
+        DFUDataKeyedColumns11: DFUDataKeyedColumns11;
+        DFUDataKeyedColumns12: DFUDataKeyedColumns12;
+        DFUDataKeyedColumns13: DFUDataKeyedColumns13;
+        DFUDataKeyedColumns14: DFUDataKeyedColumns14;
+        DFUDataKeyedColumns15: DFUDataKeyedColumns15;
+        DFUDataKeyedColumns16: DFUDataKeyedColumns16;
+        DFUDataKeyedColumns17: DFUDataKeyedColumns17;
+        DFUDataKeyedColumns18: DFUDataKeyedColumns18;
+        DFUDataKeyedColumns19: DFUDataKeyedColumns19;
+        DFUDataKeyedColumns20: DFUDataKeyedColumns20;
+        DFUDataNonKeyedColumns1: DFUDataNonKeyedColumns1;
+        DFUDataNonKeyedColumns2: DFUDataNonKeyedColumns2;
+        DFUDataNonKeyedColumns3: DFUDataNonKeyedColumns3;
+        DFUDataNonKeyedColumns4: DFUDataNonKeyedColumns4;
+        DFUDataNonKeyedColumns5: DFUDataNonKeyedColumns5;
+        DFUDataNonKeyedColumns6: DFUDataNonKeyedColumns6;
+        DFUDataNonKeyedColumns7: DFUDataNonKeyedColumns7;
+        DFUDataNonKeyedColumns8: DFUDataNonKeyedColumns8;
+        DFUDataNonKeyedColumns9: DFUDataNonKeyedColumns9;
+        DFUDataNonKeyedColumns10: DFUDataNonKeyedColumns10;
+        DFUDataNonKeyedColumns11: DFUDataNonKeyedColumns11;
+        DFUDataNonKeyedColumns12: DFUDataNonKeyedColumns12;
+        DFUDataNonKeyedColumns13: DFUDataNonKeyedColumns13;
+        DFUDataNonKeyedColumns14: DFUDataNonKeyedColumns14;
+        DFUDataNonKeyedColumns15: DFUDataNonKeyedColumns15;
+        DFUDataNonKeyedColumns16: DFUDataNonKeyedColumns16;
+        DFUDataNonKeyedColumns17: DFUDataNonKeyedColumns17;
+        DFUDataNonKeyedColumns18: DFUDataNonKeyedColumns18;
+        DFUDataNonKeyedColumns19: DFUDataNonKeyedColumns19;
+        DFUDataNonKeyedColumns20: DFUDataNonKeyedColumns20;
+        RowCount: long;
+        ShowColumns: string;
+        ChooseFile: int;
+        Name: string;
+        FilterBy: string;
+        FilterForGoBack: string;
+        ColumnsHidden: ColumnsHidden;
+        ColumnCount: int;
+        StartForGoback: long;
+        CountForGoback: int;
+        Start: long;
+        Count: long;
+        PageSize: long;
+        Total: long;
+        Result: string;
+        MsgToDisplay: string;
+        Cluster: string;
+        ClusterType: string;
+        File: string;
+        Key: string;
+        SchemaOnly: boolean;
+        RoxieSelections: boolean;
+        DisableUppercaseTranslation: boolean;
+        AutoUppercaseTranslation: boolean;
+        SelectedKey: string;
+    }
+
+    export interface DFUSpaceRequest {
+        CountBy?: string;
+        ScopeUnder?: string;
+        OwnerUnder?: string;
+        Interval?: string;
+        StartDate?: string;
+        EndDate?: string;
+    }
+
+    export interface DFUSpaceItem {
+        Name: string;
+        NumOfFiles: string;
+        NumOfFilesUnknown: string;
+        TotalSize: string;
+        LargestFile: string;
+        LargestSize: string;
+        SmallestFile: string;
+        SmallestSize: string;
+        NumOfFilesInt64: long;
+        NumOfFilesUnknownInt64: long;
+        TotalSizeInt64: long;
+        LargestSizeInt64: long;
+        SmallestSizeInt64: long;
+    }
+
+    export interface DFUSpaceItems {
+        DFUSpaceItem: DFUSpaceItem[];
+    }
+
+    export interface DFUSpaceResponse {
+        Exceptions: Exceptions;
+        CountBy: string;
+        ScopeUnder: string;
+        OwnerUnder: string;
+        Interval: string;
+        StartDate: string;
+        EndDate: string;
+        DFUSpaceItems: DFUSpaceItems;
+    }
+
+    export interface EclRecordTypeInfoRequest {
+        Ecl?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+    }
+
+    export interface EclRecordTypeInfoResponse {
+        jsonInfo: string;
+        binInfo: base64Binary;
+    }
+
+    export interface EraseHistoryRequest {
+        Name?: string;
+    }
+
+    export interface Origin {
+        Name: string;
+        Operation: string;
+        Timestamp: string;
+        IP: string;
+        Path: string;
+        Owner: string;
+        Workunit: string;
+    }
+
+    export interface History {
+        Origin: Origin[];
+    }
+
+    export interface EraseHistoryResponse {
+        Exceptions: Exceptions;
+        History: History;
+    }
+
+    export interface ListHistoryRequest {
+        Name?: string;
+    }
+
+    export interface ListHistoryResponse {
+        Exceptions: Exceptions;
+        History: History;
+    }
+
+    export interface WsDfuPingRequest {
+
+    }
+
+    export interface WsDfuPingResponse {
+
+    }
+
+    export interface SavexmlRequest {
+        name?: string;
+    }
+
+    export interface SavexmlResponse {
+        Exceptions: Exceptions;
+        xmlmap: base64Binary;
+    }
+
+    export interface SuperfileActionRequest {
+        action?: string;
+        superfile?: string;
+        subfiles?: subfiles;
+        before?: string;
+        delete?: boolean;
+        removeSuperfile?: boolean;
+    }
+
+    export interface SuperfileActionResponse {
+        Exceptions: Exceptions;
+        superfile: string;
+        retcode: int;
+    }
+
+    export interface SuperfileListRequest {
+        superfile?: string;
+    }
+
+    export interface SuperfileListResponse {
+        Exceptions: Exceptions;
+        superfile: string;
+        subfiles: subfiles;
+    }
+
+}
+
+export class DfuServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsDfu", "1.66");
+    }
+
+    Add(request: Partial<WsDfu.AddRequest>): Promise<WsDfu.AddResponse> {
+        return this._connection.send("Add", request, "json", false, undefined, "AddResponse");
+    }
+
+    AddRemote(request: Partial<WsDfu.AddRemoteRequest>): Promise<WsDfu.AddRemoteResponse> {
+        return this._connection.send("AddRemote", request, "json", false, undefined, "AddRemoteResponse");
+    }
+
+    AddtoSuperfile(request: Partial<WsDfu.AddtoSuperfileRequest>): Promise<WsDfu.AddtoSuperfileResponse> {
+        return this._connection.send("AddtoSuperfile", request, "json", false, undefined, "AddtoSuperfileResponse");
+    }
+
+    DFUArrayAction(request: Partial<WsDfu.DFUArrayActionRequest>): Promise<WsDfu.DFUArrayActionResponse> {
+        return this._connection.send("DFUArrayAction", request, "json", false, undefined, "DFUArrayActionResponse");
+    }
+
+    DFUBrowseData(request: Partial<WsDfu.DFUBrowseDataRequest>): Promise<WsDfu.DFUBrowseDataResponse> {
+        return this._connection.send("DFUBrowseData", request, "json", false, undefined, "DFUBrowseDataResponse");
+    }
+
+    DFUDefFile(request: Partial<WsDfu.DFUDefFileRequest>): Promise<WsDfu.DFUDefFileResponse> {
+        return this._connection.send("DFUDefFile", request, "json", false, undefined, "DFUDefFileResponse");
+    }
+
+    DFUFileAccess(request: Partial<WsDfu.DFUFileAccessRequest>): Promise<WsDfu.DFUFileAccessResponse> {
+        return this._connection.send("DFUFileAccess", request, "json", false, undefined, "DFUFileAccessResponse");
+    }
+
+    DFUFileAccessV2(request: Partial<WsDfu.DFUFileAccessV2Request>): Promise<WsDfu.DFUFileAccessResponse> {
+        return this._connection.send("DFUFileAccessV2", request, "json", false, undefined, "DFUFileAccessResponse");
+    }
+
+    DFUFileCreate(request: Partial<WsDfu.DFUFileCreateRequest>): Promise<WsDfu.DFUFileCreateResponse> {
+        return this._connection.send("DFUFileCreate", request, "json", false, undefined, "DFUFileCreateResponse");
+    }
+
+    DFUFileCreateV2(request: Partial<WsDfu.DFUFileCreateV2Request>): Promise<WsDfu.DFUFileCreateResponse> {
+        return this._connection.send("DFUFileCreateV2", request, "json", false, undefined, "DFUFileCreateResponse");
+    }
+
+    DFUFilePublish(request: Partial<WsDfu.DFUFilePublishRequest>): Promise<WsDfu.DFUFilePublishResponse> {
+        return this._connection.send("DFUFilePublish", request, "json", false, undefined, "DFUFilePublishResponse");
+    }
+
+    DFUFileView(request: Partial<WsDfu.DFUFileViewRequest>): Promise<WsDfu.DFUFileViewResponse> {
+        return this._connection.send("DFUFileView", request, "json", false, undefined, "DFUFileViewResponse");
+    }
+
+    DFUGetDataColumns(request: Partial<WsDfu.DFUGetDataColumnsRequest>): Promise<WsDfu.DFUGetDataColumnsResponse> {
+        return this._connection.send("DFUGetDataColumns", request, "json", false, undefined, "DFUGetDataColumnsResponse");
+    }
+
+    DFUGetFileMetaData(request: Partial<WsDfu.DFUGetFileMetaDataRequest>): Promise<WsDfu.DFUGetFileMetaDataResponse> {
+        return this._connection.send("DFUGetFileMetaData", request, "json", false, undefined, "DFUGetFileMetaDataResponse");
+    }
+
+    DFUGetMetaInquiry(request: Partial<WsDfu.DFUMetaInquiryRequest>): Promise<WsDfu.DFUMetaInquiryResponse> {
+        return this._connection.send("DFUGetMetaInquiry", request, "json", false, undefined, "DFUMetaInquiryResponse");
+    }
+
+    DFUInfo(request: Partial<WsDfu.DFUInfoRequest>): Promise<WsDfu.DFUInfoResponse> {
+        return this._connection.send("DFUInfo", request, "json", false, undefined, "DFUInfoResponse");
+    }
+
+    DFUQuery(request: Partial<WsDfu.DFUQueryRequest>): Promise<WsDfu.DFUQueryResponse> {
+        return this._connection.send("DFUQuery", request, "json", false, undefined, "DFUQueryResponse");
+    }
+
+    DFURecordTypeInfo(request: Partial<WsDfu.DFURecordTypeInfoRequest>): Promise<WsDfu.DFURecordTypeInfoResponse> {
+        return this._connection.send("DFURecordTypeInfo", request, "json", false, undefined, "DFURecordTypeInfoResponse");
+    }
+
+    DFUSearch(request: Partial<WsDfu.DFUSearchRequest>): Promise<WsDfu.DFUSearchResponse> {
+        return this._connection.send("DFUSearch", request, "json", false, undefined, "DFUSearchResponse");
+    }
+
+    DFUSearchData(request: Partial<WsDfu.DFUSearchDataRequest>): Promise<WsDfu.DFUSearchDataResponse> {
+        return this._connection.send("DFUSearchData", request, "json", false, undefined, "DFUSearchDataResponse");
+    }
+
+    DFUSpace(request: Partial<WsDfu.DFUSpaceRequest>): Promise<WsDfu.DFUSpaceResponse> {
+        return this._connection.send("DFUSpace", request, "json", false, undefined, "DFUSpaceResponse");
+    }
+
+    EclRecordTypeInfo(request: Partial<WsDfu.EclRecordTypeInfoRequest>): Promise<WsDfu.EclRecordTypeInfoResponse> {
+        return this._connection.send("EclRecordTypeInfo", request, "json", false, undefined, "EclRecordTypeInfoResponse");
+    }
+
+    EraseHistory(request: Partial<WsDfu.EraseHistoryRequest>): Promise<WsDfu.EraseHistoryResponse> {
+        return this._connection.send("EraseHistory", request, "json", false, undefined, "EraseHistoryResponse");
+    }
+
+    ListHistory(request: Partial<WsDfu.ListHistoryRequest>): Promise<WsDfu.ListHistoryResponse> {
+        return this._connection.send("ListHistory", request, "json", false, undefined, "ListHistoryResponse");
+    }
+
+    Ping(request: Partial<WsDfu.WsDfuPingRequest>): Promise<WsDfu.WsDfuPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsDfuPingResponse");
+    }
+
+    Savexml(request: Partial<WsDfu.SavexmlRequest>): Promise<WsDfu.SavexmlResponse> {
+        return this._connection.send("Savexml", request, "json", false, undefined, "SavexmlResponse");
+    }
+
+    SuperfileAction(request: Partial<WsDfu.SuperfileActionRequest>): Promise<WsDfu.SuperfileActionResponse> {
+        return this._connection.send("SuperfileAction", request, "json", false, undefined, "SuperfileActionResponse");
+    }
+
+    SuperfileList(request: Partial<WsDfu.SuperfileListRequest>): Promise<WsDfu.SuperfileListResponse> {
+        return this._connection.send("SuperfileList", request, "json", false, undefined, "SuperfileListResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsDfu/v1.67/WsDfu.ts b/packages/comms/src/services/wsdl/WsDfu/v1.67/WsDfu.ts
new file mode 100644
index 0000000000..9313ace7a5
--- /dev/null
+++ b/packages/comms/src/services/wsdl/WsDfu/v1.67/WsDfu.ts
@@ -0,0 +1,1268 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsDfu {
+
+    export type base64Binary = string;
+    export type long = number;
+    export type int = number;
+    export type double = number;
+
+    export enum DFUArrayActions {
+        Delete = "Delete",
+        AddToSuperfile = "Add To Superfile",
+        ChangeProtection = "Change Protection",
+        ChangeRestriction = "Change Restriction"
+    }
+
+    export enum DFUChangeProtection {
+        NoChange = 0,
+        Protect = 1,
+        Unprotect = 2,
+        UnprotectAll = 3
+    }
+
+    export enum DFUChangeRestriction {
+        NoChange = 0,
+        Restrict = 1,
+        Unrestricted = 2
+    }
+
+    export enum DFUDefFileFormat {
+        xml = "xml",
+        def = "def"
+    }
+
+    export enum FileAccessRole {
+        Token = "Token",
+        Engine = "Engine",
+        External = "External"
+    }
+
+    export enum SecAccessType {
+        None = "None",
+        Access = "Access",
+        Read = "Read",
+        Write = "Write",
+        Full = "Full"
+    }
+
+    export enum DFUFileType {
+        Flat = "Flat",
+        Index = "Index",
+        Xml = "Xml",
+        Csv = "Csv",
+        Json = "Json",
+        IndexLocal = "IndexLocal",
+        IndexPartitioned = "IndexPartitioned",
+        Unset = "Unset"
+    }
+
+    export interface AddRequest {
+        dstname?: string;
+        xmlmap?: base64Binary;
+        dstcluster?: string;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface AddResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface AddRemoteRequest {
+        dstname?: string;
+        srcname?: string;
+        srcdali?: string;
+        srcusername?: string;
+        srcpassword?: string;
+    }
+
+    export interface AddRemoteResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface names {
+        Item: string[];
+    }
+
+    export interface AddtoSuperfileRequest {
+        Superfile?: string;
+        Subfiles?: string;
+        names?: names;
+        ExistingFile?: boolean;
+        BackToPage?: string;
+    }
+
+    export interface SubfileNames {
+        SubfileName: string[];
+    }
+
+    export interface AddtoSuperfileResponse {
+        Exceptions: Exceptions;
+        Subfiles: string;
+        BackToPage: string;
+        SubfileNames: SubfileNames;
+    }
+
+    export interface LogicalFiles {
+        Item: string[];
+    }
+
+    export interface DFUArrayActionRequest {
+        Type?: DFUArrayActions;
+        NoDelete?: boolean;
+        BackToPage?: string;
+        LogicalFiles?: LogicalFiles;
+        removeFromSuperfiles?: boolean;
+        removeRecursively?: boolean;
+        Protect?: DFUChangeProtection;
+        Restrict?: DFUChangeRestriction;
+    }
+
+    export interface DFUActionInfo {
+        FileName: string;
+        NodeGroup: string;
+        ActionResult: string;
+        Failed: boolean;
+    }
+
+    export interface ActionResults {
+        DFUActionInfo: DFUActionInfo[];
+    }
+
+    export interface DFUArrayActionResponse {
+        Exceptions: Exceptions;
+        BackToPage: string;
+        RedirectTo: string;
+        ActionResults: ActionResults;
+    }
+
+    export interface DFUBrowseDataRequest {
+        LogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        SchemaOnly?: boolean;
+        StartForGoback?: long;
+        CountForGoback?: int;
+        ChooseFile?: int;
+        Cluster?: string;
+        ClusterType?: string;
+        ParentName?: string;
+        Start?: long;
+        Count?: int;
+        DisableUppercaseTranslation?: boolean;
+    }
+
+    export interface DFUDataColumn {
+        ColumnID: int;
+        ColumnLabel: string;
+        ColumnType: string;
+        ColumnValue: string;
+        ColumnSize: int;
+        MaxSize: int;
+        ColumnEclType: string;
+        ColumnRawSize: int;
+        IsNaturalColumn: boolean;
+        IsKeyedColumn: boolean;
+        DataColumns: DataColumns;
+    }
+
+    export interface DataColumns {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface ColumnHidden {
+        ColumnID: int;
+        ColumnLabel: string;
+        ColumnType: string;
+        ColumnValue: string;
+        ColumnSize: int;
+        MaxSize: int;
+        ColumnEclType: string;
+        ColumnRawSize: int;
+        IsNaturalColumn: boolean;
+        IsKeyedColumn: boolean;
+        DataColumns: DataColumns;
+    }
+
+    export interface ColumnsHidden {
+        ColumnHidden: ColumnHidden[];
+    }
+
+    export interface DFUBrowseDataResponse {
+        Exceptions: Exceptions;
+        Name: string;
+        LogicalName: string;
+        FilterBy: string;
+        FilterForGoBack: string;
+        ColumnsHidden: ColumnsHidden;
+        ColumnCount: int;
+        StartForGoback: long;
+        CountForGoback: int;
+        ChooseFile: int;
+        SchemaOnly: boolean;
+        Cluster: string;
+        ClusterType: string;
+        ParentName: string;
+        Start: long;
+        Count: long;
+        PageSize: long;
+        Total: long;
+        Result: string;
+        MsgToDisplay: string;
+        DisableUppercaseTranslation: boolean;
+    }
+
+    export interface DFUDefFileRequest {
+        Name?: string;
+        Format?: DFUDefFileFormat;
+    }
+
+    export interface DFUDefFileResponse {
+        Exceptions: Exceptions;
+        defFile: base64Binary;
+    }
+
+    export interface RequestBase {
+        Name: string;
+        Cluster: string;
+        JobId: string;
+        ExpirySeconds: int;
+        AccessRole: FileAccessRole;
+        AccessType: SecAccessType;
+        ReturnJsonTypeInfo: boolean;
+        ReturnBinTypeInfo: boolean;
+    }
+
+    export interface DFUFileAccessRequest {
+        RequestBase?: RequestBase;
+    }
+
+    export interface DFUPartLocation {
+        LocationIndex: int;
+        Host: string;
+    }
+
+    export interface FileLocations {
+        DFUPartLocation: DFUPartLocation[];
+    }
+
+    export interface DFUFileCopy {
+        CopyIndex: int;
+        LocationIndex: int;
+        Path: string;
+    }
+
+    export interface Copies {
+        DFUFileCopy: DFUFileCopy[];
+    }
+
+    export interface DFUFilePart {
+        PartIndex: int;
+        Copies: Copies;
+        TopLevelKey: boolean;
+    }
+
+    export interface FileParts {
+        DFUFilePart: DFUFilePart[];
+    }
+
+    export interface AccessInfo {
+        MetaInfoBlob: string;
+        ExpiryTime: string;
+        NumParts: int;
+        FileLocations: FileLocations;
+        FileParts: FileParts;
+        RecordTypeInfoJson: string;
+        fileAccessPort: int;
+        fileAccessSSL: boolean;
+    }
+
+    export interface DFUFileAccessResponse {
+        Exceptions: Exceptions;
+        AccessInfo: AccessInfo;
+        Type: DFUFileType;
+    }
+
+    export interface DFUFileAccessV2Request {
+        Name?: string;
+        Cluster?: string;
+        RequestId?: string;
+        ExpirySeconds?: int;
+        ReturnTextResponse?: boolean;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+    }
+
+    export interface PartLocations {
+        Item: string[];
+    }
+
+    export interface DFUFileCreateRequest {
+        ECLRecordDefinition?: string;
+        PartLocations?: PartLocations;
+        RequestBase?: RequestBase;
+    }
+
+    export interface DFUFileCreateResponse {
+        Exceptions: Exceptions;
+        FileId: string;
+        Warning: string;
+        AccessInfo: AccessInfo;
+    }
+
+    export interface DFUFileCreateV2Request {
+        Name?: string;
+        Cluster?: string;
+        Type?: DFUFileType;
+        ECLRecordDefinition?: string;
+        RequestId?: string;
+        ExpirySeconds?: int;
+        ReturnTextResponse?: boolean;
+        Compressed?: boolean;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+    }
+
+    export interface DFUFilePublishRequest {
+        FileId?: string;
+        Overwrite?: boolean;
+        FileDescriptorBlob?: base64Binary;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+        ECLRecordDefinition?: string;
+        RecordCount?: long;
+        FileSize?: long;
+    }
+
+    export interface DFUFilePublishResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface DFUFileViewRequest {
+        Scope?: string;
+        IncludeSuperOwner?: boolean;
+    }
+
+    export interface DFULogicalFile {
+        Prefix: string;
+        NodeGroup: string;
+        Directory: string;
+        Description: string;
+        Parts: string;
+        Name: string;
+        Owner: string;
+        Totalsize: string;
+        RecordCount: string;
+        Modified: string;
+        LongSize: string;
+        LongRecordCount: string;
+        isSuperfile: boolean;
+        isDirectory: boolean;
+        Replicate: boolean;
+        IntSize: long;
+        IntRecordCount: long;
+        FromRoxieCluster: boolean;
+        BrowseData: boolean;
+        IsCompressed: boolean;
+        ContentType: string;
+        CompressedFileSize: long;
+        SuperOwners: string;
+        Persistent: boolean;
+        IsProtected: boolean;
+        KeyType: string;
+        NumOfSubfiles: int;
+        Accessed: string;
+        AtRestCost: double;
+        AccessCost: double;
+        MinSkew: long;
+        MaxSkew: long;
+        MinSkewPart: long;
+        MaxSkewPart: long;
+    }
+
+    export interface DFULogicalFiles {
+        DFULogicalFile: DFULogicalFile[];
+    }
+
+    export interface DFUFileViewResponse {
+        Exceptions: Exceptions;
+        Scope: string;
+        NumFiles: int;
+        DFULogicalFiles: DFULogicalFiles;
+    }
+
+    export interface DFUGetDataColumnsRequest {
+        OpenLogicalName?: string;
+        LogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        ChooseFile?: int;
+        Cluster?: string;
+        ClusterType?: string;
+        StartIndex?: long;
+        EndIndex?: long;
+    }
+
+    export interface DFUDataKeyedColumns1 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns2 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns3 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns4 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns5 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns6 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns7 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns8 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns9 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns10 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns11 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns12 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns13 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns14 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns15 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns16 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns17 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns18 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns19 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataKeyedColumns20 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns1 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns2 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns3 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns4 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns5 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns6 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns7 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns8 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns9 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns10 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns11 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns12 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns13 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns14 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns15 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns16 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns17 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns18 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns19 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUDataNonKeyedColumns20 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+
+    export interface DFUGetDataColumnsResponse {
+        Exceptions: Exceptions;
+        LogicalName: string;
+        StartIndex: long;
+        EndIndex: long;
+        DFUDataKeyedColumns1: DFUDataKeyedColumns1;
+        DFUDataKeyedColumns2: DFUDataKeyedColumns2;
+        DFUDataKeyedColumns3: DFUDataKeyedColumns3;
+        DFUDataKeyedColumns4: DFUDataKeyedColumns4;
+        DFUDataKeyedColumns5: DFUDataKeyedColumns5;
+        DFUDataKeyedColumns6: DFUDataKeyedColumns6;
+        DFUDataKeyedColumns7: DFUDataKeyedColumns7;
+        DFUDataKeyedColumns8: DFUDataKeyedColumns8;
+        DFUDataKeyedColumns9: DFUDataKeyedColumns9;
+        DFUDataKeyedColumns10: DFUDataKeyedColumns10;
+        DFUDataKeyedColumns11: DFUDataKeyedColumns11;
+        DFUDataKeyedColumns12: DFUDataKeyedColumns12;
+        DFUDataKeyedColumns13: DFUDataKeyedColumns13;
+        DFUDataKeyedColumns14: DFUDataKeyedColumns14;
+        DFUDataKeyedColumns15: DFUDataKeyedColumns15;
+        DFUDataKeyedColumns16: DFUDataKeyedColumns16;
+        DFUDataKeyedColumns17: DFUDataKeyedColumns17;
+        DFUDataKeyedColumns18: DFUDataKeyedColumns18;
+        DFUDataKeyedColumns19: DFUDataKeyedColumns19;
+        DFUDataKeyedColumns20: DFUDataKeyedColumns20;
+        DFUDataNonKeyedColumns1: DFUDataNonKeyedColumns1;
+        DFUDataNonKeyedColumns2: DFUDataNonKeyedColumns2;
+        DFUDataNonKeyedColumns3: DFUDataNonKeyedColumns3;
+        DFUDataNonKeyedColumns4: DFUDataNonKeyedColumns4;
+        DFUDataNonKeyedColumns5: DFUDataNonKeyedColumns5;
+        DFUDataNonKeyedColumns6: DFUDataNonKeyedColumns6;
+        DFUDataNonKeyedColumns7: DFUDataNonKeyedColumns7;
+        DFUDataNonKeyedColumns8: DFUDataNonKeyedColumns8;
+        DFUDataNonKeyedColumns9: DFUDataNonKeyedColumns9;
+        DFUDataNonKeyedColumns10: DFUDataNonKeyedColumns10;
+        DFUDataNonKeyedColumns11: DFUDataNonKeyedColumns11;
+        DFUDataNonKeyedColumns12: DFUDataNonKeyedColumns12;
+        DFUDataNonKeyedColumns13: DFUDataNonKeyedColumns13;
+        DFUDataNonKeyedColumns14: DFUDataNonKeyedColumns14;
+        DFUDataNonKeyedColumns15: DFUDataNonKeyedColumns15;
+        DFUDataNonKeyedColumns16: DFUDataNonKeyedColumns16;
+        DFUDataNonKeyedColumns17: DFUDataNonKeyedColumns17;
+        DFUDataNonKeyedColumns18: DFUDataNonKeyedColumns18;
+        DFUDataNonKeyedColumns19: DFUDataNonKeyedColumns19;
+        DFUDataNonKeyedColumns20: DFUDataNonKeyedColumns20;
+        RowCount: long;
+        ShowColumns: string;
+        ChooseFile: int;
+        Cluster: string;
+        ClusterType: string;
+    }
+
+    export interface DFUGetFileMetaDataRequest {
+        LogicalFileName?: string;
+        ClusterName?: string;
+        IncludeXmlSchema?: boolean;
+        AddHeaderInXmlSchema?: boolean;
+        IncludeXmlXPathSchema?: boolean;
+        AddHeaderInXmlXPathSchema?: boolean;
+    }
+
+    export interface DFUGetFileMetaDataResponse {
+        Exceptions: Exceptions;
+        TotalColumnCount: int;
+        KeyedColumnCount: int;
+        DataColumns: DataColumns;
+        XmlSchema: string;
+        XmlXPathSchema: string;
+        TotalResultRows: long;
+    }
+
+    export interface DFUMetaInquiryRequest {
+
+    }
+
+    export interface DFUMetaFieldInfo {
+        Name: string;
+        Type: string;
+    }
+
+    export interface Fields {
+        DFUMetaFieldInfo: DFUMetaFieldInfo[];
+    }
+
+    export interface DFUMetaInquiryResponse {
+        Exceptions: Exceptions;
+        Fields: Fields;
+    }
+
+    export interface DFUInfoRequest {
+        Name?: string;
+        Cluster?: string;
+        UpdateDescription?: boolean;
+        QuerySet?: string;
+        Query?: string;
+        FileDesc?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+        Protect?: DFUChangeProtection;
+        Restrict?: DFUChangeRestriction;
+        ForceIndexInfo?: boolean;
+    }
+
+    export interface Stat {
+        MinSkew: string;
+        MaxSkew: string;
+        MinSkewInt64: long;
+        MaxSkewInt64: long;
+        MinSkewPart: long;
+        MaxSkewPart: long;
+    }
+
+    export interface DFUPart {
+        Id: int;
+        Copy: int;
+        Ip: string;
+        Partsize: string;
+        PartSizeInt64: long;
+        CompressedSize: long;
+    }
+
+    export interface DFUFileParts {
+        DFUPart: DFUPart[];
+    }
+
+    export interface DFUFilePartsOnCluster {
+        Cluster: string;
+        BaseDir: string;
+        ReplicateDir: string;
+        Replicate: boolean;
+        CanReplicate: boolean;
+        DFUFileParts: DFUFileParts;
+    }
+
+    export interface DFUFilePartsOnClusters {
+        DFUFilePartsOnCluster: DFUFilePartsOnCluster[];
+    }
+
+    export interface subfiles {
+        Item: string[];
+    }
+
+    export interface Superfiles {
+        DFULogicalFile: DFULogicalFile[];
+    }
+
+    export interface DFUFileProtect {
+        Owner: string;
+        Modified: string;
+    }
+
+    export interface ProtectList {
+        DFUFileProtect: DFUFileProtect[];
+    }
+
+    export interface Graphs {
+        ECLGraph: string[];
+    }
+
+    export interface FieldNames {
+        Item: string[];
+    }
+
+    export interface Partition {
+        FieldMask: long;
+        FieldNames: FieldNames;
+    }
+
+    export interface DFUFileBloom {
+        FieldMask: long;
+        FieldNames: FieldNames;
+        Limit: long;
+        Probability: string;
+    }
+
+    export interface Blooms {
+        DFUFileBloom: DFUFileBloom[];
+    }
+
+    export interface ExtendedIndexInfo {
+        IsLeafCountEstimated: boolean;
+        NumLeafNodes: long;
+        NumBlobNodes: long;
+        NumBranchNodes: long;
+        SizeDiskLeaves: long;
+        SizeDiskBlobs: long;
+        SizeDiskBranches: long;
+        SizeOriginalData: long;
+        SizeOriginalBranches: long;
+        SizeMemoryLeaves: long;
+        SizeMemoryBranches: long;
+        BranchCompressionPercent: double;
+        DataCompressionPercent: double;
+    }
+
+    export interface FileDetail {
+        Name: string;
+        Filename: string;
+        Prefix: string;
+        NodeGroup: string;
+        NumParts: int;
+        Description: string;
+        Dir: string;
+        PathMask: string;
+        Filesize: string;
+        FileSizeInt64: long;
+        RecordSize: string;
+        RecordCount: string;
+        RecordSizeInt64: long;
+        RecordCountInt64: long;
+        Wuid: string;
+        Owner: string;
+        JobName: string;
+        Persistent: string;
+        Format: string;
+        MaxRecordSize: string;
+        CsvSeparate: string;
+        CsvQuote: string;
+        CsvTerminate: string;
+        CsvEscape: string;
+        Modified: string;
+        Ecl: string;
+        Stat: Stat;
+        DFUFilePartsOnClusters: DFUFilePartsOnClusters;
+        isSuperfile: boolean;
+        ShowFileContent: boolean;
+        subfiles: subfiles;
+        Superfiles: Superfiles;
+        ProtectList: ProtectList;
+        FromRoxieCluster: boolean;
+        Graphs: Graphs;
+        UserPermission: string;
+        ContentType: string;
+        CompressedFileSize: long;
+        PercentCompressed: string;
+        IsCompressed: boolean;
+        IsRestricted: boolean;
+        BrowseData: boolean;
+        jsonInfo: string;
+        binInfo: base64Binary;
+        PackageID: string;
+        Partition: Partition;
+        Blooms: Blooms;
+        ExpireDays: int;
+        KeyType: string;
+        AtRestCost: double;
+        AccessCost: double;
+        ExpirationDate: string;
+        ExtendedIndexInfo: ExtendedIndexInfo;
+        CompressionType: string;
+    }
+
+    export interface DFUInfoResponse {
+        Exceptions: Exceptions;
+        FileDetail: FileDetail;
+    }
+
+    export interface DFUQueryRequest {
+        Prefix?: string;
+        NodeGroup?: string;
+        ContentType?: string;
+        InvertContent?: boolean;
+        LogicalName?: string;
+        Owner?: string;
+        StartDate?: string;
+        EndDate?: string;
+        FileType?: string;
+        FileSizeFrom?: long;
+        FileSizeTo?: long;
+        FirstN?: int;
+        PageSize?: int;
+        PageStartFrom?: int;
+        Sortby?: string;
+        Fields?: string;
+        Descending?: boolean;
+        OneLevelDirFileReturn?: boolean;
+        CacheHint?: long;
+        MaxNumberOfFiles?: int;
+        IncludeSuperOwner?: boolean;
+        StartAccessedTime?: string;
+        EndAccessedTime?: string;
+        MaxSkewFrom?: long;
+        MaxSkewTo?: long;
+        MinSkewFrom?: long;
+        MinSkewTo?: long;
+    }
+
+    export interface DFUQueryResponse {
+        Exceptions: Exceptions;
+        DFULogicalFiles: DFULogicalFiles;
+        Prefix: string;
+        NodeGroup: string;
+        LogicalName: string;
+        Description: string;
+        Owner: string;
+        StartDate: string;
+        EndDate: string;
+        FileType: string;
+        FileSizeFrom: long;
+        FileSizeTo: long;
+        FirstN: int;
+        PageSize: int;
+        PageStartFrom: long;
+        LastPageFrom: long;
+        PageEndAt: long;
+        PrevPageFrom: long;
+        NextPageFrom: long;
+        NumFiles: long;
+        Sortby: string;
+        Descending: boolean;
+        BasicQuery: string;
+        ParametersForPaging: string;
+        Filters: string;
+        CacheHint: long;
+        IsSubsetOfFiles: boolean;
+        Warning: string;
+    }
+
+    export interface DFURecordTypeInfoRequest {
+        Name?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+    }
+
+    export interface DFURecordTypeInfoResponse {
+        jsonInfo: string;
+        binInfo: base64Binary;
+    }
+
+    export interface DFUSearchRequest {
+        ShowExample?: string;
+    }
+
+    export interface ClusterNames {
+        ClusterName: string[];
+    }
+
+    export interface FileTypes {
+        FileType: string[];
+    }
+
+    export interface DFUSearchResponse {
+        Exceptions: Exceptions;
+        ShowExample: string;
+        ClusterNames: ClusterNames;
+        FileTypes: FileTypes;
+    }
+
+    export interface DFUSearchDataRequest {
+        Cluster?: string;
+        ClusterType?: string;
+        OpenLogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        ChooseFile?: int;
+        StartIndex?: long;
+        EndIndex?: long;
+        LogicalName?: string;
+        ParentName?: string;
+        StartForGoback?: long;
+        CountForGoback?: int;
+        Start?: long;
+        Count?: int;
+        File?: string;
+        Key?: string;
+        SchemaOnly?: boolean;
+        RoxieSelections?: boolean;
+        DisableUppercaseTranslation?: boolean;
+        SelectedKey?: string;
+    }
+
+    export interface DFUSearchDataResponse {
+        Exceptions: Exceptions;
+        OpenLogicalName: string;
+        LogicalName: string;
+        ParentName: string;
+        StartIndex: long;
+        EndIndex: long;
+        DFUDataKeyedColumns1: DFUDataKeyedColumns1;
+        DFUDataKeyedColumns2: DFUDataKeyedColumns2;
+        DFUDataKeyedColumns3: DFUDataKeyedColumns3;
+        DFUDataKeyedColumns4: DFUDataKeyedColumns4;
+        DFUDataKeyedColumns5: DFUDataKeyedColumns5;
+        DFUDataKeyedColumns6: DFUDataKeyedColumns6;
+        DFUDataKeyedColumns7: DFUDataKeyedColumns7;
+        DFUDataKeyedColumns8: DFUDataKeyedColumns8;
+        DFUDataKeyedColumns9: DFUDataKeyedColumns9;
+        DFUDataKeyedColumns10: DFUDataKeyedColumns10;
+        DFUDataKeyedColumns11: DFUDataKeyedColumns11;
+        DFUDataKeyedColumns12: DFUDataKeyedColumns12;
+        DFUDataKeyedColumns13: DFUDataKeyedColumns13;
+        DFUDataKeyedColumns14: DFUDataKeyedColumns14;
+        DFUDataKeyedColumns15: DFUDataKeyedColumns15;
+        DFUDataKeyedColumns16: DFUDataKeyedColumns16;
+        DFUDataKeyedColumns17: DFUDataKeyedColumns17;
+        DFUDataKeyedColumns18: DFUDataKeyedColumns18;
+        DFUDataKeyedColumns19: DFUDataKeyedColumns19;
+        DFUDataKeyedColumns20: DFUDataKeyedColumns20;
+        DFUDataNonKeyedColumns1: DFUDataNonKeyedColumns1;
+        DFUDataNonKeyedColumns2: DFUDataNonKeyedColumns2;
+        DFUDataNonKeyedColumns3: DFUDataNonKeyedColumns3;
+        DFUDataNonKeyedColumns4: DFUDataNonKeyedColumns4;
+        DFUDataNonKeyedColumns5: DFUDataNonKeyedColumns5;
+        DFUDataNonKeyedColumns6: DFUDataNonKeyedColumns6;
+        DFUDataNonKeyedColumns7: DFUDataNonKeyedColumns7;
+        DFUDataNonKeyedColumns8: DFUDataNonKeyedColumns8;
+        DFUDataNonKeyedColumns9: DFUDataNonKeyedColumns9;
+        DFUDataNonKeyedColumns10: DFUDataNonKeyedColumns10;
+        DFUDataNonKeyedColumns11: DFUDataNonKeyedColumns11;
+        DFUDataNonKeyedColumns12: DFUDataNonKeyedColumns12;
+        DFUDataNonKeyedColumns13: DFUDataNonKeyedColumns13;
+        DFUDataNonKeyedColumns14: DFUDataNonKeyedColumns14;
+        DFUDataNonKeyedColumns15: DFUDataNonKeyedColumns15;
+        DFUDataNonKeyedColumns16: DFUDataNonKeyedColumns16;
+        DFUDataNonKeyedColumns17: DFUDataNonKeyedColumns17;
+        DFUDataNonKeyedColumns18: DFUDataNonKeyedColumns18;
+        DFUDataNonKeyedColumns19: DFUDataNonKeyedColumns19;
+        DFUDataNonKeyedColumns20: DFUDataNonKeyedColumns20;
+        RowCount: long;
+        ShowColumns: string;
+        ChooseFile: int;
+        Name: string;
+        FilterBy: string;
+        FilterForGoBack: string;
+        ColumnsHidden: ColumnsHidden;
+        ColumnCount: int;
+        StartForGoback: long;
+        CountForGoback: int;
+        Start: long;
+        Count: long;
+        PageSize: long;
+        Total: long;
+        Result: string;
+        MsgToDisplay: string;
+        Cluster: string;
+        ClusterType: string;
+        File: string;
+        Key: string;
+        SchemaOnly: boolean;
+        RoxieSelections: boolean;
+        DisableUppercaseTranslation: boolean;
+        AutoUppercaseTranslation: boolean;
+        SelectedKey: string;
+    }
+
+    export interface DFUSpaceRequest {
+        CountBy?: string;
+        ScopeUnder?: string;
+        OwnerUnder?: string;
+        Interval?: string;
+        StartDate?: string;
+        EndDate?: string;
+    }
+
+    export interface DFUSpaceItem {
+        Name: string;
+        NumOfFiles: string;
+        NumOfFilesUnknown: string;
+        TotalSize: string;
+        LargestFile: string;
+        LargestSize: string;
+        SmallestFile: string;
+        SmallestSize: string;
+        NumOfFilesInt64: long;
+        NumOfFilesUnknownInt64: long;
+        TotalSizeInt64: long;
+        LargestSizeInt64: long;
+        SmallestSizeInt64: long;
+    }
+
+    export interface DFUSpaceItems {
+        DFUSpaceItem: DFUSpaceItem[];
+    }
+
+    export interface DFUSpaceResponse {
+        Exceptions: Exceptions;
+        CountBy: string;
+        ScopeUnder: string;
+        OwnerUnder: string;
+        Interval: string;
+        StartDate: string;
+        EndDate: string;
+        DFUSpaceItems: DFUSpaceItems;
+    }
+
+    export interface EclRecordTypeInfoRequest {
+        Ecl?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+    }
+
+    export interface EclRecordTypeInfoResponse {
+        jsonInfo: string;
+        binInfo: base64Binary;
+    }
+
+    export interface EraseHistoryRequest {
+        Name?: string;
+    }
+
+    export interface Origin {
+        Name: string;
+        Operation: string;
+        Timestamp: string;
+        IP: string;
+        Path: string;
+        Owner: string;
+        Workunit: string;
+    }
+
+    export interface History {
+        Origin: Origin[];
+    }
+
+    export interface EraseHistoryResponse {
+        Exceptions: Exceptions;
+        History: History;
+    }
+
+    export interface ListHistoryRequest {
+        Name?: string;
+    }
+
+    export interface ListHistoryResponse {
+        Exceptions: Exceptions;
+        History: History;
+    }
+
+    export interface WsDfuPingRequest {
+
+    }
+
+    export interface WsDfuPingResponse {
+
+    }
+
+    export interface SavexmlRequest {
+        name?: string;
+    }
+
+    export interface SavexmlResponse {
+        Exceptions: Exceptions;
+        xmlmap: base64Binary;
+    }
+
+    export interface SuperfileActionRequest {
+        action?: string;
+        superfile?: string;
+        subfiles?: subfiles;
+        before?: string;
+        delete?: boolean;
+        removeSuperfile?: boolean;
+    }
+
+    export interface SuperfileActionResponse {
+        Exceptions: Exceptions;
+        superfile: string;
+        retcode: int;
+    }
+
+    export interface SuperfileListRequest {
+        superfile?: string;
+    }
+
+    export interface SuperfileListResponse {
+        Exceptions: Exceptions;
+        superfile: string;
+        subfiles: subfiles;
+    }
+
+}
+
+export class DfuServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsDfu", "1.67");
+    }
+
+    Add(request: Partial<WsDfu.AddRequest>): Promise<WsDfu.AddResponse> {
+        return this._connection.send("Add", request, "json", false, undefined, "AddResponse");
+    }
+
+    AddRemote(request: Partial<WsDfu.AddRemoteRequest>): Promise<WsDfu.AddRemoteResponse> {
+        return this._connection.send("AddRemote", request, "json", false, undefined, "AddRemoteResponse");
+    }
+
+    AddtoSuperfile(request: Partial<WsDfu.AddtoSuperfileRequest>): Promise<WsDfu.AddtoSuperfileResponse> {
+        return this._connection.send("AddtoSuperfile", request, "json", false, undefined, "AddtoSuperfileResponse");
+    }
+
+    DFUArrayAction(request: Partial<WsDfu.DFUArrayActionRequest>): Promise<WsDfu.DFUArrayActionResponse> {
+        return this._connection.send("DFUArrayAction", request, "json", false, undefined, "DFUArrayActionResponse");
+    }
+
+    DFUBrowseData(request: Partial<WsDfu.DFUBrowseDataRequest>): Promise<WsDfu.DFUBrowseDataResponse> {
+        return this._connection.send("DFUBrowseData", request, "json", false, undefined, "DFUBrowseDataResponse");
+    }
+
+    DFUDefFile(request: Partial<WsDfu.DFUDefFileRequest>): Promise<WsDfu.DFUDefFileResponse> {
+        return this._connection.send("DFUDefFile", request, "json", false, undefined, "DFUDefFileResponse");
+    }
+
+    DFUFileAccess(request: Partial<WsDfu.DFUFileAccessRequest>): Promise<WsDfu.DFUFileAccessResponse> {
+        return this._connection.send("DFUFileAccess", request, "json", false, undefined, "DFUFileAccessResponse");
+    }
+
+    DFUFileAccessV2(request: Partial<WsDfu.DFUFileAccessV2Request>): Promise<WsDfu.DFUFileAccessResponse> {
+        return this._connection.send("DFUFileAccessV2", request, "json", false, undefined, "DFUFileAccessResponse");
+    }
+
+    DFUFileCreate(request: Partial<WsDfu.DFUFileCreateRequest>): Promise<WsDfu.DFUFileCreateResponse> {
+        return this._connection.send("DFUFileCreate", request, "json", false, undefined, "DFUFileCreateResponse");
+    }
+
+    DFUFileCreateV2(request: Partial<WsDfu.DFUFileCreateV2Request>): Promise<WsDfu.DFUFileCreateResponse> {
+        return this._connection.send("DFUFileCreateV2", request, "json", false, undefined, "DFUFileCreateResponse");
+    }
+
+    DFUFilePublish(request: Partial<WsDfu.DFUFilePublishRequest>): Promise<WsDfu.DFUFilePublishResponse> {
+        return this._connection.send("DFUFilePublish", request, "json", false, undefined, "DFUFilePublishResponse");
+    }
+
+    DFUFileView(request: Partial<WsDfu.DFUFileViewRequest>): Promise<WsDfu.DFUFileViewResponse> {
+        return this._connection.send("DFUFileView", request, "json", false, undefined, "DFUFileViewResponse");
+    }
+
+    DFUGetDataColumns(request: Partial<WsDfu.DFUGetDataColumnsRequest>): Promise<WsDfu.DFUGetDataColumnsResponse> {
+        return this._connection.send("DFUGetDataColumns", request, "json", false, undefined, "DFUGetDataColumnsResponse");
+    }
+
+    DFUGetFileMetaData(request: Partial<WsDfu.DFUGetFileMetaDataRequest>): Promise<WsDfu.DFUGetFileMetaDataResponse> {
+        return this._connection.send("DFUGetFileMetaData", request, "json", false, undefined, "DFUGetFileMetaDataResponse");
+    }
+
+    DFUGetMetaInquiry(request: Partial<WsDfu.DFUMetaInquiryRequest>): Promise<WsDfu.DFUMetaInquiryResponse> {
+        return this._connection.send("DFUGetMetaInquiry", request, "json", false, undefined, "DFUMetaInquiryResponse");
+    }
+
+    DFUInfo(request: Partial<WsDfu.DFUInfoRequest>): Promise<WsDfu.DFUInfoResponse> {
+        return this._connection.send("DFUInfo", request, "json", false, undefined, "DFUInfoResponse");
+    }
+
+    DFUQuery(request: Partial<WsDfu.DFUQueryRequest>): Promise<WsDfu.DFUQueryResponse> {
+        return this._connection.send("DFUQuery", request, "json", false, undefined, "DFUQueryResponse");
+    }
+
+    DFURecordTypeInfo(request: Partial<WsDfu.DFURecordTypeInfoRequest>): Promise<WsDfu.DFURecordTypeInfoResponse> {
+        return this._connection.send("DFURecordTypeInfo", request, "json", false, undefined, "DFURecordTypeInfoResponse");
+    }
+
+    DFUSearch(request: Partial<WsDfu.DFUSearchRequest>): Promise<WsDfu.DFUSearchResponse> {
+        return this._connection.send("DFUSearch", request, "json", false, undefined, "DFUSearchResponse");
+    }
+
+    DFUSearchData(request: Partial<WsDfu.DFUSearchDataRequest>): Promise<WsDfu.DFUSearchDataResponse> {
+        return this._connection.send("DFUSearchData", request, "json", false, undefined, "DFUSearchDataResponse");
+    }
+
+    DFUSpace(request: Partial<WsDfu.DFUSpaceRequest>): Promise<WsDfu.DFUSpaceResponse> {
+        return this._connection.send("DFUSpace", request, "json", false, undefined, "DFUSpaceResponse");
+    }
+
+    EclRecordTypeInfo(request: Partial<WsDfu.EclRecordTypeInfoRequest>): Promise<WsDfu.EclRecordTypeInfoResponse> {
+        return this._connection.send("EclRecordTypeInfo", request, "json", false, undefined, "EclRecordTypeInfoResponse");
+    }
+
+    EraseHistory(request: Partial<WsDfu.EraseHistoryRequest>): Promise<WsDfu.EraseHistoryResponse> {
+        return this._connection.send("EraseHistory", request, "json", false, undefined, "EraseHistoryResponse");
+    }
+
+    ListHistory(request: Partial<WsDfu.ListHistoryRequest>): Promise<WsDfu.ListHistoryResponse> {
+        return this._connection.send("ListHistory", request, "json", false, undefined, "ListHistoryResponse");
+    }
+
+    Ping(request: Partial<WsDfu.WsDfuPingRequest>): Promise<WsDfu.WsDfuPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsDfuPingResponse");
+    }
+
+    Savexml(request: Partial<WsDfu.SavexmlRequest>): Promise<WsDfu.SavexmlResponse> {
+        return this._connection.send("Savexml", request, "json", false, undefined, "SavexmlResponse");
+    }
+
+    SuperfileAction(request: Partial<WsDfu.SuperfileActionRequest>): Promise<WsDfu.SuperfileActionResponse> {
+        return this._connection.send("SuperfileAction", request, "json", false, undefined, "SuperfileActionResponse");
+    }
+
+    SuperfileList(request: Partial<WsDfu.SuperfileListRequest>): Promise<WsDfu.SuperfileListResponse> {
+        return this._connection.send("SuperfileList", request, "json", false, undefined, "SuperfileListResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsFileIO/v1.01/WsFileIO.ts b/packages/comms/src/services/wsdl/WsFileIO/v1.01/WsFileIO.ts
index b14bfa72d2..22a2ad4ac7 100644
--- a/packages/comms/src/services/wsdl/WsFileIO/v1.01/WsFileIO.ts
+++ b/packages/comms/src/services/wsdl/WsFileIO/v1.01/WsFileIO.ts
@@ -1,11 +1,11 @@
 import { IConnection, IOptions } from "../../../../connection.ts";
 import { Service } from "../../../../espConnection.ts";
 
-type long = number;
-type base64Binary = string;
-
 export namespace WsFileIO {
 
+    export type long = number;
+    export type base64Binary = string;
+
     export interface CreateFileRequest {
         DestDropZone?: string;
         DestRelativePath?: string;
@@ -26,10 +26,7 @@ export namespace WsFileIO {
     }
 
     export interface CreateFileResponse {
-        Exceptions: {
-            Source: string;
-            Exception: Exception[];
-        };
+        Exceptions: Exceptions;
         DestDropZone: string;
         DestRelativePath: string;
         Overwrite: boolean;
@@ -88,20 +85,20 @@ export class FileIOServiceBase extends Service {
         super(optsConnection, "WsFileIO", "1.01");
     }
 
-    CreateFile(request: WsFileIO.CreateFileRequest): Promise<WsFileIO.CreateFileResponse> {
-        return this._connection.send("CreateFile", request);
+    CreateFile(request: Partial<WsFileIO.CreateFileRequest>): Promise<WsFileIO.CreateFileResponse> {
+        return this._connection.send("CreateFile", request, "json", false, undefined, "CreateFileResponse");
     }
 
-    Ping(request: WsFileIO.WsFileIOPingRequest): Promise<WsFileIO.WsFileIOPingResponse> {
-        return this._connection.send("Ping", request);
+    Ping(request: Partial<WsFileIO.WsFileIOPingRequest>): Promise<WsFileIO.WsFileIOPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsFileIOPingResponse");
     }
 
-    ReadFileData(request: WsFileIO.ReadFileDataRequest): Promise<WsFileIO.ReadFileDataResponse> {
-        return this._connection.send("ReadFileData", request);
+    ReadFileData(request: Partial<WsFileIO.ReadFileDataRequest>): Promise<WsFileIO.ReadFileDataResponse> {
+        return this._connection.send("ReadFileData", request, "json", false, undefined, "ReadFileDataResponse");
     }
 
-    WriteFileData(request: WsFileIO.WriteFileDataRequest): Promise<WsFileIO.WriteFileDataResponse> {
-        return this._connection.send("WriteFileData", request);
+    WriteFileData(request: Partial<WsFileIO.WriteFileDataRequest>): Promise<WsFileIO.WriteFileDataResponse> {
+        return this._connection.send("WriteFileData", request, "json", false, undefined, "WriteFileDataResponse");
     }
 
 }
diff --git a/packages/comms/src/services/wsdl/WsPackageProcess/v1.07/WsPackageProcess.ts b/packages/comms/src/services/wsdl/WsPackageProcess/v1.07/WsPackageProcess.ts
new file mode 100644
index 0000000000..7d517d7ea4
--- /dev/null
+++ b/packages/comms/src/services/wsdl/WsPackageProcess/v1.07/WsPackageProcess.ts
@@ -0,0 +1,500 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsPackageProcess {
+
+    export type int = number;
+    export type nonNegativeInteger = number;
+
+    export interface ActivatePackageRequest {
+        Target?: string;
+        PackageMap?: string;
+        Process?: string;
+        GlobalScope?: boolean;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface status {
+        Code: int;
+        Description: string;
+    }
+
+    export interface ActivatePackageResponse {
+        Exceptions: Exceptions;
+        status: status;
+    }
+
+    export interface AddPackageRequest {
+        Info?: string;
+        Activate?: boolean;
+        OverWrite?: boolean;
+        Target?: string;
+        PackageMap?: string;
+        Process?: string;
+        DaliIp?: string;
+        GlobalScope?: boolean;
+        SourceProcess?: string;
+        AllowForeignFiles?: boolean;
+        PreloadAllPackages?: boolean;
+        ReplacePackageMap?: boolean;
+        UpdateSuperFiles?: boolean;
+        UpdateCloneFrom?: boolean;
+        AppendCluster?: boolean;
+        DfuCopyFiles?: boolean;
+        DfuQueue?: string;
+        DfuWait?: nonNegativeInteger;
+        DfuOverwrite?: boolean;
+        OnlyCopyFiles?: boolean;
+        StopIfFilesCopied?: boolean;
+        DfuPublisherWuid?: string;
+        RemoteStorage?: string;
+        KeyCompression?: string;
+    }
+
+    export interface FilesNotFound {
+        File: string[];
+    }
+
+    export interface AddPackageResponse {
+        Exceptions: Exceptions;
+        status: status;
+        FilesNotFound: FilesNotFound;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+
+    export interface AddPartToPackageMapRequest {
+        Target?: string;
+        Process?: string;
+        PackageMap?: string;
+        GlobalScope?: boolean;
+        PartName?: string;
+        Content?: string;
+        DeletePrevious?: boolean;
+        DaliIp?: string;
+        SourceProcess?: string;
+        AllowForeignFiles?: boolean;
+        PreloadAllPackages?: boolean;
+        UpdateSuperFiles?: boolean;
+        UpdateCloneFrom?: boolean;
+        AppendCluster?: boolean;
+        DfuCopyFiles?: boolean;
+        DfuQueue?: string;
+        DfuWait?: nonNegativeInteger;
+        DfuOverwrite?: boolean;
+        OnlyCopyFiles?: boolean;
+        StopIfFilesCopied?: boolean;
+        DfuPublisherWuid?: string;
+        RemoteStorage?: string;
+        KeyCompression?: string;
+    }
+
+    export interface AddPartToPackageMapResponse {
+        Exceptions: Exceptions;
+        status: status;
+        FilesNotFound: FilesNotFound;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+
+    export interface CopyPackageMapRequest {
+        SourcePath?: string;
+        RemoteUserName?: string;
+        RemotePassword?: string;
+        Target?: string;
+        Process?: string;
+        PMID?: string;
+        Activate?: boolean;
+        DaliIp?: string;
+        GlobalScope?: boolean;
+        SourceProcess?: string;
+        PreloadAllPackages?: boolean;
+        ReplacePackageMap?: boolean;
+        UpdateSuperFiles?: boolean;
+        UpdateCloneFrom?: boolean;
+        AppendCluster?: boolean;
+        DfuCopyFiles?: boolean;
+        DfuQueue?: string;
+        DfuWait?: nonNegativeInteger;
+        DfuOverwrite?: boolean;
+        OnlyCopyFiles?: boolean;
+        StopIfFilesCopied?: boolean;
+        DfuPublisherWuid?: string;
+        RemoteStorage?: string;
+        KeyCompression?: string;
+    }
+
+    export interface CopyPackageMapResponse {
+        Exceptions: Exceptions;
+        status: status;
+        FilesNotFound: FilesNotFound;
+        DfuPublisherWuid: string;
+        DfuPublisherState: string;
+    }
+
+    export interface DeActivatePackageRequest {
+        Target?: string;
+        PackageMap?: string;
+        Process?: string;
+        GlobalScope?: boolean;
+    }
+
+    export interface DeActivatePackageResponse {
+        Exceptions: Exceptions;
+        status: status;
+    }
+
+    export interface PackageMap {
+        Id: string;
+        Target: string;
+        Process: string;
+    }
+
+    export interface PackageMaps {
+        PackageMap: PackageMap[];
+    }
+
+    export interface DeletePackageRequest {
+        Target?: string;
+        PackageMap?: string;
+        Process?: string;
+        GlobalScope?: boolean;
+        PackageMaps?: PackageMaps;
+    }
+
+    export interface DeletePackageResponse {
+        Exceptions: Exceptions;
+        status: status;
+    }
+
+    export interface EchoRequest {
+        Request?: string;
+    }
+
+    export interface EchoResponse {
+        Response: string;
+    }
+
+    export interface GetPackageRequest {
+        Target?: string;
+        Process?: string;
+    }
+
+    export interface GetPackageResponse {
+        Exceptions: Exceptions;
+        status: status;
+        Info: string;
+    }
+
+    export interface GetPackageMapByIdRequest {
+        PackageMapId?: string;
+    }
+
+    export interface GetPackageMapByIdResponse {
+        Exceptions: Exceptions;
+        status: status;
+        Info: string;
+    }
+
+    export interface GetPackageMapSelectOptionsRequest {
+        IncludeTargets?: boolean;
+        IncludeProcesses?: boolean;
+        IncludeProcessFilters?: boolean;
+    }
+
+    export interface Processes {
+        Item: string[];
+    }
+
+    export interface TargetData {
+        Name: string;
+        Type: string;
+        Processes: Processes;
+    }
+
+    export interface Targets {
+        TargetData: TargetData[];
+    }
+
+    export interface ProcessFilters {
+        Item: string[];
+    }
+
+    export interface GetPackageMapSelectOptionsResponse {
+        Exceptions: Exceptions;
+        status: status;
+        Targets: Targets;
+        ProcessFilters: ProcessFilters;
+    }
+
+    export interface GetPartFromPackageMapRequest {
+        Target?: string;
+        PackageMap?: string;
+        GlobalScope?: boolean;
+        PartName?: string;
+    }
+
+    export interface GetPartFromPackageMapResponse {
+        Exceptions: Exceptions;
+        status: status;
+        Content: string;
+    }
+
+    export interface GetQueryFileMappingRequest {
+        Target?: string;
+        PMID?: string;
+        QueryName?: string;
+        GlobalScope?: boolean;
+    }
+
+    export interface UnmappedFiles {
+        File: string[];
+    }
+
+    export interface SubFiles {
+        File: string[];
+    }
+
+    export interface SuperFile {
+        Name: string;
+        SubFiles: SubFiles;
+    }
+
+    export interface SuperFiles {
+        SuperFile: SuperFile[];
+    }
+
+    export interface GetQueryFileMappingResponse {
+        Exceptions: Exceptions;
+        UnmappedFiles: UnmappedFiles;
+        SuperFiles: SuperFiles;
+    }
+
+    export interface ListPackageRequest {
+        Target?: string;
+        Process?: string;
+    }
+
+    export interface PackageListData {
+        Id: string;
+        Queries: string;
+    }
+
+    export interface PkgListData {
+        PackageListData: PackageListData[];
+    }
+
+    export interface PackageListMapData {
+        Id: string;
+        Target: string;
+        Process: string;
+        PkgListData: PkgListData;
+        Active: boolean;
+        Description: string;
+    }
+
+    export interface PkgListMapData {
+        PackageListMapData: PackageListMapData[];
+    }
+
+    export interface ListPackageResponse {
+        Exceptions: Exceptions;
+        status: status;
+        PkgListMapData: PkgListMapData;
+    }
+
+    export interface ListPackagesRequest {
+        Target?: string;
+        Process?: string;
+        ProcessFilter?: string;
+    }
+
+    export interface PackageMapList {
+        PackageListMapData: PackageListMapData[];
+    }
+
+    export interface ListPackagesResponse {
+        Exceptions: Exceptions;
+        status: status;
+        PackageMapList: PackageMapList;
+    }
+
+    export interface WsPackageProcessPingRequest {
+
+    }
+
+    export interface WsPackageProcessPingResponse {
+
+    }
+
+    export interface RemovePartFromPackageMapRequest {
+        Target?: string;
+        PackageMap?: string;
+        GlobalScope?: boolean;
+        PartName?: string;
+    }
+
+    export interface RemovePartFromPackageMapResponse {
+        Exceptions: Exceptions;
+        status: status;
+    }
+
+    export interface QueriesToVerify {
+        Item: string[];
+    }
+
+    export interface QueriesToIgnore {
+        Item: string[];
+    }
+
+    export interface ValidatePackageRequest {
+        Info?: string;
+        Target?: string;
+        Process?: string;
+        Active?: boolean;
+        PMID?: string;
+        QueryIdToVerify?: string;
+        QueriesToVerify?: QueriesToVerify;
+        QueriesToIgnore?: QueriesToIgnore;
+        CheckDFS?: boolean;
+        GlobalScope?: boolean;
+        IgnoreWarnings?: boolean;
+        IgnoreOptionalFiles?: boolean;
+    }
+
+    export interface Warnings {
+        Item: string[];
+    }
+
+    export interface Errors {
+        Item: string[];
+    }
+
+    export interface Unmatched {
+        Item: string[];
+    }
+
+    export interface packages {
+        Unmatched: Unmatched;
+    }
+
+    export interface queries {
+        Unmatched: Unmatched;
+    }
+
+    export interface NotInDFS {
+        File: string[];
+    }
+
+    export interface files {
+        Unmatched: Unmatched;
+        NotInDFS: NotInDFS;
+    }
+
+    export interface Result {
+        Target: string;
+        PMID: string;
+        Warnings: Warnings;
+        Errors: Errors;
+        packages: packages;
+        queries: queries;
+        files: files;
+    }
+
+    export interface Results {
+        Result: Result[];
+    }
+
+    export interface ValidatePackageResponse {
+        Exceptions: Exceptions;
+        Results: Results;
+    }
+
+}
+
+export class PackageProcessServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsPackageProcess", "1.07");
+    }
+
+    ActivatePackage(request: Partial<WsPackageProcess.ActivatePackageRequest>): Promise<WsPackageProcess.ActivatePackageResponse> {
+        return this._connection.send("ActivatePackage", request, "json", false, undefined, "ActivatePackageResponse");
+    }
+
+    AddPackage(request: Partial<WsPackageProcess.AddPackageRequest>): Promise<WsPackageProcess.AddPackageResponse> {
+        return this._connection.send("AddPackage", request, "json", false, undefined, "AddPackageResponse");
+    }
+
+    AddPartToPackageMap(request: Partial<WsPackageProcess.AddPartToPackageMapRequest>): Promise<WsPackageProcess.AddPartToPackageMapResponse> {
+        return this._connection.send("AddPartToPackageMap", request, "json", false, undefined, "AddPartToPackageMapResponse");
+    }
+
+    CopyPackageMap(request: Partial<WsPackageProcess.CopyPackageMapRequest>): Promise<WsPackageProcess.CopyPackageMapResponse> {
+        return this._connection.send("CopyPackageMap", request, "json", false, undefined, "CopyPackageMapResponse");
+    }
+
+    DeActivatePackage(request: Partial<WsPackageProcess.DeActivatePackageRequest>): Promise<WsPackageProcess.DeActivatePackageResponse> {
+        return this._connection.send("DeActivatePackage", request, "json", false, undefined, "DeActivatePackageResponse");
+    }
+
+    DeletePackage(request: Partial<WsPackageProcess.DeletePackageRequest>): Promise<WsPackageProcess.DeletePackageResponse> {
+        return this._connection.send("DeletePackage", request, "json", false, undefined, "DeletePackageResponse");
+    }
+
+    Echo(request: Partial<WsPackageProcess.EchoRequest>): Promise<WsPackageProcess.EchoResponse> {
+        return this._connection.send("Echo", request, "json", false, undefined, "EchoResponse");
+    }
+
+    GetPackage(request: Partial<WsPackageProcess.GetPackageRequest>): Promise<WsPackageProcess.GetPackageResponse> {
+        return this._connection.send("GetPackage", request, "json", false, undefined, "GetPackageResponse");
+    }
+
+    GetPackageMapById(request: Partial<WsPackageProcess.GetPackageMapByIdRequest>): Promise<WsPackageProcess.GetPackageMapByIdResponse> {
+        return this._connection.send("GetPackageMapById", request, "json", false, undefined, "GetPackageMapByIdResponse");
+    }
+
+    GetPackageMapSelectOptions(request: Partial<WsPackageProcess.GetPackageMapSelectOptionsRequest>): Promise<WsPackageProcess.GetPackageMapSelectOptionsResponse> {
+        return this._connection.send("GetPackageMapSelectOptions", request, "json", false, undefined, "GetPackageMapSelectOptionsResponse");
+    }
+
+    GetPartFromPackageMap(request: Partial<WsPackageProcess.GetPartFromPackageMapRequest>): Promise<WsPackageProcess.GetPartFromPackageMapResponse> {
+        return this._connection.send("GetPartFromPackageMap", request, "json", false, undefined, "GetPartFromPackageMapResponse");
+    }
+
+    GetQueryFileMapping(request: Partial<WsPackageProcess.GetQueryFileMappingRequest>): Promise<WsPackageProcess.GetQueryFileMappingResponse> {
+        return this._connection.send("GetQueryFileMapping", request, "json", false, undefined, "GetQueryFileMappingResponse");
+    }
+
+    ListPackage(request: Partial<WsPackageProcess.ListPackageRequest>): Promise<WsPackageProcess.ListPackageResponse> {
+        return this._connection.send("ListPackage", request, "json", false, undefined, "ListPackageResponse");
+    }
+
+    ListPackages(request: Partial<WsPackageProcess.ListPackagesRequest>): Promise<WsPackageProcess.ListPackagesResponse> {
+        return this._connection.send("ListPackages", request, "json", false, undefined, "ListPackagesResponse");
+    }
+
+    Ping(request: Partial<WsPackageProcess.WsPackageProcessPingRequest>): Promise<WsPackageProcess.WsPackageProcessPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsPackageProcessPingResponse");
+    }
+
+    RemovePartFromPackageMap(request: Partial<WsPackageProcess.RemovePartFromPackageMapRequest>): Promise<WsPackageProcess.RemovePartFromPackageMapResponse> {
+        return this._connection.send("RemovePartFromPackageMap", request, "json", false, undefined, "RemovePartFromPackageMapResponse");
+    }
+
+    ValidatePackage(request: Partial<WsPackageProcess.ValidatePackageRequest>): Promise<WsPackageProcess.ValidatePackageResponse> {
+        return this._connection.send("ValidatePackage", request, "json", false, undefined, "ValidatePackageResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsSMC/v1.27/WsSMC.ts b/packages/comms/src/services/wsdl/WsSMC/v1.27/WsSMC.ts
index 71594422a1..a1c9ea29bb 100644
--- a/packages/comms/src/services/wsdl/WsSMC/v1.27/WsSMC.ts
+++ b/packages/comms/src/services/wsdl/WsSMC/v1.27/WsSMC.ts
@@ -119,9 +119,7 @@ export namespace WsSMC {
 
     export interface ServerJobQueue {
         QueueName: string;
-        Queues: {
-            ServerJobQueue: ServerJobQueue[];
-        };
+        Queues: Queues;
         ServerName: string;
         ServerType: string;
         QueueStatus: string;
@@ -135,26 +133,13 @@ export namespace WsSMC {
     }
 
     export interface ActivityResponse {
-        Exceptions: {
-            Source: string;
-            Exception: Exception[];
-        };
+        Exceptions: Exceptions;
         Build: string;
-        ThorClusterList: {
-            TargetCluster: TargetCluster[];
-        };
-        RoxieClusterList: {
-            TargetCluster: TargetCluster[];
-        };
-        HThorClusterList: {
-            TargetCluster: TargetCluster[];
-        };
-        DFUJobs: {
-            DFUJob: DFUJob[];
-        };
-        Running: {
-            ActiveWorkunit: ActiveWorkunit[];
-        };
+        ThorClusterList: ThorClusterList;
+        RoxieClusterList: RoxieClusterList;
+        HThorClusterList: HThorClusterList;
+        DFUJobs: DFUJobs;
+        Running: Running;
         BannerContent: string;
         BannerColor: string;
         BannerSize: string;
@@ -166,9 +151,7 @@ export namespace WsSMC {
         Descending: boolean;
         SuperUser: boolean;
         AccessRight: string;
-        ServerJobQueues: {
-            ServerJobQueue: ServerJobQueue[];
-        };
+        ServerJobQueues: ServerJobQueues;
         ActivityTime: string;
         DaliDetached: boolean;
     }
@@ -191,9 +174,7 @@ export namespace WsSMC {
     export interface HPCCResourceRepository {
         Name: string;
         Path: string;
-        HPCCResources: {
-            HPCCResource: HPCCResource[];
-        };
+        HPCCResources: HPCCResources;
     }
 
     export interface HPCCResourceRepositories {
@@ -206,9 +187,7 @@ export namespace WsSMC {
         ESPInstance: string;
         OS: int;
         UseResource: boolean;
-        HPCCResourceRepositories: {
-            HPCCResourceRepository: HPCCResourceRepository[];
-        };
+        HPCCResourceRepositories: HPCCResourceRepositories;
     }
 
     export interface ClearQueue {
@@ -247,58 +226,14 @@ export namespace WsSMC {
     }
 
     export interface StatusServerInfo {
-        TargetClusterInfo: {
-            ClusterName: string;
-            QueueName: string;
-            QueueStatus: string;
-            StatusDetails: string;
-            Warning: string;
-            ClusterType: int;
-            ClusterSize: int;
-            ClusterStatus: int;
-        };
-        ServerInfo: {
-            QueueName: string;
-            Queues: Queues;
-            ServerName: string;
-            ServerType: string;
-            QueueStatus: string;
-            StatusDetails: string;
-            NetworkAddress: string;
-            Port: int;
-        };
-        Workunits: {
-            ActiveWorkunit: ActiveWorkunit[];
-        };
+        TargetClusterInfo: TargetClusterInfo;
+        ServerInfo: ServerInfo;
+        Workunits: Workunits;
     }
 
     export interface SMCQueueResponse {
         Exceptions: Exceptions;
-        StatusServerInfo: {
-            TargetClusterInfo: {
-                ClusterName: string;
-                QueueName: string;
-                QueueStatus: string;
-                StatusDetails: string;
-                Warning: string;
-                ClusterType: int;
-                ClusterSize: int;
-                ClusterStatus: int;
-            };
-            ServerInfo: {
-                QueueName: string;
-                Queues: Queues;
-                ServerName: string;
-                ServerType: string;
-                QueueStatus: string;
-                StatusDetails: string;
-                NetworkAddress: string;
-                Port: int;
-            };
-            Workunits: {
-                ActiveWorkunit: ActiveWorkunit[];
-            };
-        };
+        StatusServerInfo: StatusServerInfo;
     }
 
     export interface GetBuildInfo {
@@ -316,9 +251,7 @@ export namespace WsSMC {
 
     export interface GetBuildInfoResponse {
         Exceptions: Exceptions;
-        BuildInfo: {
-            NamedValue: NamedValue[];
-        };
+        BuildInfo: BuildInfo;
     }
 
     export interface GetStatusServerInfo {
@@ -355,9 +288,7 @@ export namespace WsSMC {
 
     export interface GetThorQueueAvailabilityResponse {
         Exceptions: Exceptions;
-        ThorClusters: {
-            ThorCluster: ThorCluster[];
-        };
+        ThorClusters: ThorClusters;
     }
 
     export interface Index {
@@ -391,9 +322,7 @@ export namespace WsSMC {
         DurationMS: unsignedInt;
         TimeLocked: string;
         Modes: string;
-        ModeNames: {
-            Item: string[];
-        };
+        ModeNames: ModeNames;
     }
 
     export interface Locks {
@@ -402,9 +331,7 @@ export namespace WsSMC {
 
     export interface LockQueryResponse {
         Exceptions: Exceptions;
-        Locks: {
-            Lock: Lock[];
-        };
+        Locks: Locks;
         NumLocks: int;
     }
 
@@ -502,9 +429,7 @@ export namespace WsSMC {
 
     export interface RoxieControlCmdResponse {
         Exceptions: Exceptions;
-        Endpoints: {
-            Endpoint: Endpoint[];
-        };
+        Endpoints: Endpoints;
     }
 
     export interface QueryIds {
@@ -513,9 +438,7 @@ export namespace WsSMC {
 
     export interface RoxieXrefCmd {
         RoxieCluster: string;
-        QueryIds: {
-            Item: string[];
-        };
+        QueryIds: QueryIds;
         CheckAllNodes: boolean;
         Wait: int;
     }
@@ -553,9 +476,7 @@ export namespace WsSMC {
         QueueName: string;
         Wuid: string;
         Priority: string;
-        SMCJobs: {
-            SMCJob: SMCJob[];
-        };
+        SMCJobs: SMCJobs;
     }
 
     export interface SMCPriorityResponse {
@@ -579,91 +500,91 @@ export class SMCServiceBase extends Service {
         super(optsConnection, "WsSMC", "1.27");
     }
 
-    Activity(request: WsSMC.Activity): Promise<WsSMC.ActivityResponse> {
+    Activity(request: Partial<WsSMC.Activity>): Promise<WsSMC.ActivityResponse> {
         return this._connection.send("Activity", request, "json", false, undefined, "ActivityResponse");
     }
 
-    BrowseResources(request: WsSMC.BrowseResources): Promise<WsSMC.BrowseResourcesResponse> {
+    BrowseResources(request: Partial<WsSMC.BrowseResources>): Promise<WsSMC.BrowseResourcesResponse> {
         return this._connection.send("BrowseResources", request, "json", false, undefined, "BrowseResourcesResponse");
     }
 
-    ClearQueue(request: WsSMC.ClearQueue): Promise<WsSMC.SMCQueueResponse> {
+    ClearQueue(request: Partial<WsSMC.ClearQueue>): Promise<WsSMC.SMCQueueResponse> {
         return this._connection.send("ClearQueue", request, "json", false, undefined, "SMCQueueResponse");
     }
 
-    GetBuildInfo(request: WsSMC.GetBuildInfo): Promise<WsSMC.GetBuildInfoResponse> {
+    GetBuildInfo(request: Partial<WsSMC.GetBuildInfo>): Promise<WsSMC.GetBuildInfoResponse> {
         return this._connection.send("GetBuildInfo", request, "json", false, undefined, "GetBuildInfoResponse");
     }
 
-    GetStatusServerInfo(request: WsSMC.GetStatusServerInfo): Promise<WsSMC.GetStatusServerInfoResponse> {
+    GetStatusServerInfo(request: Partial<WsSMC.GetStatusServerInfo>): Promise<WsSMC.GetStatusServerInfoResponse> {
         return this._connection.send("GetStatusServerInfo", request, "json", false, undefined, "GetStatusServerInfoResponse");
     }
 
-    GetThorQueueAvailability(request: WsSMC.GetThorQueueAvailability): Promise<WsSMC.GetThorQueueAvailabilityResponse> {
+    GetThorQueueAvailability(request: Partial<WsSMC.GetThorQueueAvailability>): Promise<WsSMC.GetThorQueueAvailabilityResponse> {
         return this._connection.send("GetThorQueueAvailability", request, "json", false, undefined, "GetThorQueueAvailabilityResponse");
     }
 
-    Index(request: WsSMC.Index): Promise<WsSMC.SMCIndexResponse> {
+    Index(request: Partial<WsSMC.Index>): Promise<WsSMC.SMCIndexResponse> {
         return this._connection.send("Index", request, "json", false, undefined, "SMCIndexResponse");
     }
 
-    LockQuery(request: WsSMC.LockQuery): Promise<WsSMC.LockQueryResponse> {
+    LockQuery(request: Partial<WsSMC.LockQuery>): Promise<WsSMC.LockQueryResponse> {
         return this._connection.send("LockQuery", request, "json", false, undefined, "LockQueryResponse");
     }
 
-    MoveJobBack(request: WsSMC.MoveJobBack): Promise<WsSMC.SMCJobResponse> {
+    MoveJobBack(request: Partial<WsSMC.MoveJobBack>): Promise<WsSMC.SMCJobResponse> {
         return this._connection.send("MoveJobBack", request, "json", false, undefined, "SMCJobResponse");
     }
 
-    MoveJobDown(request: WsSMC.MoveJobDown): Promise<WsSMC.SMCJobResponse> {
+    MoveJobDown(request: Partial<WsSMC.MoveJobDown>): Promise<WsSMC.SMCJobResponse> {
         return this._connection.send("MoveJobDown", request, "json", false, undefined, "SMCJobResponse");
     }
 
-    MoveJobFront(request: WsSMC.MoveJobFront): Promise<WsSMC.SMCJobResponse> {
+    MoveJobFront(request: Partial<WsSMC.MoveJobFront>): Promise<WsSMC.SMCJobResponse> {
         return this._connection.send("MoveJobFront", request, "json", false, undefined, "SMCJobResponse");
     }
 
-    MoveJobUp(request: WsSMC.MoveJobUp): Promise<WsSMC.SMCJobResponse> {
+    MoveJobUp(request: Partial<WsSMC.MoveJobUp>): Promise<WsSMC.SMCJobResponse> {
         return this._connection.send("MoveJobUp", request, "json", false, undefined, "SMCJobResponse");
     }
 
-    NotInCommunityEdition(request: WsSMC.NotInCommunityEdition): Promise<WsSMC.NotInCommunityEditionResponse> {
+    NotInCommunityEdition(request: Partial<WsSMC.NotInCommunityEdition>): Promise<WsSMC.NotInCommunityEditionResponse> {
         return this._connection.send("NotInCommunityEdition", request, "json", false, undefined, "NotInCommunityEditionResponse");
     }
 
-    PauseQueue(request: WsSMC.PauseQueue): Promise<WsSMC.SMCQueueResponse> {
+    PauseQueue(request: Partial<WsSMC.PauseQueue>): Promise<WsSMC.SMCQueueResponse> {
         return this._connection.send("PauseQueue", request, "json", false, undefined, "SMCQueueResponse");
     }
 
-    Ping(request: WsSMC.Ping): Promise<WsSMC.WsSMCPingResponse> {
+    Ping(request: Partial<WsSMC.Ping>): Promise<WsSMC.WsSMCPingResponse> {
         return this._connection.send("Ping", request, "json", false, undefined, "WsSMCPingResponse");
     }
 
-    RemoveJob(request: WsSMC.RemoveJob): Promise<WsSMC.SMCJobResponse> {
+    RemoveJob(request: Partial<WsSMC.RemoveJob>): Promise<WsSMC.SMCJobResponse> {
         return this._connection.send("RemoveJob", request, "json", false, undefined, "SMCJobResponse");
     }
 
-    ResumeQueue(request: WsSMC.ResumeQueue): Promise<WsSMC.SMCQueueResponse> {
+    ResumeQueue(request: Partial<WsSMC.ResumeQueue>): Promise<WsSMC.SMCQueueResponse> {
         return this._connection.send("ResumeQueue", request, "json", false, undefined, "SMCQueueResponse");
     }
 
-    RoxieControlCmd(request: WsSMC.RoxieControlCmd): Promise<WsSMC.RoxieControlCmdResponse> {
+    RoxieControlCmd(request: Partial<WsSMC.RoxieControlCmd>): Promise<WsSMC.RoxieControlCmdResponse> {
         return this._connection.send("RoxieControlCmd", request, "json", false, undefined, "RoxieControlCmdResponse");
     }
 
-    RoxieXrefCmd(request: WsSMC.RoxieXrefCmd): Promise<WsSMC.RoxieXrefCmdResponse> {
+    RoxieXrefCmd(request: Partial<WsSMC.RoxieXrefCmd>): Promise<WsSMC.RoxieXrefCmdResponse> {
         return this._connection.send("RoxieXrefCmd", request, "json", false, undefined, "RoxieXrefCmdResponse");
     }
 
-    SetBanner(request: WsSMC.SetBanner): Promise<WsSMC.SetBannerResponse> {
+    SetBanner(request: Partial<WsSMC.SetBanner>): Promise<WsSMC.SetBannerResponse> {
         return this._connection.send("SetBanner", request, "json", false, undefined, "SetBannerResponse");
     }
 
-    SetJobPriority(request: WsSMC.SetJobPriority): Promise<WsSMC.SMCPriorityResponse> {
+    SetJobPriority(request: Partial<WsSMC.SetJobPriority>): Promise<WsSMC.SMCPriorityResponse> {
         return this._connection.send("SetJobPriority", request, "json", false, undefined, "SMCPriorityResponse");
     }
 
-    StopQueue(request: WsSMC.StopQueue): Promise<WsSMC.SMCQueueResponse> {
+    StopQueue(request: Partial<WsSMC.StopQueue>): Promise<WsSMC.SMCQueueResponse> {
         return this._connection.send("StopQueue", request, "json", false, undefined, "SMCQueueResponse");
     }
 
diff --git a/packages/comms/src/services/wsdl/WsSMC/v1.28/WsSMC.ts b/packages/comms/src/services/wsdl/WsSMC/v1.28/WsSMC.ts
new file mode 100644
index 0000000000..70a503bdcd
--- /dev/null
+++ b/packages/comms/src/services/wsdl/WsSMC/v1.28/WsSMC.ts
@@ -0,0 +1,645 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsSMC {
+
+    export type int = number;
+    export type dateTime = string;
+    export type unsignedInt = number;
+    export type long = number;
+
+    export enum LockModes {
+        ALL = "ALL",
+        READ = "READ",
+        WRITE = "WRITE",
+        HOLD = "HOLD",
+        SUB = "SUB"
+    }
+
+    export enum RoxieControlCmdType {
+        Attach = "Attach",
+        Detach = "Detach",
+        State = "State",
+        Reload = "Reload",
+        ReloadRetry = "ReloadRetry",
+        MemLock = "MemLock",
+        MemUnlock = "MemUnlock",
+        GetMemLocked = "GetMemLocked"
+    }
+
+    export interface Activity {
+        ChatURL: string;
+        BannerContent: string;
+        BannerColor: string;
+        BannerSize: string;
+        BannerScroll: string;
+        BannerAction: int;
+        EnableChatURL: boolean;
+        FromSubmitBtn: boolean;
+        SortBy: string;
+        Descending: boolean;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface TargetCluster {
+        ClusterName: string;
+        QueueName: string;
+        QueueStatus: string;
+        StatusDetails: string;
+        Warning: string;
+        ClusterType: int;
+        ClusterSize: int;
+        ClusterStatus: int;
+    }
+
+    export interface ThorClusterList {
+        TargetCluster: TargetCluster[];
+    }
+
+    export interface RoxieClusterList {
+        TargetCluster: TargetCluster[];
+    }
+
+    export interface HThorClusterList {
+        TargetCluster: TargetCluster[];
+    }
+
+    export interface DFUJob {
+        TimeStarted: string;
+        Done: int;
+        Total: int;
+        Command: string;
+    }
+
+    export interface DFUJobs {
+        DFUJob: DFUJob[];
+    }
+
+    export interface ActiveWorkunit {
+        Wuid: string;
+        State: string;
+        StateID: int;
+        Owner: string;
+        Jobname: string;
+        Server: string;
+        Instance: string;
+        Priority: string;
+        Extra: string;
+        GraphName: string;
+        Duration: string;
+        GID: string;
+        QueueName: string;
+        MemoryBlocked: int;
+        IsPausing: boolean;
+        Warning: string;
+        ClusterName: string;
+        ClusterType: string;
+        ClusterQueueName: string;
+        TargetClusterName: string;
+        NoAccess: boolean;
+    }
+
+    export interface Running {
+        ActiveWorkunit: ActiveWorkunit[];
+    }
+
+    export interface Queues {
+        ServerJobQueue: ServerJobQueue[];
+    }
+
+    export interface ServerJobQueue {
+        QueueName: string;
+        Queues: Queues;
+        ServerName: string;
+        ServerType: string;
+        QueueStatus: string;
+        StatusDetails: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+    export interface ServerJobQueues {
+        ServerJobQueue: ServerJobQueue[];
+    }
+
+    export interface ActivityResponse {
+        Exceptions: Exceptions;
+        Build: string;
+        ThorClusterList: ThorClusterList;
+        RoxieClusterList: RoxieClusterList;
+        HThorClusterList: HThorClusterList;
+        DFUJobs: DFUJobs;
+        Running: Running;
+        BannerContent: string;
+        BannerColor: string;
+        BannerSize: string;
+        BannerScroll: string;
+        ChatURL: string;
+        ShowBanner: int;
+        ShowChatURL: int;
+        SortBy: string;
+        Descending: boolean;
+        SuperUser: boolean;
+        AccessRight: string;
+        ServerJobQueues: ServerJobQueues;
+        ActivityTime: string;
+        DaliDetached: boolean;
+    }
+
+    export interface BrowseResources {
+
+    }
+
+    export interface HPCCResource {
+        Name: string;
+        Description: string;
+        FileName: string;
+        Version: string;
+    }
+
+    export interface HPCCResources {
+        HPCCResource: HPCCResource[];
+    }
+
+    export interface HPCCResourceRepository {
+        Name: string;
+        Path: string;
+        HPCCResources: HPCCResources;
+    }
+
+    export interface HPCCResourceRepositories {
+        HPCCResourceRepository: HPCCResourceRepository[];
+    }
+
+    export interface BrowseResourcesResponse {
+        Exceptions: Exceptions;
+        PortalURL: string;
+        ESPInstance: string;
+        OS: int;
+        UseResource: boolean;
+        HPCCResourceRepositories: HPCCResourceRepositories;
+    }
+
+    export interface ClearQueue {
+        Cluster: string;
+        QueueName: string;
+        Comment: string;
+        ServerType: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+    export interface TargetClusterInfo {
+        ClusterName: string;
+        QueueName: string;
+        QueueStatus: string;
+        StatusDetails: string;
+        Warning: string;
+        ClusterType: int;
+        ClusterSize: int;
+        ClusterStatus: int;
+    }
+
+    export interface ServerInfo {
+        QueueName: string;
+        Queues: Queues;
+        ServerName: string;
+        ServerType: string;
+        QueueStatus: string;
+        StatusDetails: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+    export interface Workunits {
+        ActiveWorkunit: ActiveWorkunit[];
+    }
+
+    export interface StatusServerInfo {
+        TargetClusterInfo: TargetClusterInfo;
+        ServerInfo: ServerInfo;
+        Workunits: Workunits;
+    }
+
+    export interface SMCQueueResponse {
+        Exceptions: Exceptions;
+        StatusServerInfo: StatusServerInfo;
+    }
+
+    export interface GetBuildInfo {
+
+    }
+
+    export interface NamedValue {
+        Name: string;
+        Value: string;
+    }
+
+    export interface BuildInfo {
+        NamedValue: NamedValue[];
+    }
+
+    export interface GetBuildInfoResponse {
+        Exceptions: Exceptions;
+        BuildInfo: BuildInfo;
+    }
+
+    export interface Dimension {
+        Name: string;
+        Value: string;
+    }
+
+    export interface Dimensions {
+        Dimension: Dimension[];
+    }
+
+    export interface DateTimeRange {
+        Start: dateTime;
+        End: dateTime;
+    }
+
+    export interface GetGlobalMetrics {
+        Category: string;
+        Dimensions: Dimensions;
+        DateTimeRange: DateTimeRange;
+    }
+
+    export interface Dimensions2 {
+        Dimension: Dimension[];
+    }
+
+    export interface Stat {
+        Name: string;
+        Value: string;
+    }
+
+    export interface Stats {
+        Stat: Stat[];
+    }
+
+    export interface GlobalMetric {
+        Category: string;
+        Dimensions: Dimensions2;
+        DateTimeRange: DateTimeRange;
+        Stats: Stats;
+    }
+
+    export interface GlobalMetrics {
+        GlobalMetric: GlobalMetric[];
+    }
+
+    export interface GetGlobalMetricsResponse {
+        Exceptions: Exceptions;
+        GlobalMetrics: GlobalMetrics;
+    }
+
+    export interface GetStatusServerInfo {
+        ServerName: string;
+        ServerType: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+    export interface GetStatusServerInfoResponse {
+        Exceptions: Exceptions;
+        StatusServerInfo: StatusServerInfo;
+    }
+
+    export interface GetThorQueueAvailability {
+
+    }
+
+    export interface ThorCluster {
+        ClusterName: string;
+        QueueName: string;
+        QueueStatus: string;
+        QueueAvailable: int;
+        JobsRunning: int;
+        JobsInQueue: int;
+        QueueStatus2: int;
+        ThorLCR: string;
+        ClusterSize: int;
+    }
+
+    export interface ThorClusters {
+        ThorCluster: ThorCluster[];
+    }
+
+    export interface GetThorQueueAvailabilityResponse {
+        Exceptions: Exceptions;
+        ThorClusters: ThorClusters;
+    }
+
+    export interface Index {
+
+    }
+
+    export interface SMCIndexResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface LockQuery {
+        EPIP: string;
+        XPath: string;
+        DurationMSLow: unsignedInt;
+        DurationMSHigh: unsignedInt;
+        TimeLockedLow: string;
+        TimeLockedHigh: string;
+        Mode: LockModes;
+        AllFileLocks: boolean;
+    }
+
+    export interface ModeNames {
+        Item: string[];
+    }
+
+    export interface Lock {
+        EPIP: string;
+        XPath: string;
+        LogicalFile: string;
+        SessionID: long;
+        DurationMS: unsignedInt;
+        TimeLocked: string;
+        Modes: string;
+        ModeNames: ModeNames;
+    }
+
+    export interface Locks {
+        Lock: Lock[];
+    }
+
+    export interface LockQueryResponse {
+        Exceptions: Exceptions;
+        Locks: Locks;
+        NumLocks: int;
+    }
+
+    export interface MoveJobBack {
+        ClusterType: int;
+        Cluster: string;
+        QueueName: string;
+        Wuid: string;
+    }
+
+    export interface SMCJobResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface MoveJobDown {
+        ClusterType: int;
+        Cluster: string;
+        QueueName: string;
+        Wuid: string;
+    }
+
+    export interface MoveJobFront {
+        ClusterType: int;
+        Cluster: string;
+        QueueName: string;
+        Wuid: string;
+    }
+
+    export interface MoveJobUp {
+        ClusterType: int;
+        Cluster: string;
+        QueueName: string;
+        Wuid: string;
+    }
+
+    export interface NotInCommunityEdition {
+        EEPortal: string;
+    }
+
+    export interface NotInCommunityEditionResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface PauseQueue {
+        Cluster: string;
+        QueueName: string;
+        Comment: string;
+        ServerType: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+    export interface Ping {
+
+    }
+
+    export interface WsSMCPingResponse {
+
+    }
+
+    export interface RemoveJob {
+        ClusterType: int;
+        Cluster: string;
+        QueueName: string;
+        Wuid: string;
+    }
+
+    export interface ResumeQueue {
+        Cluster: string;
+        QueueName: string;
+        Comment: string;
+        ServerType: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+    export interface RoxieControlCmd {
+        ProcessCluster: string;
+        TargetCluster: string;
+        Command: RoxieControlCmdType;
+        Wait: int;
+    }
+
+    export interface Endpoint {
+        Address: string;
+        Attached: boolean;
+        StateHash: string;
+        Status: string;
+        MemLocked: boolean;
+    }
+
+    export interface Endpoints {
+        Endpoint: Endpoint[];
+    }
+
+    export interface RoxieControlCmdResponse {
+        Exceptions: Exceptions;
+        Endpoints: Endpoints;
+    }
+
+    export interface QueryIds {
+        Item: string[];
+    }
+
+    export interface RoxieXrefCmd {
+        RoxieCluster: string;
+        QueryIds: QueryIds;
+        CheckAllNodes: boolean;
+        Wait: int;
+    }
+
+    export interface RoxieXrefCmdResponse {
+        Exceptions: Exceptions;
+        Result: string;
+    }
+
+    export interface SetBanner {
+        ChatURL: string;
+        BannerContent: string;
+        BannerColor: string;
+        BannerSize: string;
+        BannerScroll: string;
+        BannerAction: int;
+        EnableChatURL: boolean;
+        FromSubmitBtn: boolean;
+    }
+
+    export interface SetBannerResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface SMCJob {
+        Wuid: string;
+        QueueName: string;
+    }
+
+    export interface SMCJobs {
+        SMCJob: SMCJob[];
+    }
+
+    export interface SetJobPriority {
+        QueueName: string;
+        Wuid: string;
+        Priority: string;
+        SMCJobs: SMCJobs;
+    }
+
+    export interface SMCPriorityResponse {
+        Exceptions: Exceptions;
+    }
+
+    export interface StopQueue {
+        Cluster: string;
+        QueueName: string;
+        Comment: string;
+        ServerType: string;
+        NetworkAddress: string;
+        Port: int;
+    }
+
+}
+
+export class SMCServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsSMC", "1.28");
+    }
+
+    Activity(request: Partial<WsSMC.Activity>): Promise<WsSMC.ActivityResponse> {
+        return this._connection.send("Activity", request, "json", false, undefined, "ActivityResponse");
+    }
+
+    BrowseResources(request: Partial<WsSMC.BrowseResources>): Promise<WsSMC.BrowseResourcesResponse> {
+        return this._connection.send("BrowseResources", request, "json", false, undefined, "BrowseResourcesResponse");
+    }
+
+    ClearQueue(request: Partial<WsSMC.ClearQueue>): Promise<WsSMC.SMCQueueResponse> {
+        return this._connection.send("ClearQueue", request, "json", false, undefined, "SMCQueueResponse");
+    }
+
+    GetBuildInfo(request: Partial<WsSMC.GetBuildInfo>): Promise<WsSMC.GetBuildInfoResponse> {
+        return this._connection.send("GetBuildInfo", request, "json", false, undefined, "GetBuildInfoResponse");
+    }
+
+    GetGlobalMetrics(request: Partial<WsSMC.GetGlobalMetrics>): Promise<WsSMC.GetGlobalMetricsResponse> {
+        return this._connection.send("GetGlobalMetrics", request, "json", false, undefined, "GetGlobalMetricsResponse");
+    }
+
+    GetStatusServerInfo(request: Partial<WsSMC.GetStatusServerInfo>): Promise<WsSMC.GetStatusServerInfoResponse> {
+        return this._connection.send("GetStatusServerInfo", request, "json", false, undefined, "GetStatusServerInfoResponse");
+    }
+
+    GetThorQueueAvailability(request: Partial<WsSMC.GetThorQueueAvailability>): Promise<WsSMC.GetThorQueueAvailabilityResponse> {
+        return this._connection.send("GetThorQueueAvailability", request, "json", false, undefined, "GetThorQueueAvailabilityResponse");
+    }
+
+    Index(request: Partial<WsSMC.Index>): Promise<WsSMC.SMCIndexResponse> {
+        return this._connection.send("Index", request, "json", false, undefined, "SMCIndexResponse");
+    }
+
+    LockQuery(request: Partial<WsSMC.LockQuery>): Promise<WsSMC.LockQueryResponse> {
+        return this._connection.send("LockQuery", request, "json", false, undefined, "LockQueryResponse");
+    }
+
+    MoveJobBack(request: Partial<WsSMC.MoveJobBack>): Promise<WsSMC.SMCJobResponse> {
+        return this._connection.send("MoveJobBack", request, "json", false, undefined, "SMCJobResponse");
+    }
+
+    MoveJobDown(request: Partial<WsSMC.MoveJobDown>): Promise<WsSMC.SMCJobResponse> {
+        return this._connection.send("MoveJobDown", request, "json", false, undefined, "SMCJobResponse");
+    }
+
+    MoveJobFront(request: Partial<WsSMC.MoveJobFront>): Promise<WsSMC.SMCJobResponse> {
+        return this._connection.send("MoveJobFront", request, "json", false, undefined, "SMCJobResponse");
+    }
+
+    MoveJobUp(request: Partial<WsSMC.MoveJobUp>): Promise<WsSMC.SMCJobResponse> {
+        return this._connection.send("MoveJobUp", request, "json", false, undefined, "SMCJobResponse");
+    }
+
+    NotInCommunityEdition(request: Partial<WsSMC.NotInCommunityEdition>): Promise<WsSMC.NotInCommunityEditionResponse> {
+        return this._connection.send("NotInCommunityEdition", request, "json", false, undefined, "NotInCommunityEditionResponse");
+    }
+
+    PauseQueue(request: Partial<WsSMC.PauseQueue>): Promise<WsSMC.SMCQueueResponse> {
+        return this._connection.send("PauseQueue", request, "json", false, undefined, "SMCQueueResponse");
+    }
+
+    Ping(request: Partial<WsSMC.Ping>): Promise<WsSMC.WsSMCPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsSMCPingResponse");
+    }
+
+    RemoveJob(request: Partial<WsSMC.RemoveJob>): Promise<WsSMC.SMCJobResponse> {
+        return this._connection.send("RemoveJob", request, "json", false, undefined, "SMCJobResponse");
+    }
+
+    ResumeQueue(request: Partial<WsSMC.ResumeQueue>): Promise<WsSMC.SMCQueueResponse> {
+        return this._connection.send("ResumeQueue", request, "json", false, undefined, "SMCQueueResponse");
+    }
+
+    RoxieControlCmd(request: Partial<WsSMC.RoxieControlCmd>): Promise<WsSMC.RoxieControlCmdResponse> {
+        return this._connection.send("RoxieControlCmd", request, "json", false, undefined, "RoxieControlCmdResponse");
+    }
+
+    RoxieXrefCmd(request: Partial<WsSMC.RoxieXrefCmd>): Promise<WsSMC.RoxieXrefCmdResponse> {
+        return this._connection.send("RoxieXrefCmd", request, "json", false, undefined, "RoxieXrefCmdResponse");
+    }
+
+    SetBanner(request: Partial<WsSMC.SetBanner>): Promise<WsSMC.SetBannerResponse> {
+        return this._connection.send("SetBanner", request, "json", false, undefined, "SetBannerResponse");
+    }
+
+    SetJobPriority(request: Partial<WsSMC.SetJobPriority>): Promise<WsSMC.SMCPriorityResponse> {
+        return this._connection.send("SetJobPriority", request, "json", false, undefined, "SMCPriorityResponse");
+    }
+
+    StopQueue(request: Partial<WsSMC.StopQueue>): Promise<WsSMC.SMCQueueResponse> {
+        return this._connection.send("StopQueue", request, "json", false, undefined, "SMCQueueResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsTopology/v1.32/WsTopology.ts b/packages/comms/src/services/wsdl/WsTopology/v1.32/WsTopology.ts
index 77f0906dcb..ea4c1fdbdc 100644
--- a/packages/comms/src/services/wsdl/WsTopology/v1.32/WsTopology.ts
+++ b/packages/comms/src/services/wsdl/WsTopology/v1.32/WsTopology.ts
@@ -14,6 +14,19 @@ export namespace WsTopology {
         WorkunitsOnly = "WorkunitsOnly"
     }
 
+    export enum TpMachineType {
+        ALLNODES = "ALLNODES",
+        THORMACHINES = "THORMACHINES",
+        HOLEMACHINES = "HOLEMACHINES",
+        ROXIEMACHINES = "ROXIEMACHINES",
+        MACHINES = "MACHINES",
+        AVAILABLEMACHINES = "AVAILABLEMACHINES",
+        DROPZONE = "DROPZONE",
+        STANDBYNNODE = "STANDBYNNODE",
+        THORSPARENODES = "THORSPARENODES",
+        HOLESTANDBYNODES = "HOLESTANDBYNODES"
+    }
+
     export interface WsTopologyPingRequest {
 
     }
@@ -41,10 +54,7 @@ export namespace WsTopology {
     }
 
     export interface SystemLogResponse {
-        Exceptions: {
-            Source: string;
-            Exception: Exception[];
-        };
+        Exceptions: Exceptions;
         thefile: base64Binary;
     }
 
@@ -65,9 +75,7 @@ export namespace WsTopology {
         Exceptions: Exceptions;
         Name: string;
         WorkUnit: string;
-        TpQueues: {
-            TpQueue: TpQueue[];
-        };
+        TpQueues: TpQueues;
     }
 
     export interface TpClusterQueryRequest {
@@ -105,9 +113,7 @@ export namespace WsTopology {
         DataModel: string;
         OS: int;
         HasThorSpareProcess: boolean;
-        TpMachines: {
-            TpMachine: TpMachine[];
-        };
+        TpMachines: TpMachines;
     }
 
     export interface TpClusters {
@@ -118,9 +124,7 @@ export namespace WsTopology {
         Exceptions: Exceptions;
         EnableSNMP: boolean;
         AcceptLanguage: string;
-        TpClusters: {
-            TpCluster: TpCluster[];
-        };
+        TpClusters: TpClusters;
     }
 
     export interface TpDropZoneQueryRequest {
@@ -144,9 +148,7 @@ export namespace WsTopology {
 
     export interface TpDropZoneQueryResponse {
         Exceptions: Exceptions;
-        TpDropZones: {
-            TpDropZone: TpDropZone[];
-        };
+        TpDropZones: TpDropZones;
     }
 
     export interface TpGetComponentFileRequest {
@@ -181,9 +183,7 @@ export namespace WsTopology {
 
     export interface TpGetServicePluginsResponse {
         Exceptions: Exceptions;
-        Plugins: {
-            Plugin: Plugin[];
-        };
+        Plugins: Plugins;
     }
 
     export interface TpGroupQueryRequest {
@@ -202,9 +202,7 @@ export namespace WsTopology {
 
     export interface TpGroupQueryResponse {
         Exceptions: Exceptions;
-        TpGroups: {
-            TpGroup: TpGroup[];
-        };
+        TpGroups: TpGroups;
     }
 
     export interface TpListLogFilesRequest {
@@ -227,9 +225,7 @@ export namespace WsTopology {
 
     export interface TpListLogFilesResponse {
         Exceptions: Exceptions;
-        Files: {
-            LogFileStruct: LogFileStruct[];
-        };
+        Files: Files;
     }
 
     export interface TpListTargetClustersRequest {
@@ -248,9 +244,7 @@ export namespace WsTopology {
 
     export interface TpListTargetClustersResponse {
         Exceptions: Exceptions;
-        TargetClusters: {
-            TpClusterNameType: TpClusterNameType[];
-        };
+        TargetClusters: TargetClusters;
     }
 
     export interface TpLogFileRequest {
@@ -295,9 +289,7 @@ export namespace WsTopology {
         NextPage: int;
         TotalPages: int;
         AcceptLanguage: string;
-        LogFieldNames: {
-            Item: string[];
-        };
+        LogFieldNames: LogFieldNames;
     }
 
     export interface TpLogicalClusterQueryRequest {
@@ -320,9 +312,7 @@ export namespace WsTopology {
 
     export interface TpLogicalClusterQueryResponse {
         Exceptions: Exceptions;
-        TpLogicalClusters: {
-            TpLogicalCluster: TpLogicalCluster[];
-        };
+        TpLogicalClusters: TpLogicalClusters;
     }
 
     export interface TpMachineInfoRequest {
@@ -347,24 +337,11 @@ export namespace WsTopology {
 
     export interface TpMachineInfoResponse {
         Exceptions: Exceptions;
-        MachineInfo: {
-            Name: string;
-            Netaddress: string;
-            ConfigNetaddress: string;
-            Domain: string;
-            Directory: string;
-            Type: string;
-            Available: string;
-            OS: int;
-            Path: string;
-            Port: int;
-            ProcessNumber: int;
-            Channels: unsignedInt;
-        };
+        MachineInfo: MachineInfo;
     }
 
     export interface TpMachineQueryRequest {
-        Type?: string;
+        Type?: TpMachineType;
         Cluster?: string;
         OldIP?: string;
         Path?: string;
@@ -376,7 +353,7 @@ export namespace WsTopology {
         Exceptions: Exceptions;
         EnablePreflightInfo: boolean;
         HasThorSpareProcess: boolean;
-        Type: string;
+        Type: TpMachineType;
         Cluster: string;
         OldIP: string;
         LogDirectory: string;
@@ -509,9 +486,7 @@ export namespace WsTopology {
         Path: string;
         LogDirectory: string;
         TpMachines: TpMachines;
-        TpBindings: {
-            TpBinding: TpBinding[];
-        };
+        TpBindings: TpBindings;
     }
 
     export interface TpEspServers {
@@ -601,49 +576,21 @@ export namespace WsTopology {
     }
 
     export interface ServiceList {
-        TpDalis: {
-            TpDali: TpDali[];
-        };
-        TpDfuServers: {
-            TpDfuServer: TpDfuServer[];
-        };
-        TpDkcSlaves: {
-            TpDkcSlave: TpDkcSlave[];
-        };
+        TpDalis: TpDalis;
+        TpDfuServers: TpDfuServers;
+        TpDkcSlaves: TpDkcSlaves;
         TpDropZones: TpDropZones;
-        TpEclAgents: {
-            TpEclAgent: TpEclAgent[];
-        };
-        TpEclServers: {
-            TpEclServer: TpEclServer[];
-        };
-        TpEclCCServers: {
-            TpEclServer: TpEclServer[];
-        };
-        TpEclSchedulers: {
-            TpEclScheduler: TpEclScheduler[];
-        };
-        TpEspServers: {
-            TpEspServer: TpEspServer[];
-        };
-        TpFTSlaves: {
-            TpFTSlave: TpFTSlave[];
-        };
-        TpGenesisServers: {
-            TpGenesisServer: TpGenesisServer[];
-        };
-        TpLdapServers: {
-            TpLdapServer: TpLdapServer[];
-        };
-        TpMySqlServers: {
-            TpMySqlServer: TpMySqlServer[];
-        };
-        TpSashaServers: {
-            TpSashaServer: TpSashaServer[];
-        };
-        TpSparkThors: {
-            TpSparkThor: TpSparkThor[];
-        };
+        TpEclAgents: TpEclAgents;
+        TpEclServers: TpEclServers;
+        TpEclCCServers: TpEclCCServers;
+        TpEclSchedulers: TpEclSchedulers;
+        TpEspServers: TpEspServers;
+        TpFTSlaves: TpFTSlaves;
+        TpGenesisServers: TpGenesisServers;
+        TpLdapServers: TpLdapServers;
+        TpMySqlServers: TpMySqlServers;
+        TpSashaServers: TpSashaServers;
+        TpSparkThors: TpSparkThors;
     }
 
     export interface TpServiceQueryResponse {
@@ -657,51 +604,7 @@ export namespace WsTopology {
         AcceptLanguage: string;
         MemThresholdType: string;
         DiskThresholdType: string;
-        ServiceList: {
-            TpDalis: {
-                TpDali: TpDali[];
-            };
-            TpDfuServers: {
-                TpDfuServer: TpDfuServer[];
-            };
-            TpDkcSlaves: {
-                TpDkcSlave: TpDkcSlave[];
-            };
-            TpDropZones: TpDropZones;
-            TpEclAgents: {
-                TpEclAgent: TpEclAgent[];
-            };
-            TpEclServers: {
-                TpEclServer: TpEclServer[];
-            };
-            TpEclCCServers: {
-                TpEclServer: TpEclServer[];
-            };
-            TpEclSchedulers: {
-                TpEclScheduler: TpEclScheduler[];
-            };
-            TpEspServers: {
-                TpEspServer: TpEspServer[];
-            };
-            TpFTSlaves: {
-                TpFTSlave: TpFTSlave[];
-            };
-            TpGenesisServers: {
-                TpGenesisServer: TpGenesisServer[];
-            };
-            TpLdapServers: {
-                TpLdapServer: TpLdapServer[];
-            };
-            TpMySqlServers: {
-                TpMySqlServer: TpMySqlServer[];
-            };
-            TpSashaServers: {
-                TpSashaServer: TpSashaServer[];
-            };
-            TpSparkThors: {
-                TpSparkThor: TpSparkThor[];
-            };
-        };
+        ServiceList: ServiceList;
     }
 
     export interface TpSetMachineStatusRequest {
@@ -756,9 +659,7 @@ export namespace WsTopology {
         DiskThresholdType: string;
         PreflightProcessFilter: string;
         AcceptLanguage: string;
-        TpTargetClusters: {
-            TpTargetCluster: TpTargetCluster[];
-        };
+        TpTargetClusters: TpTargetClusters;
     }
 
     export interface TpThorStatusRequest {
@@ -798,87 +699,87 @@ export class TopologyServiceBase extends Service {
         super(optsConnection, "WsTopology", "1.32");
     }
 
-    Ping(request: WsTopology.WsTopologyPingRequest): Promise<WsTopology.WsTopologyPingResponse> {
+    Ping(request: Partial<WsTopology.WsTopologyPingRequest>): Promise<WsTopology.WsTopologyPingResponse> {
         return this._connection.send("Ping", request, "json", false, undefined, "WsTopologyPingResponse");
     }
 
-    SystemLog(request: WsTopology.SystemLogRequest): Promise<WsTopology.SystemLogResponse> {
+    SystemLog(request: Partial<WsTopology.SystemLogRequest>): Promise<WsTopology.SystemLogResponse> {
         return this._connection.send("SystemLog", request, "json", false, undefined, "SystemLogResponse");
     }
 
-    TpClusterInfo(request: WsTopology.TpClusterInfoRequest): Promise<WsTopology.TpClusterInfoResponse> {
+    TpClusterInfo(request: Partial<WsTopology.TpClusterInfoRequest>): Promise<WsTopology.TpClusterInfoResponse> {
         return this._connection.send("TpClusterInfo", request, "json", false, undefined, "TpClusterInfoResponse");
     }
 
-    TpClusterQuery(request: WsTopology.TpClusterQueryRequest): Promise<WsTopology.TpClusterQueryResponse> {
+    TpClusterQuery(request: Partial<WsTopology.TpClusterQueryRequest>): Promise<WsTopology.TpClusterQueryResponse> {
         return this._connection.send("TpClusterQuery", request, "json", false, undefined, "TpClusterQueryResponse");
     }
 
-    TpDropZoneQuery(request: WsTopology.TpDropZoneQueryRequest): Promise<WsTopology.TpDropZoneQueryResponse> {
+    TpDropZoneQuery(request: Partial<WsTopology.TpDropZoneQueryRequest>): Promise<WsTopology.TpDropZoneQueryResponse> {
         return this._connection.send("TpDropZoneQuery", request, "json", false, undefined, "TpDropZoneQueryResponse");
     }
 
-    TpGetComponentFile(request: WsTopology.TpGetComponentFileRequest): Promise<WsTopology.TpGetComponentFileResponse> {
+    TpGetComponentFile(request: Partial<WsTopology.TpGetComponentFileRequest>): Promise<WsTopology.TpGetComponentFileResponse> {
         return this._connection.send("TpGetComponentFile", request, "json", false, undefined, "TpGetComponentFileResponse");
     }
 
-    TpGetServicePlugins(request: WsTopology.TpGetServicePluginsRequest): Promise<WsTopology.TpGetServicePluginsResponse> {
+    TpGetServicePlugins(request: Partial<WsTopology.TpGetServicePluginsRequest>): Promise<WsTopology.TpGetServicePluginsResponse> {
         return this._connection.send("TpGetServicePlugins", request, "json", false, undefined, "TpGetServicePluginsResponse");
     }
 
-    TpGroupQuery(request: WsTopology.TpGroupQueryRequest): Promise<WsTopology.TpGroupQueryResponse> {
+    TpGroupQuery(request: Partial<WsTopology.TpGroupQueryRequest>): Promise<WsTopology.TpGroupQueryResponse> {
         return this._connection.send("TpGroupQuery", request, "json", false, undefined, "TpGroupQueryResponse");
     }
 
-    TpListLogFiles(request: WsTopology.TpListLogFilesRequest): Promise<WsTopology.TpListLogFilesResponse> {
+    TpListLogFiles(request: Partial<WsTopology.TpListLogFilesRequest>): Promise<WsTopology.TpListLogFilesResponse> {
         return this._connection.send("TpListLogFiles", request, "json", false, undefined, "TpListLogFilesResponse");
     }
 
-    TpListTargetClusters(request: WsTopology.TpListTargetClustersRequest): Promise<WsTopology.TpListTargetClustersResponse> {
+    TpListTargetClusters(request: Partial<WsTopology.TpListTargetClustersRequest>): Promise<WsTopology.TpListTargetClustersResponse> {
         return this._connection.send("TpListTargetClusters", request, "json", false, undefined, "TpListTargetClustersResponse");
     }
 
-    TpLogFile(request: WsTopology.TpLogFileRequest): Promise<WsTopology.TpLogFileResponse> {
+    TpLogFile(request: Partial<WsTopology.TpLogFileRequest>): Promise<WsTopology.TpLogFileResponse> {
         return this._connection.send("TpLogFile", request, "json", false, undefined, "TpLogFileResponse");
     }
 
-    TpLogFileDisplay(request: WsTopology.TpLogFileRequest): Promise<WsTopology.TpLogFileResponse> {
+    TpLogFileDisplay(request: Partial<WsTopology.TpLogFileRequest>): Promise<WsTopology.TpLogFileResponse> {
         return this._connection.send("TpLogFileDisplay", request, "json", false, undefined, "TpLogFileResponse");
     }
 
-    TpLogicalClusterQuery(request: WsTopology.TpLogicalClusterQueryRequest): Promise<WsTopology.TpLogicalClusterQueryResponse> {
+    TpLogicalClusterQuery(request: Partial<WsTopology.TpLogicalClusterQueryRequest>): Promise<WsTopology.TpLogicalClusterQueryResponse> {
         return this._connection.send("TpLogicalClusterQuery", request, "json", false, undefined, "TpLogicalClusterQueryResponse");
     }
 
-    TpMachineInfo(request: WsTopology.TpMachineInfoRequest): Promise<WsTopology.TpMachineInfoResponse> {
+    TpMachineInfo(request: Partial<WsTopology.TpMachineInfoRequest>): Promise<WsTopology.TpMachineInfoResponse> {
         return this._connection.send("TpMachineInfo", request, "json", false, undefined, "TpMachineInfoResponse");
     }
 
-    TpMachineQuery(request: WsTopology.TpMachineQueryRequest): Promise<WsTopology.TpMachineQueryResponse> {
+    TpMachineQuery(request: Partial<WsTopology.TpMachineQueryRequest>): Promise<WsTopology.TpMachineQueryResponse> {
         return this._connection.send("TpMachineQuery", request, "json", false, undefined, "TpMachineQueryResponse");
     }
 
-    TpServiceQuery(request: WsTopology.TpServiceQueryRequest): Promise<WsTopology.TpServiceQueryResponse> {
+    TpServiceQuery(request: Partial<WsTopology.TpServiceQueryRequest>): Promise<WsTopology.TpServiceQueryResponse> {
         return this._connection.send("TpServiceQuery", request, "json", false, undefined, "TpServiceQueryResponse");
     }
 
-    TpSetMachineStatus(request: WsTopology.TpSetMachineStatusRequest): Promise<WsTopology.TpSetMachineStatusResponse> {
+    TpSetMachineStatus(request: Partial<WsTopology.TpSetMachineStatusRequest>): Promise<WsTopology.TpSetMachineStatusResponse> {
         return this._connection.send("TpSetMachineStatus", request, "json", false, undefined, "TpSetMachineStatusResponse");
     }
 
-    TpSwapNode(request: WsTopology.TpSwapNodeRequest): Promise<WsTopology.TpSwapNodeResponse> {
+    TpSwapNode(request: Partial<WsTopology.TpSwapNodeRequest>): Promise<WsTopology.TpSwapNodeResponse> {
         return this._connection.send("TpSwapNode", request, "json", false, undefined, "TpSwapNodeResponse");
     }
 
-    TpTargetClusterQuery(request: WsTopology.TpTargetClusterQueryRequest): Promise<WsTopology.TpTargetClusterQueryResponse> {
+    TpTargetClusterQuery(request: Partial<WsTopology.TpTargetClusterQueryRequest>): Promise<WsTopology.TpTargetClusterQueryResponse> {
         return this._connection.send("TpTargetClusterQuery", request, "json", false, undefined, "TpTargetClusterQueryResponse");
     }
 
-    TpThorStatus(request: WsTopology.TpThorStatusRequest): Promise<WsTopology.TpThorStatusResponse> {
+    TpThorStatus(request: Partial<WsTopology.TpThorStatusRequest>): Promise<WsTopology.TpThorStatusResponse> {
         return this._connection.send("TpThorStatus", request, "json", false, undefined, "TpThorStatusResponse");
     }
 
-    TpXMLFile(request: WsTopology.TpXMLFileRequest): Promise<WsTopology.TpXMLFileResponse> {
+    TpXMLFile(request: Partial<WsTopology.TpXMLFileRequest>): Promise<WsTopology.TpXMLFileResponse> {
         return this._connection.send("TpXMLFile", request, "json", false, undefined, "TpXMLFileResponse");
     }
 
diff --git a/packages/comms/src/services/wsdl/WsTopology/v1.33/WsTopology.ts b/packages/comms/src/services/wsdl/WsTopology/v1.33/WsTopology.ts
new file mode 100644
index 0000000000..2846a47fbe
--- /dev/null
+++ b/packages/comms/src/services/wsdl/WsTopology/v1.33/WsTopology.ts
@@ -0,0 +1,835 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsTopology {
+
+    export type int = number;
+    export type base64Binary = string;
+    export type unsignedInt = number;
+    export type long = number;
+
+    export enum TpConfigResponseFormat {
+        XML = "XML",
+        YAML = "YAML"
+    }
+
+    export enum RoxieQueueFilter {
+        All = "All",
+        QueriesOnly = "QueriesOnly",
+        WorkunitsOnly = "WorkunitsOnly"
+    }
+
+    export enum TpMachineType {
+        ALLNODES = "ALLNODES",
+        THORMACHINES = "THORMACHINES",
+        HOLEMACHINES = "HOLEMACHINES",
+        ROXIEMACHINES = "ROXIEMACHINES",
+        MACHINES = "MACHINES",
+        AVAILABLEMACHINES = "AVAILABLEMACHINES",
+        DROPZONE = "DROPZONE",
+        STANDBYNNODE = "STANDBYNNODE",
+        THORSPARENODES = "THORSPARENODES",
+        HOLESTANDBYNODES = "HOLESTANDBYNODES"
+    }
+
+    export interface WsTopologyPingRequest {
+
+    }
+
+    export interface WsTopologyPingResponse {
+
+    }
+
+    export interface SystemLogRequest {
+        Name?: string;
+        Type?: string;
+        Zip?: int;
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface SystemLogResponse {
+        Exceptions: Exceptions;
+        thefile: base64Binary;
+    }
+
+    export interface TpClusterInfoRequest {
+        Name?: string;
+    }
+
+    export interface TpQueue {
+        Name: string;
+        WorkUnit: string;
+    }
+
+    export interface TpQueues {
+        TpQueue: TpQueue[];
+    }
+
+    export interface TpClusterInfoResponse {
+        Exceptions: Exceptions;
+        Name: string;
+        WorkUnit: string;
+        TpQueues: TpQueues;
+    }
+
+    export interface TpClusterQueryRequest {
+        Type?: string;
+    }
+
+    export interface TpMachine {
+        Name: string;
+        Netaddress: string;
+        ConfigNetaddress: string;
+        Domain: string;
+        Directory: string;
+        Type: string;
+        Available: string;
+        OS: int;
+        Path: string;
+        Port: int;
+        ProcessNumber: int;
+        Channels: unsignedInt;
+    }
+
+    export interface TpMachines {
+        TpMachine: TpMachine[];
+    }
+
+    export interface TpCluster {
+        Type: string;
+        Name: string;
+        QueueName: string;
+        Build: string;
+        Directory: string;
+        LogDirectory: string;
+        Desc: string;
+        Path: string;
+        DataModel: string;
+        OS: int;
+        HasThorSpareProcess: boolean;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpClusters {
+        TpCluster: TpCluster[];
+    }
+
+    export interface TpClusterQueryResponse {
+        Exceptions: Exceptions;
+        EnableSNMP: boolean;
+        AcceptLanguage: string;
+        TpClusters: TpClusters;
+    }
+
+    export interface ComponentNames {
+        Item: string[];
+    }
+
+    export interface TpComponentConfigurationRequest {
+        ComponentNames?: ComponentNames;
+    }
+
+    export interface Result {
+        ComponentName: string;
+        Configuration: string;
+    }
+
+    export interface Results {
+        Result: Result[];
+    }
+
+    export interface TpComponentConfigurationResponse {
+        Exceptions: Exceptions;
+        ConfigFormat: TpConfigResponseFormat;
+        Results: Results;
+    }
+
+    export interface TpConfiguredComponentsRequest {
+
+    }
+
+    export interface ConfiguredComponents {
+        Item: string[];
+    }
+
+    export interface TpConfiguredComponentsResponse {
+        Exceptions: Exceptions;
+        ConfiguredComponents: ConfiguredComponents;
+    }
+
+    export interface TpDropZoneQueryRequest {
+        Name?: string;
+        ECLWatchVisibleOnly?: boolean;
+    }
+
+    export interface TpDropZone {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        ECLWatchVisible: boolean;
+        UMask: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpDropZones {
+        TpDropZone: TpDropZone[];
+    }
+
+    export interface TpDropZoneQueryResponse {
+        Exceptions: Exceptions;
+        TpDropZones: TpDropZones;
+    }
+
+    export interface TpGetComponentFileRequest {
+        CompType?: string;
+        CompName?: string;
+        NetAddress?: string;
+        Directory?: string;
+        FileType?: string;
+        OsType?: int;
+        PlainText?: string;
+    }
+
+    export interface TpGetComponentFileResponse {
+        Exceptions: Exceptions;
+        FileContents: base64Binary;
+    }
+
+    export interface TpGetServicePluginsRequest {
+
+    }
+
+    export interface Plugin {
+        ShortName: string;
+        LongName: string;
+        FolderName: string;
+        WidgetName: string;
+    }
+
+    export interface Plugins {
+        Plugin: Plugin[];
+    }
+
+    export interface TpGetServicePluginsResponse {
+        Exceptions: Exceptions;
+        Plugins: Plugins;
+    }
+
+    export interface TpGroupQueryRequest {
+        Kind?: string;
+    }
+
+    export interface TpGroup {
+        Name: string;
+        Kind: string;
+        ReplicateOutputs: boolean;
+    }
+
+    export interface TpGroups {
+        TpGroup: TpGroup[];
+    }
+
+    export interface TpGroupQueryResponse {
+        Exceptions: Exceptions;
+        TpGroups: TpGroups;
+    }
+
+    export interface TpListLogFilesRequest {
+        NetworkAddress?: string;
+        Path?: string;
+    }
+
+    export interface LogFileStruct {
+        Name: string;
+        Path: string;
+        Host: string;
+        IsDir: boolean;
+        FileSize: long;
+        Modifiedtime: string;
+    }
+
+    export interface Files {
+        LogFileStruct: LogFileStruct[];
+    }
+
+    export interface TpListLogFilesResponse {
+        Exceptions: Exceptions;
+        Files: Files;
+    }
+
+    export interface TpListTargetClustersRequest {
+
+    }
+
+    export interface TpClusterNameType {
+        Name: string;
+        Type: string;
+        IsDefault: boolean;
+    }
+
+    export interface TargetClusters {
+        TpClusterNameType: TpClusterNameType[];
+    }
+
+    export interface TpListTargetClustersResponse {
+        Exceptions: Exceptions;
+        TargetClusters: TargetClusters;
+    }
+
+    export interface TpLogFileRequest {
+        Name?: string;
+        Type?: string;
+        LastHours?: int;
+        StartDate?: string;
+        EndDate?: string;
+        FirstRows?: int;
+        LastRows?: int;
+        FilterType?: int;
+        Reversely?: boolean;
+        Zip?: boolean;
+        PageNumber?: int;
+        LoadData?: boolean;
+        IncludeLogFieldNames?: boolean;
+    }
+
+    export interface LogFieldNames {
+        Item: string[];
+    }
+
+    export interface TpLogFileResponse {
+        Exceptions: Exceptions;
+        Name: string;
+        Type: string;
+        StartDate: string;
+        EndDate: string;
+        LastHours: int;
+        FirstRows: int;
+        LastRows: int;
+        Reversely: boolean;
+        Zip: boolean;
+        FilterType: int;
+        LogData: string;
+        HasDate: boolean;
+        FileSize: long;
+        PageFrom: long;
+        PageTo: long;
+        PageNumber: int;
+        PrevPage: int;
+        NextPage: int;
+        TotalPages: int;
+        AcceptLanguage: string;
+        LogFieldNames: LogFieldNames;
+    }
+
+    export interface TpLogicalClusterQueryRequest {
+        EclServerQueue?: string;
+        RoxieQueueFilter?: RoxieQueueFilter;
+    }
+
+    export interface TpLogicalCluster {
+        Name: string;
+        Queue: string;
+        LanguageVersion: string;
+        Process: string;
+        Type: string;
+        QueriesOnly: boolean;
+    }
+
+    export interface TpLogicalClusters {
+        TpLogicalCluster: TpLogicalCluster[];
+    }
+
+    export interface TpLogicalClusterQueryResponse {
+        Exceptions: Exceptions;
+        TpLogicalClusters: TpLogicalClusters;
+    }
+
+    export interface TpMachineInfoRequest {
+        Name?: string;
+        NetAddress?: string;
+    }
+
+    export interface MachineInfo {
+        Name: string;
+        Netaddress: string;
+        ConfigNetaddress: string;
+        Domain: string;
+        Directory: string;
+        Type: string;
+        Available: string;
+        OS: int;
+        Path: string;
+        Port: int;
+        ProcessNumber: int;
+        Channels: unsignedInt;
+    }
+
+    export interface TpMachineInfoResponse {
+        Exceptions: Exceptions;
+        MachineInfo: MachineInfo;
+    }
+
+    export interface TpMachineQueryRequest {
+        Type?: TpMachineType;
+        Cluster?: string;
+        OldIP?: string;
+        Path?: string;
+        Directory?: string;
+        LogDirectory?: string;
+    }
+
+    export interface TpMachineQueryResponse {
+        Exceptions: Exceptions;
+        EnablePreflightInfo: boolean;
+        HasThorSpareProcess: boolean;
+        Type: TpMachineType;
+        Cluster: string;
+        OldIP: string;
+        LogDirectory: string;
+        Path: string;
+        MemThreshold: int;
+        DiskThreshold: int;
+        CpuThreshold: int;
+        MemThresholdType: string;
+        DiskThresholdType: string;
+        PreflightProcessFilter: string;
+        EnableSNMP: boolean;
+        AcceptLanguage: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpServiceQueryRequest {
+        Type?: string;
+    }
+
+    export interface TpDali {
+        Name: string;
+        Description: string;
+        Build: string;
+        BackupComputer: string;
+        BackupDirectory: string;
+        Type: string;
+        Path: string;
+        LogDirectory: string;
+        AuditLogDirectory: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpDalis {
+        TpDali: TpDali[];
+    }
+
+    export interface TpDfuServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        Queue: string;
+        Type: string;
+        Path: string;
+        LogDirectory: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpDfuServers {
+        TpDfuServer: TpDfuServer[];
+    }
+
+    export interface TpDkcSlave {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpDkcSlaves {
+        TpDkcSlave: TpDkcSlave[];
+    }
+
+    export interface TpEclAgent {
+        Name: string;
+        Description: string;
+        Build: string;
+        Type: string;
+        Path: string;
+        DaliServer: string;
+        LogDir: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpEclAgents {
+        TpEclAgent: TpEclAgent[];
+    }
+
+    export interface TpEclServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        LogDirectory: string;
+        Type: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpEclServers {
+        TpEclServer: TpEclServer[];
+    }
+
+    export interface TpEclCCServers {
+        TpEclServer: TpEclServer[];
+    }
+
+    export interface TpEclScheduler {
+        Name: string;
+        Description: string;
+        Build: string;
+        LogDirectory: string;
+        Type: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpEclSchedulers {
+        TpEclScheduler: TpEclScheduler[];
+    }
+
+    export interface TpBinding {
+        Name: string;
+        Service: string;
+        ServiceType: string;
+        BindingType: string;
+        ServiceBuildSet: string;
+        Port: string;
+        Protocol: string;
+    }
+
+    export interface TpBindings {
+        TpBinding: TpBinding[];
+    }
+
+    export interface TpEspServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        Type: string;
+        Path: string;
+        LogDirectory: string;
+        TpMachines: TpMachines;
+        TpBindings: TpBindings;
+    }
+
+    export interface TpEspServers {
+        TpEspServer: TpEspServer[];
+    }
+
+    export interface TpFTSlave {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpFTSlaves {
+        TpFTSlave: TpFTSlave[];
+    }
+
+    export interface TpGenesisServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpGenesisServers {
+        TpGenesisServer: TpGenesisServer[];
+    }
+
+    export interface TpLdapServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpLdapServers {
+        TpLdapServer: TpLdapServer[];
+    }
+
+    export interface TpMySqlServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpMySqlServers {
+        TpMySqlServer: TpMySqlServer[];
+    }
+
+    export interface TpSashaServer {
+        Name: string;
+        Description: string;
+        Build: string;
+        Path: string;
+        LogDirectory: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpSashaServers {
+        TpSashaServer: TpSashaServer[];
+    }
+
+    export interface TpSparkThor {
+        Name: string;
+        Build: string;
+        ThorClusterName: string;
+        ThorPath: string;
+        SparkExecutorCores: unsignedInt;
+        SparkExecutorMemory: long;
+        SparkMasterPort: unsignedInt;
+        SparkMasterWebUIPort: unsignedInt;
+        SparkWorkerCores: unsignedInt;
+        SparkWorkerMemory: long;
+        SparkWorkerPort: unsignedInt;
+        LogDirectory: string;
+        Path: string;
+        TpMachines: TpMachines;
+    }
+
+    export interface TpSparkThors {
+        TpSparkThor: TpSparkThor[];
+    }
+
+    export interface ServiceList {
+        TpDalis: TpDalis;
+        TpDfuServers: TpDfuServers;
+        TpDkcSlaves: TpDkcSlaves;
+        TpDropZones: TpDropZones;
+        TpEclAgents: TpEclAgents;
+        TpEclServers: TpEclServers;
+        TpEclCCServers: TpEclCCServers;
+        TpEclSchedulers: TpEclSchedulers;
+        TpEspServers: TpEspServers;
+        TpFTSlaves: TpFTSlaves;
+        TpGenesisServers: TpGenesisServers;
+        TpLdapServers: TpLdapServers;
+        TpMySqlServers: TpMySqlServers;
+        TpSashaServers: TpSashaServers;
+        TpSparkThors: TpSparkThors;
+    }
+
+    export interface TpServiceQueryResponse {
+        Exceptions: Exceptions;
+        MemThreshold: int;
+        DiskThreshold: int;
+        CpuThreshold: int;
+        EncapsulatedSystem: boolean;
+        EnableSNMP: boolean;
+        PreflightProcessFilter: string;
+        AcceptLanguage: string;
+        MemThresholdType: string;
+        DiskThresholdType: string;
+        ServiceList: ServiceList;
+    }
+
+    export interface TpSetMachineStatusRequest {
+        MachinePath?: string;
+        StatusValue?: string;
+    }
+
+    export interface TpSetMachineStatusResponse {
+        Exceptions: Exceptions;
+        TpSetMachineStatusResult: boolean;
+    }
+
+    export interface TpSwapNodeRequest {
+        Cluster?: string;
+        OldIP?: string;
+        NewIP?: string;
+    }
+
+    export interface TpSwapNodeResponse {
+        Exceptions: Exceptions;
+        TpSwapNodeResult: boolean;
+    }
+
+    export interface TpTargetClusterQueryRequest {
+        Type?: string;
+        Name?: string;
+        ShowDetails?: boolean;
+    }
+
+    export interface TpTargetCluster {
+        Name: string;
+        Prefix: string;
+        Type: string;
+        TpClusters: TpClusters;
+        TpEclCCServers: TpEclCCServers;
+        TpEclServers: TpEclServers;
+        TpEclAgents: TpEclAgents;
+        TpEclSchedulers: TpEclSchedulers;
+    }
+
+    export interface TpTargetClusters {
+        TpTargetCluster: TpTargetCluster[];
+    }
+
+    export interface TpTargetClusterQueryResponse {
+        Exceptions: Exceptions;
+        ShowDetails: boolean;
+        MemThreshold: int;
+        DiskThreshold: int;
+        CpuThreshold: int;
+        MemThresholdType: string;
+        DiskThresholdType: string;
+        PreflightProcessFilter: string;
+        AcceptLanguage: string;
+        TpTargetClusters: TpTargetClusters;
+    }
+
+    export interface TpThorStatusRequest {
+        Name?: string;
+    }
+
+    export interface TpThorStatusResponse {
+        Exceptions: Exceptions;
+        Name: string;
+        Queue: string;
+        Group: string;
+        ThorMasterIPAddress: string;
+        Port: int;
+        StartTime: string;
+        LogFile: string;
+        Wuid: string;
+        Graph: string;
+        SubGraph: int;
+        SubGraphDuration: int;
+        AutoRefresh: int;
+    }
+
+    export interface TpXMLFileRequest {
+        Name?: string;
+    }
+
+    export interface TpXMLFileResponse {
+        Exceptions: Exceptions;
+        thefile: base64Binary;
+    }
+
+}
+
+export class TopologyServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsTopology", "1.33");
+    }
+
+    Ping(request: Partial<WsTopology.WsTopologyPingRequest>): Promise<WsTopology.WsTopologyPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "WsTopologyPingResponse");
+    }
+
+    SystemLog(request: Partial<WsTopology.SystemLogRequest>): Promise<WsTopology.SystemLogResponse> {
+        return this._connection.send("SystemLog", request, "json", false, undefined, "SystemLogResponse");
+    }
+
+    TpClusterInfo(request: Partial<WsTopology.TpClusterInfoRequest>): Promise<WsTopology.TpClusterInfoResponse> {
+        return this._connection.send("TpClusterInfo", request, "json", false, undefined, "TpClusterInfoResponse");
+    }
+
+    TpClusterQuery(request: Partial<WsTopology.TpClusterQueryRequest>): Promise<WsTopology.TpClusterQueryResponse> {
+        return this._connection.send("TpClusterQuery", request, "json", false, undefined, "TpClusterQueryResponse");
+    }
+
+    TpComponentConfiguration(request: Partial<WsTopology.TpComponentConfigurationRequest>): Promise<WsTopology.TpComponentConfigurationResponse> {
+        return this._connection.send("TpComponentConfiguration", request, "json", false, undefined, "TpComponentConfigurationResponse");
+    }
+
+    TpConfiguredComponents(request: Partial<WsTopology.TpConfiguredComponentsRequest>): Promise<WsTopology.TpConfiguredComponentsResponse> {
+        return this._connection.send("TpConfiguredComponents", request, "json", false, undefined, "TpConfiguredComponentsResponse");
+    }
+
+    TpDropZoneQuery(request: Partial<WsTopology.TpDropZoneQueryRequest>): Promise<WsTopology.TpDropZoneQueryResponse> {
+        return this._connection.send("TpDropZoneQuery", request, "json", false, undefined, "TpDropZoneQueryResponse");
+    }
+
+    TpGetComponentFile(request: Partial<WsTopology.TpGetComponentFileRequest>): Promise<WsTopology.TpGetComponentFileResponse> {
+        return this._connection.send("TpGetComponentFile", request, "json", false, undefined, "TpGetComponentFileResponse");
+    }
+
+    TpGetServicePlugins(request: Partial<WsTopology.TpGetServicePluginsRequest>): Promise<WsTopology.TpGetServicePluginsResponse> {
+        return this._connection.send("TpGetServicePlugins", request, "json", false, undefined, "TpGetServicePluginsResponse");
+    }
+
+    TpGroupQuery(request: Partial<WsTopology.TpGroupQueryRequest>): Promise<WsTopology.TpGroupQueryResponse> {
+        return this._connection.send("TpGroupQuery", request, "json", false, undefined, "TpGroupQueryResponse");
+    }
+
+    TpListLogFiles(request: Partial<WsTopology.TpListLogFilesRequest>): Promise<WsTopology.TpListLogFilesResponse> {
+        return this._connection.send("TpListLogFiles", request, "json", false, undefined, "TpListLogFilesResponse");
+    }
+
+    TpListTargetClusters(request: Partial<WsTopology.TpListTargetClustersRequest>): Promise<WsTopology.TpListTargetClustersResponse> {
+        return this._connection.send("TpListTargetClusters", request, "json", false, undefined, "TpListTargetClustersResponse");
+    }
+
+    TpLogFile(request: Partial<WsTopology.TpLogFileRequest>): Promise<WsTopology.TpLogFileResponse> {
+        return this._connection.send("TpLogFile", request, "json", false, undefined, "TpLogFileResponse");
+    }
+
+    TpLogFileDisplay(request: Partial<WsTopology.TpLogFileRequest>): Promise<WsTopology.TpLogFileResponse> {
+        return this._connection.send("TpLogFileDisplay", request, "json", false, undefined, "TpLogFileResponse");
+    }
+
+    TpLogicalClusterQuery(request: Partial<WsTopology.TpLogicalClusterQueryRequest>): Promise<WsTopology.TpLogicalClusterQueryResponse> {
+        return this._connection.send("TpLogicalClusterQuery", request, "json", false, undefined, "TpLogicalClusterQueryResponse");
+    }
+
+    TpMachineInfo(request: Partial<WsTopology.TpMachineInfoRequest>): Promise<WsTopology.TpMachineInfoResponse> {
+        return this._connection.send("TpMachineInfo", request, "json", false, undefined, "TpMachineInfoResponse");
+    }
+
+    TpMachineQuery(request: Partial<WsTopology.TpMachineQueryRequest>): Promise<WsTopology.TpMachineQueryResponse> {
+        return this._connection.send("TpMachineQuery", request, "json", false, undefined, "TpMachineQueryResponse");
+    }
+
+    TpServiceQuery(request: Partial<WsTopology.TpServiceQueryRequest>): Promise<WsTopology.TpServiceQueryResponse> {
+        return this._connection.send("TpServiceQuery", request, "json", false, undefined, "TpServiceQueryResponse");
+    }
+
+    TpSetMachineStatus(request: Partial<WsTopology.TpSetMachineStatusRequest>): Promise<WsTopology.TpSetMachineStatusResponse> {
+        return this._connection.send("TpSetMachineStatus", request, "json", false, undefined, "TpSetMachineStatusResponse");
+    }
+
+    TpSwapNode(request: Partial<WsTopology.TpSwapNodeRequest>): Promise<WsTopology.TpSwapNodeResponse> {
+        return this._connection.send("TpSwapNode", request, "json", false, undefined, "TpSwapNodeResponse");
+    }
+
+    TpTargetClusterQuery(request: Partial<WsTopology.TpTargetClusterQueryRequest>): Promise<WsTopology.TpTargetClusterQueryResponse> {
+        return this._connection.send("TpTargetClusterQuery", request, "json", false, undefined, "TpTargetClusterQueryResponse");
+    }
+
+    TpThorStatus(request: Partial<WsTopology.TpThorStatusRequest>): Promise<WsTopology.TpThorStatusResponse> {
+        return this._connection.send("TpThorStatus", request, "json", false, undefined, "TpThorStatusResponse");
+    }
+
+    TpXMLFile(request: Partial<WsTopology.TpXMLFileRequest>): Promise<WsTopology.TpXMLFileResponse> {
+        return this._connection.send("TpXMLFile", request, "json", false, undefined, "TpXMLFileResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/WsWorkunits/v2.02/WsWorkunits.ts b/packages/comms/src/services/wsdl/WsWorkunits/v2.02/WsWorkunits.ts
index 5a5c3763d6..22dfe36f9f 100644
--- a/packages/comms/src/services/wsdl/WsWorkunits/v2.02/WsWorkunits.ts
+++ b/packages/comms/src/services/wsdl/WsWorkunits/v2.02/WsWorkunits.ts
@@ -519,6 +519,7 @@ export namespace WsWorkunits {
         StopIfFilesCopied: boolean;
         DfuPublisherWuid: string;
         RemoteStorage: string;
+        KeyCompression: string;
     }
 
     export interface CopiedQueries {
@@ -880,7 +881,7 @@ export namespace WsWorkunits {
         SelectColumnMode: LogSelectColumnMode;
         CustomColumns: CustomColumns;
         ComponentsFilter: ComponentsFilter;
-        Format: LogAccessLogFormat;
+        Format: string;
         sortByTimeDirection: SortDirection;
         LogEventType: LogEventClass;
     }
@@ -1865,6 +1866,7 @@ export namespace WsWorkunits {
         StopIfFilesCopied: boolean;
         DfuPublisherWuid: string;
         RemoteStorage: string;
+        KeyCompression: string;
     }
 
     export interface WUPublishWorkunitResponse {
@@ -2323,6 +2325,7 @@ export namespace WsWorkunits {
         StopIfFilesCopied: boolean;
         DfuPublisherWuid: string;
         RemoteStorage: string;
+        KeyCompression: string;
     }
 
     export interface WUQuerySetCopyQueryResponse {
@@ -2399,6 +2402,7 @@ export namespace WsWorkunits {
         StopIfFilesCopied: boolean;
         DfuPublisherWuid: string;
         RemoteStorage: string;
+        KeyCompression: string;
     }
 
     export interface ImportedQueries {
@@ -2511,6 +2515,7 @@ export namespace WsWorkunits {
         StopIfFilesCopied: boolean;
         DfuPublisherWuid: string;
         RemoteStorage: string;
+        KeyCompression: string;
     }
 
     export interface WURecreateQueryResponse {
diff --git a/packages/comms/src/services/wsdl/ws_codesign/v1.1/ws_codesign.ts b/packages/comms/src/services/wsdl/ws_codesign/v1.1/ws_codesign.ts
index 58dacd909f..c9a8835348 100644
--- a/packages/comms/src/services/wsdl/ws_codesign/v1.1/ws_codesign.ts
+++ b/packages/comms/src/services/wsdl/ws_codesign/v1.1/ws_codesign.ts
@@ -1,13 +1,13 @@
 import { IConnection, IOptions } from "../../../../connection.ts";
 import { Service } from "../../../../espConnection.ts";
 
-type int = number;
+export namespace WsCodesign {
 
-export enum SigningMethodType {
-    Gpg = "Gpg"
-}
+    export type int = number;
 
-export namespace WsCodesign {
+    export enum SigningMethodType {
+        gpg = "gpg"
+    }
 
     export interface ListUserIDsRequest {
 
@@ -30,13 +30,8 @@ export namespace WsCodesign {
     }
 
     export interface ListUserIDsResponse {
-        Exceptions: {
-            Source: string;
-            Exception: Exception[];
-        };
-        UserIDs: {
-            Item: string[];
-        };
+        Exceptions: Exceptions;
+        UserIDs: UserIDs;
     }
 
     export interface ws_codesignPingRequest {
@@ -81,20 +76,20 @@ export class CodesignServiceBase extends Service {
         super(optsConnection, "ws_codesign", "1.1");
     }
 
-    ListUserIDs(request: WsCodesign.ListUserIDsRequest): Promise<WsCodesign.ListUserIDsResponse> {
-        return this._connection.send("ListUserIDs", request);
+    ListUserIDs(request: Partial<WsCodesign.ListUserIDsRequest>): Promise<WsCodesign.ListUserIDsResponse> {
+        return this._connection.send("ListUserIDs", request, "json", false, undefined, "ListUserIDsResponse");
     }
 
-    Ping(request: WsCodesign.ws_codesignPingRequest): Promise<WsCodesign.ws_codesignPingResponse> {
-        return this._connection.send("Ping", request);
+    Ping(request: Partial<WsCodesign.ws_codesignPingRequest>): Promise<WsCodesign.ws_codesignPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "ws_codesignPingResponse");
     }
 
-    Sign(request: WsCodesign.SignRequest): Promise<WsCodesign.SignResponse> {
-        return this._connection.send("Sign", request);
+    Sign(request: Partial<WsCodesign.SignRequest>): Promise<WsCodesign.SignResponse> {
+        return this._connection.send("Sign", request, "json", false, undefined, "SignResponse");
     }
 
-    Verify(request: WsCodesign.VerifyRequest): Promise<WsCodesign.VerifyResponse> {
-        return this._connection.send("Verify", request);
+    Verify(request: Partial<WsCodesign.VerifyRequest>): Promise<WsCodesign.VerifyResponse> {
+        return this._connection.send("Verify", request, "json", false, undefined, "VerifyResponse");
     }
 
 }
diff --git a/packages/comms/src/services/wsdl/ws_elk/v1/ws_elk.ts b/packages/comms/src/services/wsdl/ws_elk/v1/ws_elk.ts
index f7125315cc..b4a3de9171 100644
--- a/packages/comms/src/services/wsdl/ws_elk/v1/ws_elk.ts
+++ b/packages/comms/src/services/wsdl/ws_elk/v1/ws_elk.ts
@@ -36,12 +36,12 @@ export class ElkServiceBase extends Service {
         super(optsConnection, "ws_elk", "1");
     }
 
-    GetConfigDetails(request: WsElk.GetConfigDetailsRequest): Promise<WsElk.GetConfigDetailsResponse> {
-        return this._connection.send("GetConfigDetails", request);
+    GetConfigDetails(request: Partial<WsElk.GetConfigDetailsRequest>): Promise<WsElk.GetConfigDetailsResponse> {
+        return this._connection.send("GetConfigDetails", request, "json", false, undefined, "GetConfigDetailsResponse");
     }
 
-    Ping(request: WsElk.ws_elkPingRequest): Promise<WsElk.ws_elkPingResponse> {
-        return this._connection.send("Ping", request);
+    Ping(request: Partial<WsElk.ws_elkPingRequest>): Promise<WsElk.ws_elkPingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "ws_elkPingResponse");
     }
 
 }
diff --git a/packages/comms/src/services/wsdl/ws_machine/v1.18/ws_machine.ts b/packages/comms/src/services/wsdl/ws_machine/v1.18/ws_machine.ts
new file mode 100644
index 0000000000..3d4af41361
--- /dev/null
+++ b/packages/comms/src/services/wsdl/ws_machine/v1.18/ws_machine.ts
@@ -0,0 +1,497 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsMachine {
+
+    export type int = number;
+    export type long = number;
+    export type unsignedInt = number;
+
+    export enum ThresholdType {
+        THRESHOLD_PERCENTAGE = 0,
+        THRESHOLD_MB = 1
+    }
+
+    export enum TpMachineType {
+        ALLNODES = "ALLNODES",
+        THORMACHINES = "THORMACHINES",
+        HOLEMACHINES = "HOLEMACHINES",
+        ROXIEMACHINES = "ROXIEMACHINES",
+        MACHINES = "MACHINES",
+        AVAILABLEMACHINES = "AVAILABLEMACHINES",
+        DROPZONE = "DROPZONE",
+        STANDBYNNODE = "STANDBYNNODE",
+        THORSPARENODES = "THORSPARENODES",
+        HOLESTANDBYNODES = "HOLESTANDBYNODES"
+    }
+
+    export interface GetComponentStatusRequest {
+
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface StatusReport {
+        StatusID: int;
+        Status: string;
+        StatusDetails: string;
+        Reporter: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        TimeCached: string;
+        URL: string;
+    }
+
+    export interface StatusReports {
+        StatusReport: StatusReport[];
+    }
+
+    export interface ComponentStatus {
+        ComponentTypeID: int;
+        ComponentType: string;
+        EndPoint: string;
+        StatusID: int;
+        Status: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        Reporter: string;
+        StatusReports: StatusReports;
+    }
+
+    export interface ComponentStatusList {
+        ComponentStatus: ComponentStatus[];
+    }
+
+    export interface GetComponentStatusResponse {
+        Exceptions: Exceptions;
+        StatusCode: int;
+        Status: string;
+        ComponentType: string;
+        EndPoint: string;
+        ComponentStatusID: int;
+        ComponentStatus: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        Reporter: string;
+        StatusReport: StatusReport;
+        ComponentStatusList: ComponentStatusList;
+    }
+
+    export interface Component {
+        Type: string;
+        Name: string;
+    }
+
+    export interface Components {
+        Component: Component[];
+    }
+
+    export interface GetComponentUsageRequest {
+        Components?: Components;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface DiskUsage {
+        Name: string;
+        Path: string;
+        Description: string;
+        InUse: long;
+        Available: long;
+        PercentAvailable: int;
+        Exception: string;
+    }
+
+    export interface DiskUsages {
+        DiskUsage: DiskUsage[];
+    }
+
+    export interface MachineUsage {
+        Name: string;
+        NetAddress: string;
+        Description: string;
+        Exception: string;
+        DiskUsages: DiskUsages;
+    }
+
+    export interface MachineUsages {
+        MachineUsage: MachineUsage[];
+    }
+
+    export interface ComponentUsage {
+        Type: string;
+        Name: string;
+        Description: string;
+        Exception: string;
+        MachineUsages: MachineUsages;
+    }
+
+    export interface ComponentUsages {
+        ComponentUsage: ComponentUsage[];
+    }
+
+    export interface GetComponentUsageResponse {
+        Exceptions: Exceptions;
+        ComponentUsages: ComponentUsages;
+        UsageTime: string;
+    }
+
+    export interface Addresses {
+        Item: string[];
+    }
+
+    export interface GetMachineInfoRequest {
+        Addresses?: Addresses;
+        SortBy?: string;
+        ClusterType?: TpMachineType;
+        Cluster?: string;
+        OldIP?: string;
+        Path?: string;
+        AddProcessesToFilter?: string;
+        ApplyProcessFilter?: boolean;
+        GetProcessorInfo?: boolean;
+        GetStorageInfo?: boolean;
+        LocalFileSystemsOnly?: boolean;
+        GetSoftwareInfo?: boolean;
+        MemThreshold?: int;
+        DiskThreshold?: int;
+        CpuThreshold?: int;
+        AutoRefresh?: int;
+        MemThresholdType?: ThresholdType;
+        DiskThresholdType?: ThresholdType;
+        UserName?: string;
+        Password?: string;
+        SecurityString?: string;
+    }
+
+    export interface RequestInfo {
+        Addresses: Addresses;
+        SortBy: string;
+        ClusterType: TpMachineType;
+        Cluster: string;
+        OldIP: string;
+        Path: string;
+        AddProcessesToFilter: string;
+        ApplyProcessFilter: boolean;
+        GetProcessorInfo: boolean;
+        GetStorageInfo: boolean;
+        LocalFileSystemsOnly: boolean;
+        GetSoftwareInfo: boolean;
+        MemThreshold: int;
+        DiskThreshold: int;
+        CpuThreshold: int;
+        AutoRefresh: int;
+        MemThresholdType: ThresholdType;
+        DiskThresholdType: ThresholdType;
+        SecurityString: string;
+        UserName: string;
+        Password: string;
+        EnableSNMP: boolean;
+    }
+
+    export interface Columns {
+        Item: string[];
+    }
+
+    export interface ProcessorInfo {
+        Type: string;
+        Load: int;
+    }
+
+    export interface Processors {
+        ProcessorInfo: ProcessorInfo[];
+    }
+
+    export interface StorageInfo {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface Storage {
+        StorageInfo: StorageInfo[];
+    }
+
+    export interface SWRunInfo {
+        Name: string;
+        Instances: int;
+        State: int;
+    }
+
+    export interface Running {
+        SWRunInfo: SWRunInfo[];
+    }
+
+    export interface PhysicalMemory {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface VirtualMemory {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface ComponentInfo {
+        Condition: int;
+        State: int;
+        UpTime: string;
+    }
+
+    export interface MachineInfoEx {
+        Address: string;
+        ConfigAddress: string;
+        Name: string;
+        ProcessType: string;
+        DisplayType: string;
+        Description: string;
+        AgentVersion: string;
+        Contact: string;
+        Location: string;
+        UpTime: string;
+        ComponentName: string;
+        ComponentPath: string;
+        RoxieState: string;
+        RoxieStateDetails: string;
+        OS: int;
+        ProcessNumber: int;
+        Channels: unsignedInt;
+        Processors: Processors;
+        Storage: Storage;
+        Running: Running;
+        PhysicalMemory: PhysicalMemory;
+        VirtualMemory: VirtualMemory;
+        ComponentInfo: ComponentInfo;
+        Exception: string;
+    }
+
+    export interface Machines {
+        MachineInfoEx: MachineInfoEx[];
+    }
+
+    export interface GetMachineInfoResponse {
+        Exceptions: Exceptions;
+        RequestInfo: RequestInfo;
+        Columns: Columns;
+        Machines: Machines;
+        TimeStamp: string;
+        UserName: string;
+        Password: string;
+        AcceptLanguage: string;
+    }
+
+    export interface GetMachineInfoRequestEx {
+        Addresses: Addresses;
+        ClusterType: TpMachineType;
+    }
+
+    export interface GetMachineInfoResponseEx {
+        Exceptions: Exceptions;
+        AcceptLanguage: string;
+        Machines: Machines;
+    }
+
+    export interface ShowColumns {
+        Item: string[];
+    }
+
+    export interface MetricsRequest {
+        SecurityString?: string;
+        Addresses?: Addresses;
+        ShowColumns?: ShowColumns;
+        AutoRefresh?: int;
+        SelectAllChecked?: boolean;
+        Cluster?: string;
+        AutoUpdate?: boolean;
+    }
+
+    export interface MetricsResponse {
+        Exceptions: Exceptions;
+        FieldInformation: string;
+        Metrics: string;
+        AutoRefresh: int;
+        Cluster: string;
+        SelectAllChecked: boolean;
+        AutoUpdate: boolean;
+        AcceptLanguage: string;
+    }
+
+    export interface NodeGroups {
+        Item: string[];
+    }
+
+    export interface GetNodeGroupUsageRequest {
+        NodeGroups?: NodeGroups;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface NodeGroupUsage {
+        Name: string;
+        Description: string;
+        Exception: string;
+        ComponentUsages: ComponentUsages;
+    }
+
+    export interface NodeGroupUsages {
+        NodeGroupUsage: NodeGroupUsage[];
+    }
+
+    export interface GetNodeGroupUsageResponse {
+        Exceptions: Exceptions;
+        NodeGroupUsages: NodeGroupUsages;
+        UsageTime: string;
+    }
+
+    export interface TargetClusters {
+        Item: string[];
+    }
+
+    export interface GetTargetClusterInfoRequest {
+        TargetClusters?: TargetClusters;
+        AddProcessesToFilter?: string;
+        ApplyProcessFilter?: boolean;
+        GetProcessorInfo?: boolean;
+        GetStorageInfo?: boolean;
+        LocalFileSystemsOnly?: boolean;
+        GetSoftwareInfo?: boolean;
+        MemThreshold?: int;
+        DiskThreshold?: int;
+        CpuThreshold?: int;
+        AutoRefresh?: int;
+        MemThresholdType?: ThresholdType;
+        DiskThresholdType?: ThresholdType;
+    }
+
+    export interface Processes {
+        MachineInfoEx: MachineInfoEx[];
+    }
+
+    export interface TargetClusterInfo {
+        Name: string;
+        Type: string;
+        Processes: Processes;
+    }
+
+    export interface TargetClusterInfoList {
+        TargetClusterInfo: TargetClusterInfo[];
+    }
+
+    export interface GetTargetClusterInfoResponse {
+        Exceptions: Exceptions;
+        Columns: Columns;
+        RequestInfo: RequestInfo;
+        TargetClusterInfoList: TargetClusterInfoList;
+        TimeStamp: string;
+        AcceptLanguage: string;
+    }
+
+    export interface GetTargetClusterUsageRequest {
+        TargetClusters?: TargetClusters;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface TargetClusterUsage {
+        Name: string;
+        Description: string;
+        Exception: string;
+        ComponentUsages: ComponentUsages;
+    }
+
+    export interface TargetClusterUsages {
+        TargetClusterUsage: TargetClusterUsage[];
+    }
+
+    export interface GetTargetClusterUsageResponse {
+        Exceptions: Exceptions;
+        TargetClusterUsages: TargetClusterUsages;
+        UsageTime: string;
+    }
+
+    export interface ws_machinePingRequest {
+
+    }
+
+    export interface ws_machinePingResponse {
+
+    }
+
+    export interface UpdateComponentStatusRequest {
+        Reporter?: string;
+        ComponentStatusList?: ComponentStatusList;
+    }
+
+    export interface UpdateComponentStatusResponse {
+        Exceptions: Exceptions;
+        StatusCode: int;
+        Status: string;
+    }
+
+}
+
+export class MachineServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "ws_machine", "1.18");
+    }
+
+    GetComponentStatus(request: Partial<WsMachine.GetComponentStatusRequest>): Promise<WsMachine.GetComponentStatusResponse> {
+        return this._connection.send("GetComponentStatus", request, "json", false, undefined, "GetComponentStatusResponse");
+    }
+
+    GetComponentUsage(request: Partial<WsMachine.GetComponentUsageRequest>): Promise<WsMachine.GetComponentUsageResponse> {
+        return this._connection.send("GetComponentUsage", request, "json", false, undefined, "GetComponentUsageResponse");
+    }
+
+    GetMachineInfo(request: Partial<WsMachine.GetMachineInfoRequest>): Promise<WsMachine.GetMachineInfoResponse> {
+        return this._connection.send("GetMachineInfo", request, "json", false, undefined, "GetMachineInfoResponse");
+    }
+
+    GetMachineInfoEx(request: Partial<WsMachine.GetMachineInfoRequestEx>): Promise<WsMachine.GetMachineInfoResponseEx> {
+        return this._connection.send("GetMachineInfoEx", request, "json", false, undefined, "GetMachineInfoResponseEx");
+    }
+
+    GetMetrics(request: Partial<WsMachine.MetricsRequest>): Promise<WsMachine.MetricsResponse> {
+        return this._connection.send("GetMetrics", request, "json", false, undefined, "MetricsResponse");
+    }
+
+    GetNodeGroupUsage(request: Partial<WsMachine.GetNodeGroupUsageRequest>): Promise<WsMachine.GetNodeGroupUsageResponse> {
+        return this._connection.send("GetNodeGroupUsage", request, "json", false, undefined, "GetNodeGroupUsageResponse");
+    }
+
+    GetTargetClusterInfo(request: Partial<WsMachine.GetTargetClusterInfoRequest>): Promise<WsMachine.GetTargetClusterInfoResponse> {
+        return this._connection.send("GetTargetClusterInfo", request, "json", false, undefined, "GetTargetClusterInfoResponse");
+    }
+
+    GetTargetClusterUsage(request: Partial<WsMachine.GetTargetClusterUsageRequest>): Promise<WsMachine.GetTargetClusterUsageResponse> {
+        return this._connection.send("GetTargetClusterUsage", request, "json", false, undefined, "GetTargetClusterUsageResponse");
+    }
+
+    Ping(request: Partial<WsMachine.ws_machinePingRequest>): Promise<WsMachine.ws_machinePingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "ws_machinePingResponse");
+    }
+
+    UpdateComponentStatus(request: Partial<WsMachine.UpdateComponentStatusRequest>): Promise<WsMachine.UpdateComponentStatusResponse> {
+        return this._connection.send("UpdateComponentStatus", request, "json", false, undefined, "UpdateComponentStatusResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/ws_machine/v1.19/ws_machine.ts b/packages/comms/src/services/wsdl/ws_machine/v1.19/ws_machine.ts
new file mode 100644
index 0000000000..2294b8e9ff
--- /dev/null
+++ b/packages/comms/src/services/wsdl/ws_machine/v1.19/ws_machine.ts
@@ -0,0 +1,497 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsMachine {
+
+    export type int = number;
+    export type long = number;
+    export type unsignedInt = number;
+
+    export enum ThresholdType {
+        THRESHOLD_PERCENTAGE = 0,
+        THRESHOLD_MB = 1
+    }
+
+    export enum TpMachineType {
+        ALLNODES = "ALLNODES",
+        THORMACHINES = "THORMACHINES",
+        HOLEMACHINES = "HOLEMACHINES",
+        ROXIEMACHINES = "ROXIEMACHINES",
+        MACHINES = "MACHINES",
+        AVAILABLEMACHINES = "AVAILABLEMACHINES",
+        DROPZONE = "DROPZONE",
+        STANDBYNNODE = "STANDBYNNODE",
+        THORSPARENODES = "THORSPARENODES",
+        HOLESTANDBYNODES = "HOLESTANDBYNODES"
+    }
+
+    export interface GetComponentStatusRequest {
+
+    }
+
+    export interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+
+    export interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+
+    export interface StatusReport {
+        StatusID: int;
+        Status: string;
+        StatusDetails: string;
+        Reporter: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        TimeCached: string;
+        URL: string;
+    }
+
+    export interface StatusReports {
+        StatusReport: StatusReport[];
+    }
+
+    export interface ComponentStatus {
+        ComponentTypeID: int;
+        ComponentType: string;
+        EndPoint: string;
+        StatusID: int;
+        Status: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        Reporter: string;
+        StatusReports: StatusReports;
+    }
+
+    export interface ComponentStatusList {
+        ComponentStatus: ComponentStatus[];
+    }
+
+    export interface GetComponentStatusResponse {
+        Exceptions: Exceptions;
+        StatusCode: int;
+        Status: string;
+        ComponentType: string;
+        EndPoint: string;
+        ComponentStatusID: int;
+        ComponentStatus: string;
+        TimeReported: long;
+        TimeReportedStr: string;
+        Reporter: string;
+        StatusReport: StatusReport;
+        ComponentStatusList: ComponentStatusList;
+    }
+
+    export interface Component {
+        Type: string;
+        Name: string;
+    }
+
+    export interface Components {
+        Component: Component[];
+    }
+
+    export interface GetComponentUsageRequest {
+        Components?: Components;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface DiskUsage {
+        Name: string;
+        Path: string;
+        Description: string;
+        InUse: long;
+        Available: long;
+        PercentAvailable: int;
+        Exception: string;
+    }
+
+    export interface DiskUsages {
+        DiskUsage: DiskUsage[];
+    }
+
+    export interface MachineUsage {
+        Name: string;
+        NetAddress: string;
+        Description: string;
+        Exception: string;
+        DiskUsages: DiskUsages;
+    }
+
+    export interface MachineUsages {
+        MachineUsage: MachineUsage[];
+    }
+
+    export interface ComponentUsage {
+        Type: string;
+        Name: string;
+        Description: string;
+        Exception: string;
+        MachineUsages: MachineUsages;
+    }
+
+    export interface ComponentUsages {
+        ComponentUsage: ComponentUsage[];
+    }
+
+    export interface GetComponentUsageResponse {
+        Exceptions: Exceptions;
+        ComponentUsages: ComponentUsages;
+        UsageTime: string;
+    }
+
+    export interface Addresses {
+        Item: string[];
+    }
+
+    export interface GetMachineInfoRequest {
+        Addresses?: Addresses;
+        SortBy?: string;
+        ClusterType?: TpMachineType;
+        Cluster?: string;
+        OldIP?: string;
+        Path?: string;
+        AddProcessesToFilter?: string;
+        ApplyProcessFilter?: boolean;
+        GetProcessorInfo?: boolean;
+        GetStorageInfo?: boolean;
+        LocalFileSystemsOnly?: boolean;
+        GetSoftwareInfo?: boolean;
+        MemThreshold?: int;
+        DiskThreshold?: int;
+        CpuThreshold?: int;
+        AutoRefresh?: int;
+        MemThresholdType?: ThresholdType;
+        DiskThresholdType?: ThresholdType;
+        UserName?: string;
+        Password?: string;
+        SecurityString?: string;
+    }
+
+    export interface RequestInfo {
+        Addresses: Addresses;
+        SortBy: string;
+        ClusterType: TpMachineType;
+        Cluster: string;
+        OldIP: string;
+        Path: string;
+        AddProcessesToFilter: string;
+        ApplyProcessFilter: boolean;
+        GetProcessorInfo: boolean;
+        GetStorageInfo: boolean;
+        LocalFileSystemsOnly: boolean;
+        GetSoftwareInfo: boolean;
+        MemThreshold: int;
+        DiskThreshold: int;
+        CpuThreshold: int;
+        AutoRefresh: int;
+        MemThresholdType: ThresholdType;
+        DiskThresholdType: ThresholdType;
+        SecurityString: string;
+        UserName: string;
+        Password: string;
+        EnableSNMP: boolean;
+    }
+
+    export interface Columns {
+        Item: string[];
+    }
+
+    export interface ProcessorInfo {
+        Type: string;
+        Load: int;
+    }
+
+    export interface Processors {
+        ProcessorInfo: ProcessorInfo[];
+    }
+
+    export interface StorageInfo {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface Storage {
+        StorageInfo: StorageInfo[];
+    }
+
+    export interface SWRunInfo {
+        Name: string;
+        Instances: int;
+        State: int;
+    }
+
+    export interface Running {
+        SWRunInfo: SWRunInfo[];
+    }
+
+    export interface PhysicalMemory {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface VirtualMemory {
+        Description: string;
+        Type: string;
+        Available: long;
+        PercentAvail: int;
+        Total: long;
+        Failures: int;
+    }
+
+    export interface ComponentInfo {
+        Condition: int;
+        State: int;
+        UpTime: string;
+    }
+
+    export interface MachineInfoEx {
+        Address: string;
+        ConfigAddress: string;
+        Name: string;
+        ProcessType: string;
+        DisplayType: string;
+        Description: string;
+        AgentVersion: string;
+        Contact: string;
+        Location: string;
+        UpTime: string;
+        ComponentName: string;
+        ComponentPath: string;
+        RoxieState: string;
+        RoxieStateDetails: string;
+        OS: int;
+        ProcessNumber: int;
+        Channels: unsignedInt;
+        Processors: Processors;
+        Storage: Storage;
+        Running: Running;
+        PhysicalMemory: PhysicalMemory;
+        VirtualMemory: VirtualMemory;
+        ComponentInfo: ComponentInfo;
+        Exception: string;
+    }
+
+    export interface Machines {
+        MachineInfoEx: MachineInfoEx[];
+    }
+
+    export interface GetMachineInfoResponse {
+        Exceptions: Exceptions;
+        RequestInfo: RequestInfo;
+        Columns: Columns;
+        Machines: Machines;
+        TimeStamp: string;
+        UserName: string;
+        Password: string;
+        AcceptLanguage: string;
+    }
+
+    export interface GetMachineInfoRequestEx {
+        Addresses: Addresses;
+        ClusterType: TpMachineType;
+    }
+
+    export interface GetMachineInfoResponseEx {
+        Exceptions: Exceptions;
+        AcceptLanguage: string;
+        Machines: Machines;
+    }
+
+    export interface ShowColumns {
+        Item: string[];
+    }
+
+    export interface MetricsRequest {
+        SecurityString?: string;
+        Addresses?: Addresses;
+        ShowColumns?: ShowColumns;
+        AutoRefresh?: int;
+        SelectAllChecked?: boolean;
+        Cluster?: string;
+        AutoUpdate?: boolean;
+    }
+
+    export interface MetricsResponse {
+        Exceptions: Exceptions;
+        FieldInformation: string;
+        Metrics: string;
+        AutoRefresh: int;
+        Cluster: string;
+        SelectAllChecked: boolean;
+        AutoUpdate: boolean;
+        AcceptLanguage: string;
+    }
+
+    export interface NodeGroups {
+        Item: string[];
+    }
+
+    export interface GetNodeGroupUsageRequest {
+        NodeGroups?: NodeGroups;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface NodeGroupUsage {
+        Name: string;
+        Description: string;
+        Exception: string;
+        ComponentUsages: ComponentUsages;
+    }
+
+    export interface NodeGroupUsages {
+        NodeGroupUsage: NodeGroupUsage[];
+    }
+
+    export interface GetNodeGroupUsageResponse {
+        Exceptions: Exceptions;
+        NodeGroupUsages: NodeGroupUsages;
+        UsageTime: string;
+    }
+
+    export interface TargetClusters {
+        Item: string[];
+    }
+
+    export interface GetTargetClusterInfoRequest {
+        TargetClusters?: TargetClusters;
+        AddProcessesToFilter?: string;
+        ApplyProcessFilter?: boolean;
+        GetProcessorInfo?: boolean;
+        GetStorageInfo?: boolean;
+        LocalFileSystemsOnly?: boolean;
+        GetSoftwareInfo?: boolean;
+        MemThreshold?: int;
+        DiskThreshold?: int;
+        CpuThreshold?: int;
+        AutoRefresh?: int;
+        MemThresholdType?: ThresholdType;
+        DiskThresholdType?: ThresholdType;
+    }
+
+    export interface Processes {
+        MachineInfoEx: MachineInfoEx[];
+    }
+
+    export interface TargetClusterInfo {
+        Name: string;
+        Type: string;
+        Processes: Processes;
+    }
+
+    export interface TargetClusterInfoList {
+        TargetClusterInfo: TargetClusterInfo[];
+    }
+
+    export interface GetTargetClusterInfoResponse {
+        Exceptions: Exceptions;
+        Columns: Columns;
+        RequestInfo: RequestInfo;
+        TargetClusterInfoList: TargetClusterInfoList;
+        TimeStamp: string;
+        AcceptLanguage: string;
+    }
+
+    export interface GetTargetClusterUsageRequest {
+        TargetClusters?: TargetClusters;
+        BypassCachedResult?: boolean;
+    }
+
+    export interface TargetClusterUsage {
+        Name: string;
+        Description: string;
+        Exception: string;
+        ComponentUsages: ComponentUsages;
+    }
+
+    export interface TargetClusterUsages {
+        TargetClusterUsage: TargetClusterUsage[];
+    }
+
+    export interface GetTargetClusterUsageResponse {
+        Exceptions: Exceptions;
+        TargetClusterUsages: TargetClusterUsages;
+        UsageTime: string;
+    }
+
+    export interface ws_machinePingRequest {
+
+    }
+
+    export interface ws_machinePingResponse {
+
+    }
+
+    export interface UpdateComponentStatusRequest {
+        Reporter?: string;
+        ComponentStatusList?: ComponentStatusList;
+    }
+
+    export interface UpdateComponentStatusResponse {
+        Exceptions: Exceptions;
+        StatusCode: int;
+        Status: string;
+    }
+
+}
+
+export class MachineServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "ws_machine", "1.19");
+    }
+
+    GetComponentStatus(request: Partial<WsMachine.GetComponentStatusRequest>): Promise<WsMachine.GetComponentStatusResponse> {
+        return this._connection.send("GetComponentStatus", request, "json", false, undefined, "GetComponentStatusResponse");
+    }
+
+    GetComponentUsage(request: Partial<WsMachine.GetComponentUsageRequest>): Promise<WsMachine.GetComponentUsageResponse> {
+        return this._connection.send("GetComponentUsage", request, "json", false, undefined, "GetComponentUsageResponse");
+    }
+
+    GetMachineInfo(request: Partial<WsMachine.GetMachineInfoRequest>): Promise<WsMachine.GetMachineInfoResponse> {
+        return this._connection.send("GetMachineInfo", request, "json", false, undefined, "GetMachineInfoResponse");
+    }
+
+    GetMachineInfoEx(request: Partial<WsMachine.GetMachineInfoRequestEx>): Promise<WsMachine.GetMachineInfoResponseEx> {
+        return this._connection.send("GetMachineInfoEx", request, "json", false, undefined, "GetMachineInfoResponseEx");
+    }
+
+    GetMetrics(request: Partial<WsMachine.MetricsRequest>): Promise<WsMachine.MetricsResponse> {
+        return this._connection.send("GetMetrics", request, "json", false, undefined, "MetricsResponse");
+    }
+
+    GetNodeGroupUsage(request: Partial<WsMachine.GetNodeGroupUsageRequest>): Promise<WsMachine.GetNodeGroupUsageResponse> {
+        return this._connection.send("GetNodeGroupUsage", request, "json", false, undefined, "GetNodeGroupUsageResponse");
+    }
+
+    GetTargetClusterInfo(request: Partial<WsMachine.GetTargetClusterInfoRequest>): Promise<WsMachine.GetTargetClusterInfoResponse> {
+        return this._connection.send("GetTargetClusterInfo", request, "json", false, undefined, "GetTargetClusterInfoResponse");
+    }
+
+    GetTargetClusterUsage(request: Partial<WsMachine.GetTargetClusterUsageRequest>): Promise<WsMachine.GetTargetClusterUsageResponse> {
+        return this._connection.send("GetTargetClusterUsage", request, "json", false, undefined, "GetTargetClusterUsageResponse");
+    }
+
+    Ping(request: Partial<WsMachine.ws_machinePingRequest>): Promise<WsMachine.ws_machinePingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "ws_machinePingResponse");
+    }
+
+    UpdateComponentStatus(request: Partial<WsMachine.UpdateComponentStatusRequest>): Promise<WsMachine.UpdateComponentStatusResponse> {
+        return this._connection.send("UpdateComponentStatus", request, "json", false, undefined, "UpdateComponentStatusResponse");
+    }
+
+}
diff --git a/packages/comms/src/services/wsdl/wsstore/v1.02/wsstore.ts b/packages/comms/src/services/wsdl/wsstore/v1.02/wsstore.ts
index 5764c2ee99..61429b1782 100644
--- a/packages/comms/src/services/wsdl/wsstore/v1.02/wsstore.ts
+++ b/packages/comms/src/services/wsdl/wsstore/v1.02/wsstore.ts
@@ -1,10 +1,10 @@
 import { IConnection, IOptions } from "../../../../connection.ts";
 import { Service } from "../../../../espConnection.ts";
 
-type int = number;
-
 export namespace Wsstore {
 
+    export type int = number;
+
     export interface CreateStoreRequest {
         Name?: string;
         Type?: string;
@@ -25,10 +25,7 @@ export namespace Wsstore {
     }
 
     export interface CreateStoreResponse {
-        Exceptions: {
-            Source: string;
-            Exception: Exception[];
-        };
+        Exceptions: Exceptions;
         Name: string;
         Type: string;
         Description: string;
@@ -91,9 +88,7 @@ export namespace Wsstore {
     export interface FetchAllResponse {
         Exceptions: Exceptions;
         Namespace: string;
-        Pairs: {
-            Pair: Pair[];
-        };
+        Pairs: Pairs;
     }
 
     export interface FetchKeyMDRequest {
@@ -125,9 +120,7 @@ export namespace Wsstore {
         Exceptions: Exceptions;
         StoreName: string;
         Namespace: string;
-        KeySet: {
-            Key: string[];
-        };
+        KeySet: KeySet;
     }
 
     export interface ListNamespacesRequest {
@@ -142,9 +135,7 @@ export namespace Wsstore {
     export interface ListNamespacesResponse {
         Exceptions: Exceptions;
         StoreName: string;
-        Namespaces: {
-            Namespace: string[];
-        };
+        Namespaces: Namespaces;
     }
 
     export interface ListStoresRequest {
@@ -169,9 +160,7 @@ export namespace Wsstore {
 
     export interface ListStoresResponse {
         Exceptions: Exceptions;
-        Stores: {
-            Store: Store[];
-        };
+        Stores: Stores;
     }
 
     export interface wsstorePingRequest {
@@ -203,48 +192,48 @@ export class storeServiceBase extends Service {
         super(optsConnection, "wsstore", "1.02");
     }
 
-    CreateStore(request: Wsstore.CreateStoreRequest): Promise<Wsstore.CreateStoreResponse> {
-        return this._connection.send("CreateStore", request);
+    CreateStore(request: Partial<Wsstore.CreateStoreRequest>): Promise<Wsstore.CreateStoreResponse> {
+        return this._connection.send("CreateStore", request, "json", false, undefined, "CreateStoreResponse");
     }
 
-    Delete(request: Wsstore.DeleteRequest): Promise<Wsstore.DeleteResponse> {
-        return this._connection.send("Delete", request);
+    Delete(request: Partial<Wsstore.DeleteRequest>): Promise<Wsstore.DeleteResponse> {
+        return this._connection.send("Delete", request, "json", false, undefined, "DeleteResponse");
     }
 
-    DeleteNamespace(request: Wsstore.DeleteNamespaceRequest): Promise<Wsstore.DeleteNamespaceResponse> {
-        return this._connection.send("DeleteNamespace", request);
+    DeleteNamespace(request: Partial<Wsstore.DeleteNamespaceRequest>): Promise<Wsstore.DeleteNamespaceResponse> {
+        return this._connection.send("DeleteNamespace", request, "json", false, undefined, "DeleteNamespaceResponse");
     }
 
-    Fetch(request: Wsstore.FetchRequest): Promise<Wsstore.FetchResponse> {
-        return this._connection.send("Fetch", request);
+    Fetch(request: Partial<Wsstore.FetchRequest>): Promise<Wsstore.FetchResponse> {
+        return this._connection.send("Fetch", request, "json", false, undefined, "FetchResponse");
     }
 
-    FetchAll(request: Wsstore.FetchAllRequest): Promise<Wsstore.FetchAllResponse> {
-        return this._connection.send("FetchAll", request);
+    FetchAll(request: Partial<Wsstore.FetchAllRequest>): Promise<Wsstore.FetchAllResponse> {
+        return this._connection.send("FetchAll", request, "json", false, undefined, "FetchAllResponse");
     }
 
-    FetchKeyMetadata(request: Wsstore.FetchKeyMDRequest): Promise<Wsstore.FetchKeyMDResponse> {
-        return this._connection.send("FetchKeyMetadata", request);
+    FetchKeyMetadata(request: Partial<Wsstore.FetchKeyMDRequest>): Promise<Wsstore.FetchKeyMDResponse> {
+        return this._connection.send("FetchKeyMetadata", request, "json", false, undefined, "FetchKeyMDResponse");
     }
 
-    ListKeys(request: Wsstore.ListKeysRequest): Promise<Wsstore.ListKeysResponse> {
-        return this._connection.send("ListKeys", request);
+    ListKeys(request: Partial<Wsstore.ListKeysRequest>): Promise<Wsstore.ListKeysResponse> {
+        return this._connection.send("ListKeys", request, "json", false, undefined, "ListKeysResponse");
     }
 
-    ListNamespaces(request: Wsstore.ListNamespacesRequest): Promise<Wsstore.ListNamespacesResponse> {
-        return this._connection.send("ListNamespaces", request);
+    ListNamespaces(request: Partial<Wsstore.ListNamespacesRequest>): Promise<Wsstore.ListNamespacesResponse> {
+        return this._connection.send("ListNamespaces", request, "json", false, undefined, "ListNamespacesResponse");
     }
 
-    ListStores(request: Wsstore.ListStoresRequest): Promise<Wsstore.ListStoresResponse> {
-        return this._connection.send("ListStores", request);
+    ListStores(request: Partial<Wsstore.ListStoresRequest>): Promise<Wsstore.ListStoresResponse> {
+        return this._connection.send("ListStores", request, "json", false, undefined, "ListStoresResponse");
     }
 
-    Ping(request: Wsstore.wsstorePingRequest): Promise<Wsstore.wsstorePingResponse> {
-        return this._connection.send("Ping", request);
+    Ping(request: Partial<Wsstore.wsstorePingRequest>): Promise<Wsstore.wsstorePingResponse> {
+        return this._connection.send("Ping", request, "json", false, undefined, "wsstorePingResponse");
     }
 
-    Set(request: Wsstore.SetRequest): Promise<Wsstore.SetResponse> {
-        return this._connection.send("Set", request);
+    Set(request: Partial<Wsstore.SetRequest>): Promise<Wsstore.SetResponse> {
+        return this._connection.send("Set", request, "json", false, undefined, "SetResponse");
     }
 
 }