@hpcc-js/comms 2.75.0 → 2.78.0

package/types-3.4/services/wsdl/ws_access/v1.16/ws_access.d.ts

@@ -3,7 +3,7 @@ import { Service } from "../../../../espConnection";
 declare type int = number;
 declare type unsignedInt = number;
 declare type long = number;
-declare type base64Binary = number[];
+declare type base64Binary = string;
 export declare enum ViewMemberType {
     User = "User",
     Group = "Group"

package/types-3.4/services/wsdl/ws_account/v1.05/ws_account.d.ts

@@ -0,0 +1,74 @@
+import { IConnection, IOptions } from "../../../../connection";
+import { Service } from "../../../../espConnection";
+declare type int = number;
+export declare namespace WsAccount {
+    interface MyAccountRequest {
+    }
+    interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+    interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+    interface MyAccountResponse {
+        Exceptions: {
+            Source: string;
+            Exception: Exception[];
+        };
+        username: string;
+        firstName: string;
+        lastName: string;
+        passwordExpiration: string;
+        passwordDaysRemaining: int;
+        passwordExpirationWarningDays: int;
+        employeeID: string;
+        distinguishedName: string;
+        accountType: string;
+        passwordNeverExpires: boolean;
+        passwordIsExpired: boolean;
+        accountStatus: int;
+    }
+    interface ws_accountPingRequest {
+    }
+    interface ws_accountPingResponse {
+    }
+    interface UpdateUserRequest {
+        username?: string;
+        oldpass?: string;
+        newpass1?: string;
+        newpass2?: string;
+    }
+    interface UpdateUserResponse {
+        Exceptions: Exceptions;
+        retcode: int;
+        message: string;
+    }
+    interface UpdateUserInputRequest {
+    }
+    interface UpdateUserInputResponse {
+        Exceptions: Exceptions;
+        username: string;
+    }
+    interface VerifyUserRequest {
+        application?: string;
+        version?: string;
+    }
+    interface VerifyUserResponse {
+        Exceptions: Exceptions;
+        retcode: int;
+    }
+}
+export declare class AccountServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    MyAccount(request: WsAccount.MyAccountRequest): Promise<WsAccount.MyAccountResponse>;
+    Ping(request: WsAccount.ws_accountPingRequest): Promise<WsAccount.ws_accountPingResponse>;
+    UpdateUser(request: WsAccount.UpdateUserRequest): Promise<WsAccount.UpdateUserResponse>;
+    UpdateUserInput(request: WsAccount.UpdateUserInputRequest): Promise<WsAccount.UpdateUserInputResponse>;
+    VerifyUser(request: WsAccount.VerifyUserRequest): Promise<WsAccount.VerifyUserResponse>;
+}
+export {};
+//# sourceMappingURL=ws_account.d.ts.map

package/types-3.4/services/wsdl/ws_codesign/v1.1/ws_codesign.d.ts

@@ -0,0 +1,67 @@
+import { IConnection, IOptions } from "../../../../connection";
+import { Service } from "../../../../espConnection";
+declare type int = number;
+export declare enum SigningMethodType {
+    Gpg = "Gpg"
+}
+export declare namespace WsCodesign {
+    interface ListUserIDsRequest {
+    }
+    interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+    interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+    interface UserIDs {
+        Item: string[];
+    }
+    interface ListUserIDsResponse {
+        Exceptions: {
+            Source: string;
+            Exception: Exception[];
+        };
+        UserIDs: {
+            Item: string[];
+        };
+    }
+    interface ws_codesignPingRequest {
+    }
+    interface ws_codesignPingResponse {
+    }
+    interface SignRequest {
+        SigningMethod?: SigningMethodType;
+        UserID?: string;
+        KeyPass?: string;
+        Text?: string;
+    }
+    interface SignResponse {
+        Exceptions: Exceptions;
+        RetCode: int;
+        ErrMsg: string;
+        SignedText: string;
+    }
+    interface VerifyRequest {
+        Text?: string;
+    }
+    interface VerifyResponse {
+        Exceptions: Exceptions;
+        RetCode: int;
+        ErrMsg: string;
+        IsVerified: boolean;
+        SignedBy: string;
+    }
+}
+export declare class CodesignServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    ListUserIDs(request: WsCodesign.ListUserIDsRequest): Promise<WsCodesign.ListUserIDsResponse>;
+    Ping(request: WsCodesign.ws_codesignPingRequest): Promise<WsCodesign.ws_codesignPingResponse>;
+    Sign(request: WsCodesign.SignRequest): Promise<WsCodesign.SignResponse>;
+    Verify(request: WsCodesign.VerifyRequest): Promise<WsCodesign.VerifyResponse>;
+}
+export {};
+//# sourceMappingURL=ws_codesign.d.ts.map

package/types-3.4/services/wsdl/ws_elk/v1/ws_elk.d.ts

