@hpcc-js/comms 2.77.0 → 2.78.2

package/types-3.4/services/wsLogaccess.d.ts

@@ -1,5 +1,49 @@
-import { LogaccessServiceBase, WsLogaccess, LogAccessType } from "./wsdl/ws_logaccess/v1/ws_logaccess";
-export { WsLogaccess, LogAccessType };
+import { LogaccessServiceBase, WsLogaccess } from "./wsdl/ws_logaccess/v1.02/ws_logaccess";
+export { WsLogaccess };
+export declare enum KnownColumns {
+    audience = "hpcc.log.audience",
+    class = "hpcc.log.class",
+    jobId = "hpcc.log.jobid",
+    message = "hpcc.log.message",
+    procId = "hpcc.log.procid",
+    sequence = "hpcc.log.sequence",
+    threadId = "hpcc.log.threadid",
+    timestamp = "hpcc.log.timestamp",
+    containerName = "kubernetes.container.name"
+}
+export interface GetLogsExRequest {
+    audience?: string;
+    class?: string;
+    jobId?: string;
+    message?: string;
+    procId?: string;
+    sequence?: string;
+    threadId?: string;
+    timestamp?: string;
+    containerName?: string;
+    StartDate?: Date;
+    EndDate?: Date;
+    LogLineStartFrom: number;
+    LogLineLimit: number;
+}
+export interface LogLine {
+    audience?: string;
+    class?: string;
+    jobId?: string;
+    message?: string;
+    procId?: number;
+    sequence?: string;
+    threadId?: number;
+    timestamp?: string;
+    containerName?: string;
+}
+export interface GetLogsExResponse {
+    lines: LogLine[];
+    total: number;
+}
 export declare class LogaccessService extends LogaccessServiceBase {
+    GetLogAccessInfo(request: WsLogaccess.GetLogAccessInfoRequest): Promise<WsLogaccess.GetLogAccessInfoResponse>;
+    GetLogs(request: WsLogaccess.GetLogsRequest): Promise<WsLogaccess.GetLogsResponse>;
+    GetLogsEx(request: GetLogsExRequest): Promise<GetLogsExResponse>;
 }
 //# sourceMappingURL=wsLogaccess.d.ts.map

package/types-3.4/services/wsWorkunits.d.ts

@@ -1621,6 +1621,53 @@ export declare namespace WUQuerySetAliasAction {
         Results: Results;
     }
 }
