diff --git a/packages/comms/src/services/fileSpray.ts b/packages/comms/src/services/fileSpray.ts
index 937a16a1bc..ff2478cc71 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.27/FileSpray.ts";
+import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.29/FileSpray.ts";
 
 export {
     FileSpray
@@ -20,31 +20,6 @@ export enum FileSprayStates {
     notfound = 999
 }
 
-// defined in https://github.com/hpcc-systems/HPCC-Platform/blob/master/dali/dfu/dfuwu.cpp#L102-L121
-export enum DFUWUTypes {
-    Copy = "copy",
-    Remove = "remove",
-    Move = "move",
-    Rename = "rename",
-    Replicate = "replicate",
-    Import = "import",
-    Export = "export",
-    /*
-     * These seem to not be valid with respect to filtering DFU WUs,
-     * but leaving them here because they exist in the dfuwu.cpp struct
-     *
-     * Add = "add",
-     * Transfer = "transfer",
-     * Savemap = "savemap",
-     * Addgroup = "addgroup",
-     * Server = "server",
-     */
-    Monitor = "monitor",
-    Copymerge = "copymerge",
-    Supercopy = "supercopy",
-    Publish = "publish",
-}
-
 export interface UpdateDFUWorkunitEx extends UpdateDFUWorkunitMinusWU {
     wu?: Partial<UpdateDFUWorkunitWU>
 }
diff --git a/packages/comms/src/services/wsdl/FileSpray/v1.29/FileSpray.ts b/packages/comms/src/services/wsdl/FileSpray/v1.29/FileSpray.ts
new file mode 100644
index 0000000000..50d9281d18
--- /dev/null
+++ b/packages/comms/src/services/wsdl/FileSpray/v1.29/FileSpray.ts
@@ -0,0 +1,946 @@
+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 enum DFUCommand {
+        copy = "copy",
+        remove = "remove",
+        move = "move",
+        rename = "rename",
+        replicate = "replicate",
+        import = "import",
+        export = "export",
+        monitor = "monitor",
+        copymerge = "copymerge",
+        supercopy = "supercopy",
+        publish = "publish"
+    }
+
+    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;
+        DestNumParts?: int;
+    }
+
+    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;
+        Command?: DFUCommand;
+        Archived?: boolean;
+        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;
+        Command?: DFUCommand;
+        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.29");
+    }
+
+    AbortDFUWorkunit(request: FileSpray.AbortDFUWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.AbortDFUWorkunitResponse> {
+        return this._connection.send("AbortDFUWorkunit", request, "json", false, abortSignal, "AbortDFUWorkunitResponse");
+    }
+
+    Copy(request: FileSpray.Copy, abortSignal?: AbortSignal): Promise<FileSpray.CopyResponse> {
+        return this._connection.send("Copy", request, "json", false, abortSignal, "CopyResponse");
+    }
+
+    CreateDFUPublisherWorkunit(request: FileSpray.CreateDFUPublisherWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.CreateDFUPublisherWorkunitResponse> {
+        return this._connection.send("CreateDFUPublisherWorkunit", request, "json", false, abortSignal, "CreateDFUPublisherWorkunitResponse");
+    }
+
+    CreateDFUWorkunit(request: FileSpray.CreateDFUWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.CreateDFUWorkunitResponse> {
+        return this._connection.send("CreateDFUWorkunit", request, "json", false, abortSignal, "CreateDFUWorkunitResponse");
+    }
+
+    DFUWUFile(request: FileSpray.DFUWUFileRequest, abortSignal?: AbortSignal): Promise<FileSpray.DFUWUFileResponse> {
+        return this._connection.send("DFUWUFile", request, "json", false, abortSignal, "DFUWUFileResponse");
+    }
+
+    DFUWUSearch(request: FileSpray.DFUWUSearchRequest, abortSignal?: AbortSignal): Promise<FileSpray.DFUWUSearchResponse> {
+        return this._connection.send("DFUWUSearch", request, "json", false, abortSignal, "DFUWUSearchResponse");
+    }
+
+    DFUWorkunitsAction(request: FileSpray.DFUWorkunitsActionRequest, abortSignal?: AbortSignal): Promise<FileSpray.DFUWorkunitsActionResponse> {
+        return this._connection.send("DFUWorkunitsAction", request, "json", false, abortSignal, "DFUWorkunitsActionResponse");
+    }
+
+    DeleteDFUWorkunit(request: FileSpray.DeleteDFUWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.DeleteDFUWorkunitResponse> {
+        return this._connection.send("DeleteDFUWorkunit", request, "json", false, abortSignal, "DeleteDFUWorkunitResponse");
+    }
+
+    DeleteDFUWorkunits(request: FileSpray.DeleteDFUWorkunits, abortSignal?: AbortSignal): Promise<FileSpray.DeleteDFUWorkunitsResponse> {
+        return this._connection.send("DeleteDFUWorkunits", request, "json", false, abortSignal, "DeleteDFUWorkunitsResponse");
+    }
+
+    DeleteDropZoneFiles(request: FileSpray.DeleteDropZoneFilesRequest, abortSignal?: AbortSignal): Promise<FileSpray.DFUWorkunitsActionResponse> {
+        return this._connection.send("DeleteDropZoneFiles", request, "json", false, abortSignal, "DFUWorkunitsActionResponse");
+    }
+
+    Despray(request: FileSpray.Despray, abortSignal?: AbortSignal): Promise<FileSpray.DesprayResponse> {
+        return this._connection.send("Despray", request, "json", false, abortSignal, "DesprayResponse");
+    }
+
+    DfuMonitor(request: FileSpray.DfuMonitorRequest, abortSignal?: AbortSignal): Promise<FileSpray.DfuMonitorResponse> {
+        return this._connection.send("DfuMonitor", request, "json", false, abortSignal, "DfuMonitorResponse");
+    }
+
+    DropZoneFileSearch(request: FileSpray.DropZoneFileSearchRequest, abortSignal?: AbortSignal): Promise<FileSpray.DropZoneFileSearchResponse> {
+        return this._connection.send("DropZoneFileSearch", request, "json", false, abortSignal, "DropZoneFileSearchResponse");
+    }
+
+    DropZoneFiles(request: FileSpray.DropZoneFilesRequest, abortSignal?: AbortSignal): Promise<FileSpray.DropZoneFilesResponse> {
+        return this._connection.send("DropZoneFiles", request, "json", false, abortSignal, "DropZoneFilesResponse");
+    }
+
+    EchoDateTime(request: FileSpray.EchoDateTime, abortSignal?: AbortSignal): Promise<FileSpray.EchoDateTimeResponse> {
+        return this._connection.send("EchoDateTime", request, "json", false, abortSignal, "EchoDateTimeResponse");
+    }
+
+    FileList(request: FileSpray.FileListRequest, abortSignal?: AbortSignal): Promise<FileSpray.FileListResponse> {
+        return this._connection.send("FileList", request, "json", false, abortSignal, "FileListResponse");
+    }
+
+    GetDFUExceptions(request: FileSpray.GetDFUExceptions, abortSignal?: AbortSignal): Promise<FileSpray.GetDFUExceptionsResponse> {
+        return this._connection.send("GetDFUExceptions", request, "json", false, abortSignal, "GetDFUExceptionsResponse");
+    }
+
+    GetDFUProgress(request: FileSpray.ProgressRequest, abortSignal?: AbortSignal): Promise<FileSpray.ProgressResponse> {
+        return this._connection.send("GetDFUProgress", request, "json", false, abortSignal, "ProgressResponse");
+    }
+
+    GetDFUServerQueues(request: FileSpray.GetDFUServerQueuesRequest, abortSignal?: AbortSignal): Promise<FileSpray.GetDFUServerQueuesResponse> {
+        return this._connection.send("GetDFUServerQueues", request, "json", false, abortSignal, "GetDFUServerQueuesResponse");
+    }
+
+    GetDFUWorkunit(request: FileSpray.GetDFUWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.GetDFUWorkunitResponse> {
+        return this._connection.send("GetDFUWorkunit", request, "json", false, abortSignal, "GetDFUWorkunitResponse");
+    }
+
+    GetDFUWorkunits(request: FileSpray.GetDFUWorkunits, abortSignal?: AbortSignal): Promise<FileSpray.GetDFUWorkunitsResponse> {
+        return this._connection.send("GetDFUWorkunits", request, "json", false, abortSignal, "GetDFUWorkunitsResponse");
+    }
+
+    GetRemoteTargets(request: FileSpray.GetRemoteTargetsRequest, abortSignal?: AbortSignal): Promise<FileSpray.GetRemoteTargetsResponse> {
+        return this._connection.send("GetRemoteTargets", request, "json", false, abortSignal, "GetRemoteTargetsResponse");
+    }
+
+    GetSprayTargets(request: FileSpray.GetSprayTargetsRequest, abortSignal?: AbortSignal): Promise<FileSpray.GetSprayTargetsResponse> {
+        return this._connection.send("GetSprayTargets", request, "json", false, abortSignal, "GetSprayTargetsResponse");
+    }
+
+    OpenSave(request: FileSpray.OpenSaveRequest, abortSignal?: AbortSignal): Promise<FileSpray.OpenSaveResponse> {
+        return this._connection.send("OpenSave", request, "json", false, abortSignal, "OpenSaveResponse");
+    }
+
+    Ping(request: FileSpray.FileSprayPingRequest, abortSignal?: AbortSignal): Promise<FileSpray.FileSprayPingResponse> {
+        return this._connection.send("Ping", request, "json", false, abortSignal, "FileSprayPingResponse");
+    }
+
+    Rename(request: FileSpray.Rename, abortSignal?: AbortSignal): Promise<FileSpray.RenameResponse> {
+        return this._connection.send("Rename", request, "json", false, abortSignal, "RenameResponse");
+    }
+
+    Replicate(request: FileSpray.Replicate, abortSignal?: AbortSignal): Promise<FileSpray.ReplicateResponse> {
+        return this._connection.send("Replicate", request, "json", false, abortSignal, "ReplicateResponse");
+    }
+
+    ShowResult(request: FileSpray.ShowResultRequest, abortSignal?: AbortSignal): Promise<FileSpray.ShowResultResponse> {
+        return this._connection.send("ShowResult", request, "json", false, abortSignal, "ShowResultResponse");
+    }
+
+    SprayFixed(request: FileSpray.SprayFixed, abortSignal?: AbortSignal): Promise<FileSpray.SprayFixedResponse> {
+        return this._connection.send("SprayFixed", request, "json", false, abortSignal, "SprayFixedResponse");
+    }
+
+    SprayVariable(request: FileSpray.SprayVariable, abortSignal?: AbortSignal): Promise<FileSpray.SprayResponse> {
+        return this._connection.send("SprayVariable", request, "json", false, abortSignal, "SprayResponse");
+    }
+
+    SubmitDFUWorkunit(request: FileSpray.SubmitDFUWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.SubmitDFUWorkunitResponse> {
+        return this._connection.send("SubmitDFUWorkunit", request, "json", false, abortSignal, "SubmitDFUWorkunitResponse");
+    }
+
+    UpdateDFUWorkunit(request: FileSpray.UpdateDFUWorkunit, abortSignal?: AbortSignal): Promise<FileSpray.UpdateDFUWorkunitResponse> {
+        return this._connection.send("UpdateDFUWorkunit", request, "json", false, abortSignal, "UpdateDFUWorkunitResponse");
+    }
+
+}