@hpcc-js/comms 3.15.5 → 3.15.7

package/src/services/wsdl/WsESDLConfig/v1.5/WsESDLConfig.ts

@@ -0,0 +1,366 @@
+import { IConnection, IOptions } from "../../../../connection.ts";
+import { Service } from "../../../../espConnection.ts";
+
+export namespace WsESDLConfig {
+
+    export type int = number;
+
+    export interface ConfigureESDLBindingLogTransformRequest {
+        EsdlBindingId?: string;
+        LogTransformName?: string;
+        Overwrite?: boolean;
+        Encoded?: boolean;
+        Config?: string;
+        EchoBinding?: 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 Attribute {
+        Name?: string;
+        Value?: string;
+    }
+
+    export interface Attributes {
+        Attribute?: Attribute[];
+    }
+
+    export interface Method {
+        Name?: string;
+        Attributes?: Attributes;
+        Elements?: string;
+        XML?: string;
+    }
+
+    export interface Methods {
+        Method?: Method[];
+    }
+
+    export interface Service {
+        Methods?: Methods;
+        Name?: string;
+    }
+
+    export interface Services {
+        Service?: Service[];
+    }
+
+    export interface History {
+        PublishBy?: string;
+        CreatedTime?: string;
+        LastEditBy?: string;
+        LastEditTime?: string;
+    }
+
+    export interface Definition {
+        Name?: string;
+        Seq?: int;
+        Id?: string;
+        Interface?: string;
+        Services?: Services;
+        History?: History;
+    }
+
+    export interface Configuration {
+        Methods?: Methods;
+    }
+
+    export interface ESDLBinding {
+        Definition?: Definition;
+        Configuration?: Configuration;
+        History?: History;
+    }
+
+    export interface ConfigureESDLBindingLogTransformResponse {
+        Exceptions?: Exceptions;
+        EspProcName?: string;
+        EspBindingName?: string;
+        EsdlDefinitionID?: string;
+        EsdlServiceName?: string;
+        status?: status;
+        ESDLBinding?: ESDLBinding;
+    }
+
+    export interface MethodStructure {
+        Name?: string;
+        Attributes?: Attributes;
+        Elements?: string;
+        XML?: string;
+    }
+
+    export interface ConfigureESDLBindingMethodRequest {
+        EsdlBindingId?: string;
+        MethodName?: string;
+        Overwrite?: boolean;
+        Config?: string;
+        MethodStructure?: MethodStructure;
+        EchoBinding?: boolean;
+    }
+
+    export interface ConfigureESDLBindingMethodResponse {
+        Exceptions?: Exceptions;
+        EspProcName?: string;
+        EspBindingName?: string;
+        EsdlDefinitionID?: string;
+        EsdlServiceName?: string;
+        status?: status;
+        ESDLBinding?: ESDLBinding;
+    }
+
+    export interface DeleteESDLBindingRequest {
+        Id?: string;
+        EspProcess?: string;
+        EspBinding?: string;
+    }
+
+    export interface DeleteESDLRegistryEntryResponse {
+        Exceptions?: Exceptions;
+        DeletedTree?: string;
+        status?: status;
+    }
+
+    export interface DeleteESDLDefinitionRequest {
+        Id?: string;
+        Name?: string;
+        Version?: string;
+    }
+
+    export interface EchoRequest {
+        Request?: string;
+    }
+
+    export interface EchoResponse {
+        Response?: string;
+    }
+
+    export interface GetESDLBindingRequest {
+        EsdlBindingId?: string;
+        IncludeInterfaceDefinition?: boolean;
+        ReportMethodsAvailable?: boolean;
+    }
+
+    export interface GetESDLBindingResponse {
+        Exceptions?: Exceptions;
+        ServiceName?: string;
+        EspProcName?: string;
+        BindingName?: string;
+        EspPort?: string;
+        ConfigXML?: string;
+        ESDLBinding?: ESDLBinding;
+        status?: status;
+    }
+
+    export interface GetESDLDefinitionRequest {
+        Id?: string;
+        Name?: string;
+        Seq?: int;
+        ServiceName?: string;
+        ReportMethodsAvailable?: boolean;
+    }
+
+    export interface GetESDLDefinitionResponse {
+        Exceptions?: Exceptions;
+        status?: status;
+        Definition?: Definition;
+    }
+
+    export interface ListDESDLEspBindingsReq {
+        IncludeESDLBindingInfo?: boolean;
+    }
+
+    export interface TpBindingEx {
+        TpBindingEx?: TpBindingEx[];
+    }
+
+    export interface ESPServer {
+        Name?: string;
+        Description?: string;
+        Build?: string;
+        Type?: string;
+        Path?: string;
+        LogDirectory?: string;
+        TpBindingEx?: TpBindingEx;
+    }
+
+    export interface ESPServers {
+        ESPServer?: ESPServer[];
+    }
+
+    export interface ListDESDLEspBindingsResp {
+        ESPServers?: ESPServers;
+    }
+
+    export interface ListESDLBindingsRequest {
+
+    }
+
+    export interface Binding {
+        Id?: string;
+        EspProcess?: string;
+        Port?: int;
+        History?: History;
+    }
+
+    export interface Bindings {
+        Binding?: Binding[];
+    }
+
+    export interface Port {
+        Value?: int;
+        Bindings?: Bindings;
+    }
+
+    export interface Ports {
+        Port?: Port[];
+    }
+
+    export interface EspProcess {
+        Name?: string;
+        Ports?: Ports;
+    }
+
+    export interface EspProcesses {
+        EspProcess?: EspProcess[];
+    }
+
+    export interface ListESDLBindingsResponse {
+        Exceptions?: Exceptions;
+        BindingsXML?: string;
+        EspProcesses?: EspProcesses;
+    }
+
+    export interface ListESDLDefinitionsRequest {
+
+    }
+
+    export interface Definitions {
+        Definition?: Definition[];
+    }
+
+    export interface ListESDLDefinitionsResponse {
+        Exceptions?: Exceptions;
+        Definitions?: Definitions;
+    }
+
+    export interface WsESDLConfigPingRequest {
+
+    }
+
+    export interface WsESDLConfigPingResponse {
+
+    }
+
+    export interface PublishESDLBindingRequest {
+        EspProcName?: string;
+        EspBindingName?: string;
+        EspPort?: string;
+        EsdlDefinitionID?: string;
+        EsdlServiceName?: string;
+        Overwrite?: boolean;
+        Config?: string;
+        Methods?: Methods;
+        EchoBinding?: boolean;
+    }
+
+    export interface PublishESDLBindingResponse {
+        Exceptions?: Exceptions;
+        EsdlDefinitionID?: string;
+        Overwrite?: boolean;
+        EspProcName?: string;
+        EspPort?: string;
+        status?: status;
+        ESDLBinding?: ESDLBinding;
+    }
+
+    export interface PublishESDLDefinitionRequest {
+        ServiceName?: string;
+        XMLDefinition?: string;
+        DeletePrevious?: boolean;
+        EchoDefinition?: boolean;
+    }
+
+    export interface PublishESDLDefinitionResponse {
+        Exceptions?: Exceptions;
+        ServiceName?: string;
+        EsdlVersion?: int;
+        DeletePrevious?: boolean;
+        status?: status;
+        Definition?: Definition;
+    }
+
+}
+
+export class ESDLConfigServiceBase extends Service {
+
+    constructor(optsConnection: IOptions | IConnection) {
+        super(optsConnection, "WsESDLConfig", "1.5");
+    }
+
+    ConfigureESDLBindingLogTransform(request: WsESDLConfig.ConfigureESDLBindingLogTransformRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.ConfigureESDLBindingLogTransformResponse> {
+        return this._connection.send("ConfigureESDLBindingLogTransform", request, "json", false, abortSignal, "ConfigureESDLBindingLogTransformResponse");
+    }
+
+    ConfigureESDLBindingMethod(request: WsESDLConfig.ConfigureESDLBindingMethodRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.ConfigureESDLBindingMethodResponse> {
+        return this._connection.send("ConfigureESDLBindingMethod", request, "json", false, abortSignal, "ConfigureESDLBindingMethodResponse");
+    }
+
+    DeleteESDLBinding(request: WsESDLConfig.DeleteESDLBindingRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.DeleteESDLRegistryEntryResponse> {
+        return this._connection.send("DeleteESDLBinding", request, "json", false, abortSignal, "DeleteESDLRegistryEntryResponse");
+    }
+
+    DeleteESDLDefinition(request: WsESDLConfig.DeleteESDLDefinitionRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.DeleteESDLRegistryEntryResponse> {
+        return this._connection.send("DeleteESDLDefinition", request, "json", false, abortSignal, "DeleteESDLRegistryEntryResponse");
+    }
+
+    Echo(request: WsESDLConfig.EchoRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.EchoResponse> {
+        return this._connection.send("Echo", request, "json", false, abortSignal, "EchoResponse");
+    }
+
+    GetESDLBinding(request: WsESDLConfig.GetESDLBindingRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.GetESDLBindingResponse> {
+        return this._connection.send("GetESDLBinding", request, "json", false, abortSignal, "GetESDLBindingResponse");
+    }
+
+    GetESDLDefinition(request: WsESDLConfig.GetESDLDefinitionRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.GetESDLDefinitionResponse> {
+        return this._connection.send("GetESDLDefinition", request, "json", false, abortSignal, "GetESDLDefinitionResponse");
+    }
+
+    ListDESDLEspBindings(request: WsESDLConfig.ListDESDLEspBindingsReq, abortSignal?: AbortSignal): Promise<WsESDLConfig.ListDESDLEspBindingsResp> {
+        return this._connection.send("ListDESDLEspBindings", request, "json", false, abortSignal, "ListDESDLEspBindingsResp");
+    }
+
+    ListESDLBindings(request: WsESDLConfig.ListESDLBindingsRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.ListESDLBindingsResponse> {
+        return this._connection.send("ListESDLBindings", request, "json", false, abortSignal, "ListESDLBindingsResponse");
+    }
+
+    ListESDLDefinitions(request: WsESDLConfig.ListESDLDefinitionsRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.ListESDLDefinitionsResponse> {
+        return this._connection.send("ListESDLDefinitions", request, "json", false, abortSignal, "ListESDLDefinitionsResponse");
+    }
+
+    Ping(request: WsESDLConfig.WsESDLConfigPingRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.WsESDLConfigPingResponse> {
+        return this._connection.send("Ping", request, "json", false, abortSignal, "WsESDLConfigPingResponse");
+    }
+
+    PublishESDLBinding(request: WsESDLConfig.PublishESDLBindingRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.PublishESDLBindingResponse> {
+        return this._connection.send("PublishESDLBinding", request, "json", false, abortSignal, "PublishESDLBindingResponse");
+    }
+
+    PublishESDLDefinition(request: WsESDLConfig.PublishESDLDefinitionRequest, abortSignal?: AbortSignal): Promise<WsESDLConfig.PublishESDLDefinitionResponse> {
+        return this._connection.send("PublishESDLDefinition", request, "json", false, abortSignal, "PublishESDLDefinitionResponse");
+    }
+
+}

package/src/services/wsdl/WsFileIO/v1.01/WsFileIO.ts

@@ -14,23 +14,23 @@ export namespace WsFileIO {
     }
 
     export interface Exception {
-        Code: string;
-        Audience: string;
-        Source: string;
-        Message: string;
+        Code?: string;
+        Audience?: string;
+        Source?: string;
+        Message?: string;
     }
 
     export interface Exceptions {
-        Source: string;
-        Exception: Exception[];
+        Source?: string;
+        Exception?: Exception[];
     }
 
     export interface CreateFileResponse {
-        Exceptions: Exceptions;
-        DestDropZone: string;
-        DestRelativePath: string;
-        Overwrite: boolean;
-        Result: string;
+        Exceptions?: Exceptions;
+        DestDropZone?: string;
+        DestRelativePath?: string;
+        Overwrite?: boolean;
+        Result?: string;
     }
 
     export interface WsFileIOPingRequest {
@@ -50,13 +50,13 @@ export namespace WsFileIO {
     }
 
     export interface ReadFileDataResponse {
-        Exceptions: Exceptions;
-        Data: base64Binary;
-        DestDropZone: string;
-        DestRelativePath: string;
-        Offset: long;
-        DataSize: long;
-        Result: string;
+        Exceptions?: Exceptions;
+        Data?: base64Binary;
+        DestDropZone?: string;
+        DestRelativePath?: string;
+        Offset?: long;
+        DataSize?: long;
+        Result?: string;
     }
 
     export interface WriteFileDataRequest {
@@ -69,12 +69,12 @@ export namespace WsFileIO {
     }
 
     export interface WriteFileDataResponse {
-        Exceptions: Exceptions;
-        DestDropZone: string;
-        DestRelativePath: string;
-        Offset: long;
-        Append: boolean;
-        Result: string;
+        Exceptions?: Exceptions;
+        DestDropZone?: string;
+        DestRelativePath?: string;
+        Offset?: long;
+        Append?: boolean;
+        Result?: string;
     }
 
 }
@@ -85,20 +85,20 @@ export class FileIOServiceBase extends Service {
         super(optsConnection, "WsFileIO", "1.01");
     }
 
-    CreateFile(request: Partial<WsFileIO.CreateFileRequest>): Promise<WsFileIO.CreateFileResponse> {
-        return this._connection.send("CreateFile", request, "json", false, undefined, "CreateFileResponse");
+    CreateFile(request: WsFileIO.CreateFileRequest, abortSignal?: AbortSignal): Promise<WsFileIO.CreateFileResponse> {
+        return this._connection.send("CreateFile", request, "json", false, abortSignal, "CreateFileResponse");
     }
 
-    Ping(request: Partial<WsFileIO.WsFileIOPingRequest>): Promise<WsFileIO.WsFileIOPingResponse> {
-        return this._connection.send("Ping", request, "json", false, undefined, "WsFileIOPingResponse");
+    Ping(request: WsFileIO.WsFileIOPingRequest, abortSignal?: AbortSignal): Promise<WsFileIO.WsFileIOPingResponse> {
+        return this._connection.send("Ping", request, "json", false, abortSignal, "WsFileIOPingResponse");
     }
 
-    ReadFileData(request: Partial<WsFileIO.ReadFileDataRequest>): Promise<WsFileIO.ReadFileDataResponse> {
-        return this._connection.send("ReadFileData", request, "json", false, undefined, "ReadFileDataResponse");
+    ReadFileData(request: WsFileIO.ReadFileDataRequest, abortSignal?: AbortSignal): Promise<WsFileIO.ReadFileDataResponse> {
+        return this._connection.send("ReadFileData", request, "json", false, abortSignal, "ReadFileDataResponse");
     }
 
-    WriteFileData(request: Partial<WsFileIO.WriteFileDataRequest>): Promise<WsFileIO.WriteFileDataResponse> {
-        return this._connection.send("WriteFileData", request, "json", false, undefined, "WriteFileDataResponse");
+    WriteFileData(request: WsFileIO.WriteFileDataRequest, abortSignal?: AbortSignal): Promise<WsFileIO.WriteFileDataResponse> {
+        return this._connection.send("WriteFileData", request, "json", false, abortSignal, "WriteFileDataResponse");
     }
 
 }