@@ -0,0 +1,28 @@
+import { IConnection, IOptions } from "../../../../connection";
+import { Service } from "../../../../espConnection";
+export declare namespace WsElk {
+    interface GetConfigDetailsRequest {
+    }
+    interface GetConfigDetailsResponse {
+        IntegrateKibana: boolean;
+        KibanaAddress: string;
+        KibanaPort: string;
+        KibanaEntryPointURI: string;
+        ReportElasticSearchHealth: boolean;
+        ElasticSearchAddresses: string;
+        ElasticSearchPort: string;
+        ReportLogStashHealth: boolean;
+        LogStashAddress: string;
+        LogStashPort: string;
+    }
+    interface ws_elkPingRequest {
+    }
+    interface ws_elkPingResponse {
+    }
+}
+export declare class ElkServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    GetConfigDetails(request: WsElk.GetConfigDetailsRequest): Promise<WsElk.GetConfigDetailsResponse>;
+    Ping(request: WsElk.ws_elkPingRequest): Promise<WsElk.ws_elkPingResponse>;
+}
+//# sourceMappingURL=ws_elk.d.ts.map

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

@@ -19,7 +19,7 @@ export declare namespace WsLogaccess {
     }
     interface Range {
         StartDate: dateTime;
-        EndDate?: dateTime;
+        EndDate: dateTime;
     }
     interface Columns {
         Item: string[];
@@ -27,10 +27,15 @@ export declare namespace WsLogaccess {
     interface GetLogsRequest {
         LogCategory?: LogAccessType;
         SearchByValue?: string;
-        Range?: Range;
+        Range?: {
+            StartDate?: dateTime;
+            EndDate?: dateTime;
+        };
         LogLineLimit?: unsignedInt;
         LogLineStartFrom?: long;
-        Columns?: Columns;
+        Columns?: {
+            Item?: string[];
+        };
         Format?: string;
     }
     interface GetLogsResponse {

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";
+declare type dateTime = string;
+declare type unsignedInt = number;
+declare type long = number;
+export declare enum LogAccessType {
+    All = 0,
+    ByJobIdID = 1,
+    ByComponent = 2,
+    ByLogType = 3,
+    ByTargetAudience = 4,
+    BySourceInstance = 5,
+    BySourceNode = 6,
+    ByFieldName = 7
+}
+export declare enum LogAccessFilterOperator {
+    NONE = 0,
+    AND = 1,
+    OR = 2
+}
+export declare enum LogSelectColumnMode {
+    MIN = 0,
+    DEFAULT = 1,
+    ALL = 2,
+    CUSTOM = 3
+}
+export declare namespace WsLogaccess {
+    interface GetLogAccessInfoRequest {
+    }
+    interface GetLogAccessInfoResponse {
+        RemoteLogManagerType: string;
+        RemoteLogManagerConnectionString: string;
+    }
+    interface leftFilter {
+        LogCategory: LogAccessType;
+        SearchByValue: string;
+        SearchField: string;
+    }
+    interface rightFilter {
+        LogCategory: LogAccessType;
+        SearchByValue: string;
+        SearchField: string;
+    }
+    interface rightBinaryFilter {
+        BinaryLogFilter: BinaryLogFilter[];
+    }
+    interface BinaryLogFilter {
+        leftFilter: leftFilter;
+        leftBinaryFilter: leftBinaryFilter;
+        Operator: LogAccessFilterOperator;
+        rightFilter: {
+            LogCategory: LogAccessType;
+            SearchByValue: string;
+            SearchField: string;
+        };
+        rightBinaryFilter: {
+            BinaryLogFilter: BinaryLogFilter[];
+        };
+    }
+    interface leftBinaryFilter {
+        BinaryLogFilter: BinaryLogFilter[];
+    }
+    interface Filter {
+        leftFilter: {
+            LogCategory: LogAccessType;
+            SearchByValue: string;
+            SearchField: string;
+        };
+        leftBinaryFilter: {
+            BinaryLogFilter: BinaryLogFilter[];
+        };
+        Operator: LogAccessFilterOperator;
+        rightFilter: rightFilter;
+        rightBinaryFilter: rightBinaryFilter;
+    }
+    interface Range {
+        StartDate: dateTime;
+        EndDate: dateTime;
+    }
+    interface Columns {
+        Item: string[];
+    }
+    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;
+    }
+    interface GetLogsResponse {
+        LogLines: string;
+        LogLineCount: unsignedInt;
+        TotalLogLinesAvailable: unsignedInt;
+    }
+    interface ws_logaccessPingRequest {
+    }
+    interface ws_logaccessPingResponse {
+    }
+}
+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>;
+}
+export {};
+//# sourceMappingURL=ws_logaccess.d.ts.map

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

@@ -0,0 +1,179 @@
+import { IConnection, IOptions } from "../../../../connection";
+import { Service } from "../../../../espConnection";
+declare type int = number;
+export declare namespace Wsstore {
+    interface CreateStoreRequest {
+        Name?: string;
+        Type?: string;
+        Description?: string;
+        MaxValueSize?: int;
+    }
+    interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+    interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+    interface CreateStoreResponse {
+        Exceptions: {
+            Source: string;
+            Exception: Exception[];
+        };
+        Name: string;
+        Type: string;
+        Description: string;
+        Owner: string;
+        Success: boolean;
+    }
+    interface DeleteRequest {
+        StoreName?: string;
+        Namespace?: string;
+        Key?: string;
+        UserSpecific?: boolean;
+        TargetUser?: string;
+    }
+    interface DeleteResponse {
+        Exceptions: Exceptions;
+        Success: boolean;
+    }
+    interface DeleteNamespaceRequest {
+        StoreName?: string;
+        Namespace?: string;
+        UserSpecific?: boolean;
+        TargetUser?: string;
+    }
+    interface DeleteNamespaceResponse {
+        Exceptions: Exceptions;
+        Success: boolean;
+    }
+    interface FetchRequest {
+        StoreName?: string;
+        Namespace?: string;
+        Key?: string;
+        UserSpecific?: boolean;
+    }
+    interface FetchResponse {
+        Exceptions: Exceptions;
+        Value: string;
+    }
+    interface FetchAllRequest {
+        StoreName?: string;
+        Namespace?: string;
+        UserSpecific?: boolean;
+    }
+    interface Pair {
+        Key: string;
+        Value: string;
+    }
+    interface Pairs {
+        Pair: Pair[];
+    }
+    interface FetchAllResponse {
+        Exceptions: Exceptions;
+        Namespace: string;
+        Pairs: {
+            Pair: Pair[];
+        };
+    }
+    interface FetchKeyMDRequest {
+        StoreName?: string;
+        Namespace?: string;
+        Key?: string;
+        UserSpecific?: boolean;
+    }
+    interface FetchKeyMDResponse {
+        Exceptions: Exceptions;
+        StoreName: string;
+        Namespace: string;
+        Key: string;
+        Pairs: Pairs;
+    }
+    interface ListKeysRequest {
+        StoreName?: string;
+        Namespace?: string;
+        UserSpecific?: boolean;
+    }
+    interface KeySet {
+        Key: string[];
+    }
+    interface ListKeysResponse {
+        Exceptions: Exceptions;
+        StoreName: string;
+        Namespace: string;
+        KeySet: {
+            Key: string[];
+        };
+    }
+    interface ListNamespacesRequest {
+        StoreName?: string;
+        UserSpecific?: boolean;
+    }
+    interface Namespaces {
+        Namespace: string[];
+    }
+    interface ListNamespacesResponse {
+        Exceptions: Exceptions;
+        StoreName: string;
+        Namespaces: {
+            Namespace: string[];
+        };
+    }
+    interface ListStoresRequest {
+        NameFilter?: string;
+        TypeFilter?: string;
+        OwnerFilter?: string;
+    }
+    interface Store {
+        Name: string;
+        Type: string;
+        Description: string;
+        Owner: string;
+        CreateTime: string;
+        MaxValSize: string;
+        IsDefault: boolean;
+    }
+    interface Stores {
+        Store: Store[];
+    }
+    interface ListStoresResponse {
+        Exceptions: Exceptions;
+        Stores: {
+            Store: Store[];
+        };
+    }
+    interface wsstorePingRequest {
+    }
+    interface wsstorePingResponse {
+    }
+    interface SetRequest {
+        StoreName?: string;
+        Namespace?: string;
+        Key?: string;
+        Value?: string;
+        UserSpecific?: boolean;
+    }
+    interface SetResponse {
+        Exceptions: Exceptions;
+        Success: boolean;
+    }
+}
+export declare class storeServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    CreateStore(request: Wsstore.CreateStoreRequest): Promise<Wsstore.CreateStoreResponse>;
+    Delete(request: Wsstore.DeleteRequest): Promise<Wsstore.DeleteResponse>;
+    DeleteNamespace(request: Wsstore.DeleteNamespaceRequest): Promise<Wsstore.DeleteNamespaceResponse>;
+    Fetch(request: Wsstore.FetchRequest): Promise<Wsstore.FetchResponse>;
+    FetchAll(request: Wsstore.FetchAllRequest): Promise<Wsstore.FetchAllResponse>;
+    FetchKeyMetadata(request: Wsstore.FetchKeyMDRequest): Promise<Wsstore.FetchKeyMDResponse>;
+    ListKeys(request: Wsstore.ListKeysRequest): Promise<Wsstore.ListKeysResponse>;
+    ListNamespaces(request: Wsstore.ListNamespacesRequest): Promise<Wsstore.ListNamespacesResponse>;
+    ListStores(request: Wsstore.ListStoresRequest): Promise<Wsstore.ListStoresResponse>;
+    Ping(request: Wsstore.wsstorePingRequest): Promise<Wsstore.wsstorePingResponse>;
+    Set(request: Wsstore.SetRequest): Promise<Wsstore.SetResponse>;
+}
+export {};
+//# sourceMappingURL=wsstore.d.ts.map