+export declare namespace WUQueryFiles {
+    interface Request {
+        Target: string;
+        QueryId: string;
+    }
+    interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+    interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+    interface File {
+        Error: string;
+        LogicalName: string;
+    }
+    interface Files {
+        File: File[];
+    }
+    interface SubFiles {
+        File: string[];
+    }
+    interface SuperFile {
+        Name: string;
+        SubFiles: SubFiles;
+        SuperFiles: SuperFiles;
+    }
+    interface SuperFiles {
+        SuperFile: SuperFile[];
+    }
+    interface QueryUsingFile {
+        Id: string;
+        Package: string;
+    }
+    interface Queries {
+        QueryUsingFile: QueryUsingFile[];
+    }
+    interface Response {
+        Exceptions: Exceptions;
+        Files: Files;
+        SuperFiles: SuperFiles;
+        Queries: Queries;
+    }
+}
 export declare namespace WUPublishWorkunit {
     interface Request {
         Wuid: string;
@@ -2232,6 +2279,7 @@ export declare class WorkunitsService extends Service {
     WUQuerySetAliasAction(request: WUQuerySetAliasAction.Request): Promise<WUQuerySetAliasAction.Response>;
     WUQuerySetQueryAction(request: WUQuerySetQueryAction.Request): Promise<WUQuerySetQueryAction.Response>;
     WUPublishWorkunit(request: WUPublishWorkunit.Request): Promise<WUPublishWorkunit.Response>;
+    WUQueryFiles(request: WUQueryFiles.Request): Promise<WUQueryFiles.Response>;
     WUGetGraph(request: WUGetGraph.Request): Promise<WUGetGraph.Response>;
     WUResult(request: WUResult.Request, abortSignal?: AbortSignal): Promise<WUResult.Response>;
     WUQueryGetGraph(request: WUQueryGetGraph.Request): Promise<WUQueryGetGraph.Response>;

package/types-3.4/services/wsdl/WsDali/v1.04/WsDali.d.ts

@@ -1,103 +1,104 @@
 import { IConnection, IOptions } from "../../../../connection";
 import { Service } from "../../../../espConnection";
-declare type unsignedInt = number;
 export declare namespace WsDali {
-    interface AddRequest {
+    type unsignedInt = number;
+    export interface AddRequest {
         Path?: string;
         Value?: string;
     }
-    interface Exception {
+    export interface Exception {
         Code: string;
         Audience: string;
         Source: string;
         Message: string;
     }
-    interface Exceptions {
+    export interface Exceptions {
         Source: string;
         Exception: Exception[];
     }
-    interface ResultResponse {
+    export interface ResultResponse {
         Exceptions: {
             Source: string;
             Exception: Exception[];
         };
         Result: string;
     }
-    interface CountRequest {
+    export interface CountRequest {
         Path?: string;
     }
-    interface CountResponse {
+    export interface CountResponse {
         Exceptions: Exceptions;
         Result: unsignedInt;
     }
-    interface DFSCheckRequest {
+    export interface DFSCheckRequest {
     }
-    interface DFSExistsRequest {
+    export interface DFSExistsRequest {
         FileName?: string;
     }
-    interface BooleanResponse {
+    export interface BooleanResponse {
         Exceptions: Exceptions;
         Result: boolean;
     }
-    interface DFSLSRequest {
+    export interface DFSLSRequest {
         Name?: string;
         PathAndNameOnly?: boolean;
         IncludeSubFileInfo?: boolean;
         Recursively?: boolean;
     }
-    interface DeleteRequest {
+    export interface DeleteRequest {
         Path?: string;
     }
-    interface GetDFSCSVRequest {
+    export interface GetDFSCSVRequest {
         LogicalNameMask?: string;
     }
-    interface GetDFSMapRequest {
+    export interface GetDFSMapRequest {
         FileName?: string;
     }
-    interface GetDFSParentsRequest {
+    export interface GetDFSParentsRequest {
         FileName?: string;
     }
-    interface GetLogicalFileRequest {
+    export interface GetLogicalFileRequest {
         FileName?: string;
     }
-    interface GetLogicalFilePartRequest {
+    export interface GetLogicalFilePartRequest {
         FileName?: string;
         PartNumber?: unsignedInt;
     }
-    interface GetProtectedListRequest {
+    export interface GetProtectedListRequest {
         FileName?: string;
         CallerId?: string;
     }
-    interface GetValueRequest {
+    export interface GetValueRequest {
         Path?: string;
     }
-    interface ImportRequest {
+    export interface ImportRequest {
         XML?: string;
         Path?: string;
         Add?: boolean;
     }
-    interface WSDaliPingRequest {
+    export interface WSDaliPingRequest {
     }
-    interface WSDaliPingResponse {
+    export interface WSDaliPingResponse {
     }
-    interface SetLogicalFilePartAttrRequest {
+    export interface SetLogicalFilePartAttrRequest {
         FileName?: string;
         PartNumber?: unsignedInt;
         Attr?: string;
         Value?: string;
     }
-    interface SetProtectedRequest {
+    export interface SetProtectedRequest {
         FileName?: string;
         CallerId?: string;
     }
-    interface SetUnprotectedRequest {
+    export interface SetUnprotectedRequest {
         FileName?: string;
         CallerId?: string;
     }
-    interface SetValueRequest {
+    export interface SetValueRequest {
         Path?: string;
         Value?: string;
     }
+    export {};
 }
 export declare class DaliServiceBase extends Service {
     constructor(optsConnection: IOptions | IConnection);
@@ -121,5 +122,4 @@ export declare class DaliServiceBase extends Service {
     SetUnprotected(request: WsDali.SetUnprotectedRequest): Promise<WsDali.ResultResponse>;
     SetValue(request: WsDali.SetValueRequest): Promise<WsDali.ResultResponse>;
 }
-export {};
 //# sourceMappingURL=WsDali.d.ts.map

package/types-3.4/services/wsdl/WsDfu/v1.63/WsDfu.d.ts

@@ -1,53 +1,53 @@
 import { IConnection, IOptions } from "../../../../connection";
 import { Service } from "../../../../espConnection";
-export declare type base64Binary = string;
-declare type long = number;
-declare type int = number;
-declare type double = number;
-export declare enum DFUArrayActions {
-    Delete = "Delete",
-    AddToSuperfile = "AddToSuperfile",
-    ChangeProtection = "ChangeProtection",
-    ChangeRestriction = "ChangeRestriction"
-}
-export declare enum DFUChangeProtection {
-    NoChange = 0,
-    Protect = 1,
-    Unprotect = 2,
-    UnprotectAll = 3
-}
-export declare enum DFUChangeRestriction {
-    NoChange = 0,
-    Restrict = 1,
-    Unrestricted = 2
-}
-export declare enum DFUDefFileFormat {
-    Xml = "Xml",
-    Def = "Def"
-}
-export declare enum FileAccessRole {
-    Token = "Token",
-    Engine = "Engine",
-    External = "External"
-}
-export declare enum SecAccessType {
-    None = "None",
-    Access = "Access",
-    Read = "Read",
-    Write = "Write",
-    Full = "Full"
-}
-export declare enum DFUFileType {
-    Flat = "Flat",
-    Index = "Index",
-    Xml = "Xml",
-    Csv = "Csv",
-    Json = "Json",
-    IndexLocal = "IndexLocal",
-    IndexPartitioned = "IndexPartitioned",
-    Unset = "Unset"
-}
 export declare namespace WsDfu {
+    type base64Binary = string;
+    type long = number;
+    type int = number;
+    type double = number;
+    enum DFUArrayActions {
+        Delete = "Delete",
+        AddToSuperfile = "AddToSuperfile",
+        ChangeProtection = "ChangeProtection",
+        ChangeRestriction = "ChangeRestriction"
+    }
+    enum DFUChangeProtection {
+        NoChange = 0,
+        Protect = 1,
+        Unprotect = 2,
+        UnprotectAll = 3
+    }
+    enum DFUChangeRestriction {
+        NoChange = 0,
+        Restrict = 1,
+        Unrestricted = 2
+    }
+    enum DFUDefFileFormat {
+        xml = "xml",
+        def = "def"
+    }
+    enum FileAccessRole {
+        Token = "Token",
+        Engine = "Engine",
+        External = "External"
+    }
+    enum SecAccessType {
+        None = "None",
+        Access = "Access",
+        Read = "Read",
+        Write = "Write",
+        Full = "Full"
+    }
+    enum DFUFileType {
+        Flat = "Flat",
+        Index = "Index",
+        Xml = "Xml",
+        Csv = "Csv",
+        Json = "Json",
+        IndexLocal = "IndexLocal",
+        IndexPartitioned = "IndexPartitioned",
+        Unset = "Unset"
+    }
     interface AddRequest {
         dstname?: string;
         xmlmap?: base64Binary;
@@ -829,6 +829,7 @@ export declare namespace WsDfu {
         KeyType: string;
         AtRestCost: double;
         AccessCost: double;
+        ExpirationDate: string;
     }
     interface DFUInfoResponse {
         Exceptions: Exceptions;
@@ -908,6 +909,7 @@ export declare namespace WsDfu {
             KeyType: string;
             AtRestCost: double;
             AccessCost: double;
+            ExpirationDate: string;
         };
     }
     interface DFUQueryRequest {
@@ -1228,5 +1230,4 @@ export declare class DfuServiceBase extends Service {
     SuperfileAction(request: WsDfu.SuperfileActionRequest): Promise<WsDfu.SuperfileActionResponse>;
     SuperfileList(request: WsDfu.SuperfileListRequest): Promise<WsDfu.SuperfileListResponse>;
 }
-export {};
 //# sourceMappingURL=WsDfu.d.ts.map

package/types-3.4/services/wsdl/ws_logaccess/v1.02/ws_logaccess.d.ts

@@ -0,0 +1,126 @@
+import { IConnection, IOptions } from "../../../../connection";
+import { Service } from "../../../../espConnection";
+export declare namespace WsLogaccess {
+    type dateTime = string;
+    type unsignedInt = number;
+    type long = number;
+    export enum LogAccessType {
+        All = 0,
+        ByJobIdID = 1,
+        ByComponent = 2,
+        ByLogType = 3,
+        ByTargetAudience = 4,
+        BySourceInstance = 5,
+        BySourceNode = 6,
+        ByFieldName = 7
+    }
+    export enum LogAccessFilterOperator {
+        NONE = 0,
+        AND = 1,
+        OR = 2
+    }
+    export enum LogSelectColumnMode {
+        MIN = 0,
+        DEFAULT = 1,
+        ALL = 2,
+        CUSTOM = 3
+    }
+    export interface GetLogAccessInfoRequest {
+    }
+    export interface GetLogAccessInfoResponse {
+        RemoteLogManagerType: string;
+        RemoteLogManagerConnectionString: string;
+    }
+    export interface leftFilter {
+        LogCategory: LogAccessType;
+        SearchByValue: string;
+        SearchField: string;
+    }
+    export interface rightFilter {
+        LogCategory: LogAccessType;
+        SearchByValue: string;
+        SearchField: string;
+    }
+    export interface rightBinaryFilter {
+        BinaryLogFilter: BinaryLogFilter[];
+    }
+    export interface BinaryLogFilter {
+        leftFilter: leftFilter;
+        leftBinaryFilter: leftBinaryFilter;
+        Operator: LogAccessFilterOperator;
+        rightFilter: {
+            LogCategory: LogAccessType;
+            SearchByValue: string;
+            SearchField: string;
+        };
+        rightBinaryFilter: {
+            BinaryLogFilter: BinaryLogFilter[];
+        };
+    }
+    export interface leftBinaryFilter {
+        BinaryLogFilter: BinaryLogFilter[];
+    }
+    export interface Filter {
+        leftFilter: {
+            LogCategory: LogAccessType;
+            SearchByValue: string;
+            SearchField: string;
+        };
+        leftBinaryFilter: {
+            BinaryLogFilter: BinaryLogFilter[];
+        };
+        Operator: LogAccessFilterOperator;
+        rightFilter: rightFilter;
+        rightBinaryFilter: rightBinaryFilter;
+    }
+    export interface Range {
+        StartDate: dateTime;
+        EndDate: dateTime;
+    }
+    export interface Columns {
+        Item: string[];
+    }
+    export interface GetLogsRequest {
+        Filter?: {
+            leftFilter?: {
+                LogCategory?: LogAccessType;
+                SearchByValue?: string;
+                SearchField?: string;
+            };
+            leftBinaryFilter?: {
+                BinaryLogFilter?: BinaryLogFilter[];
+            };
+            Operator?: LogAccessFilterOperator;
+            rightFilter?: rightFilter;
+            rightBinaryFilter?: rightBinaryFilter;
+        };
+        Range?: {
+            StartDate?: dateTime;
+            EndDate?: dateTime;
+        };
+        LogLineLimit?: unsignedInt;
+        LogLineStartFrom?: long;
+        SelectColumnMode?: LogSelectColumnMode;
+        Columns?: {
+            Item?: string[];
+        };
+        Format?: string;
+    }
+    export interface GetLogsResponse {
+        LogLines: string;
+        LogLineCount: unsignedInt;
+        TotalLogLinesAvailable: unsignedInt;
+    }
+    export interface ws_logaccessPingRequest {
+    }
+    export interface ws_logaccessPingResponse {
+    }
+    export {};
+}
+export declare class LogaccessServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    GetLogAccessInfo(request: WsLogaccess.GetLogAccessInfoRequest): Promise<WsLogaccess.GetLogAccessInfoResponse>;
+    GetLogs(request: WsLogaccess.GetLogsRequest): Promise<WsLogaccess.GetLogsResponse>;
+    Ping(request: WsLogaccess.ws_logaccessPingRequest): Promise<WsLogaccess.ws_logaccessPingResponse>;
+}
+//# sourceMappingURL=ws_logaccess.d.ts.map