@hpcc-js/comms 2.74.0 → 2.75.0

package/types/services/wsdl/WsDfu/v1.62/WsDfu.d.ts

@@ -0,0 +1,1224 @@
+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 {
+    interface AddRequest {
+        dstname?: string;
+        xmlmap?: base64Binary;
+        dstcluster?: string;
+    }
+    interface Exception {
+        Code: string;
+        Audience: string;
+        Source: string;
+        Message: string;
+    }
+    interface Exceptions {
+        Source: string;
+        Exception: Exception[];
+    }
+    interface AddResponse {
+        Exceptions: {
+            Source: string;
+            Exception: Exception[];
+        };
+    }
+    interface AddRemoteRequest {
+        dstname?: string;
+        srcname?: string;
+        srcdali?: string;
+        srcusername?: string;
+        srcpassword?: string;
+    }
+    interface AddRemoteResponse {
+        Exceptions: Exceptions;
+    }
+    interface names {
+        Item: string[];
+    }
+    interface AddtoSuperfileRequest {
+        Superfile?: string;
+        Subfiles?: string;
+        names?: {
+            Item?: string[];
+        };
+        ExistingFile?: boolean;
+        BackToPage?: string;
+    }
+    interface SubfileNames {
+        SubfileName: string[];
+    }
+    interface AddtoSuperfileResponse {
+        Exceptions: Exceptions;
+        Subfiles: string;
+        BackToPage: string;
+        SubfileNames: {
+            SubfileName: string[];
+        };
+    }
+    interface LogicalFiles {
+        Item: string[];
+    }
+    interface DFUArrayActionRequest {
+        Type?: DFUArrayActions;
+        NoDelete?: boolean;
+        BackToPage?: string;
+        LogicalFiles?: {
+            Item?: string[];
+        };
+        removeFromSuperfiles?: boolean;
+        removeRecursively?: boolean;
+        Protect?: DFUChangeProtection;
+        Restrict?: DFUChangeRestriction;
+    }
+    interface DFUActionInfo {
+        FileName: string;
+        NodeGroup: string;
+        ActionResult: string;
+        Failed: boolean;
+    }
+    interface ActionResults {
+        DFUActionInfo: DFUActionInfo[];
+    }
+    interface DFUArrayActionResponse {
+        Exceptions: Exceptions;
+        BackToPage: string;
+        RedirectTo: string;
+        ActionResults: {
+            DFUActionInfo: DFUActionInfo[];
+        };
+    }
+    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;
+    }
+    interface DFUDataColumn {
+        ColumnID: int;
+        ColumnLabel: string;
+        ColumnType: string;
+        ColumnValue: string;
+        ColumnSize: int;
+        MaxSize: int;
+        ColumnEclType: string;
+        ColumnRawSize: int;
+        IsNaturalColumn: boolean;
+        IsKeyedColumn: boolean;
+        DataColumns: DataColumns;
+    }
+    interface DataColumns {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface ColumnHidden {
+        ColumnID: int;
+        ColumnLabel: string;
+        ColumnType: string;
+        ColumnValue: string;
+        ColumnSize: int;
+        MaxSize: int;
+        ColumnEclType: string;
+        ColumnRawSize: int;
+        IsNaturalColumn: boolean;
+        IsKeyedColumn: boolean;
+        DataColumns: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+    }
+    interface ColumnsHidden {
+        ColumnHidden: ColumnHidden[];
+    }
+    interface DFUBrowseDataResponse {
+        Exceptions: Exceptions;
+        Name: string;
+        LogicalName: string;
+        FilterBy: string;
+        FilterForGoBack: string;
+        ColumnsHidden: {
+            ColumnHidden: ColumnHidden[];
+        };
+        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;
+    }
+    interface DFUDefFileRequest {
+        Name?: string;
+        Format?: DFUDefFileFormat;
+    }
+    interface DFUDefFileResponse {
+        Exceptions: Exceptions;
+        defFile: base64Binary;
+    }
+    interface RequestBase {
+        Name: string;
+        Cluster: string;
+        JobId: string;
+        ExpirySeconds: int;
+        AccessRole: FileAccessRole;
+        AccessType: SecAccessType;
+        ReturnJsonTypeInfo: boolean;
+        ReturnBinTypeInfo: boolean;
+    }
+    interface DFUFileAccessRequest {
+        RequestBase?: {
+            Name?: string;
+            Cluster?: string;
+            JobId?: string;
+            ExpirySeconds?: int;
+            AccessRole?: FileAccessRole;
+            AccessType?: SecAccessType;
+            ReturnJsonTypeInfo?: boolean;
+            ReturnBinTypeInfo?: boolean;
+        };
+    }
+    interface DFUPartLocation {
+        LocationIndex: int;
+        Host: string;
+    }
+    interface FileLocations {
+        DFUPartLocation: DFUPartLocation[];
+    }
+    interface DFUFileCopy {
+        CopyIndex: int;
+        LocationIndex: int;
+        Path: string;
+    }
+    interface Copies {
+        DFUFileCopy: DFUFileCopy[];
+    }
+    interface DFUFilePart {
+        PartIndex: int;
+        Copies: {
+            DFUFileCopy: DFUFileCopy[];
+        };
+        TopLevelKey: boolean;
+    }
+    interface FileParts {
+        DFUFilePart: DFUFilePart[];
+    }
+    interface AccessInfo {
+        MetaInfoBlob: string;
+        ExpiryTime: string;
+        NumParts: int;
+        FileLocations: {
+            DFUPartLocation: DFUPartLocation[];
+        };
+        FileParts: {
+            DFUFilePart: DFUFilePart[];
+        };
+        RecordTypeInfoJson: string;
+        fileAccessPort: int;
+        fileAccessSSL: boolean;
+    }
+    interface DFUFileAccessResponse {
+        Exceptions: Exceptions;
+        AccessInfo: {
+            MetaInfoBlob: string;
+            ExpiryTime: string;
+            NumParts: int;
+            FileLocations: {
+                DFUPartLocation: DFUPartLocation[];
+            };
+            FileParts: {
+                DFUFilePart: DFUFilePart[];
+            };
+            RecordTypeInfoJson: string;
+            fileAccessPort: int;
+            fileAccessSSL: boolean;
+        };
+        Type: DFUFileType;
+    }
+    interface DFUFileAccessV2Request {
+        Name?: string;
+        Cluster?: string;
+        RequestId?: string;
+        ExpirySeconds?: int;
+        ReturnTextResponse?: boolean;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+    }
+    interface PartLocations {
+        Item: string[];
+    }
+    interface DFUFileCreateRequest {
+        ECLRecordDefinition?: string;
+        PartLocations?: {
+            Item?: string[];
+        };
+        RequestBase?: RequestBase;
+    }
+    interface DFUFileCreateResponse {
+        Exceptions: Exceptions;
+        FileId: string;
+        Warning: string;
+        AccessInfo: AccessInfo;
+    }
+    interface DFUFileCreateV2Request {
+        Name?: string;
+        Cluster?: string;
+        Type?: DFUFileType;
+        ECLRecordDefinition?: string;
+        RequestId?: string;
+        ExpirySeconds?: int;
+        ReturnTextResponse?: boolean;
+        Compressed?: boolean;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+    }
+    interface DFUFilePublishRequest {
+        FileId?: string;
+        Overwrite?: boolean;
+        FileDescriptorBlob?: base64Binary;
+        SessionId?: long;
+        LockTimeoutMs?: int;
+        ECLRecordDefinition?: string;
+        RecordCount?: long;
+        FileSize?: long;
+    }
+    interface DFUFilePublishResponse {
+        Exceptions: Exceptions;
+    }
+    interface DFUFileViewRequest {
+        Scope?: string;
+        IncludeSuperOwner?: boolean;
+    }
+    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;
+    }
+    interface DFULogicalFiles {
+        DFULogicalFile: DFULogicalFile[];
+    }
+    interface DFUFileViewResponse {
+        Exceptions: Exceptions;
+        Scope: string;
+        NumFiles: int;
+        DFULogicalFiles: {
+            DFULogicalFile: DFULogicalFile[];
+        };
+    }
+    interface DFUGetDataColumnsRequest {
+        OpenLogicalName?: string;
+        LogicalName?: string;
+        FilterBy?: string;
+        ShowColumns?: string;
+        ChooseFile?: int;
+        Cluster?: string;
+        ClusterType?: string;
+        StartIndex?: long;
+        EndIndex?: long;
+    }
+    interface DFUDataKeyedColumns1 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns2 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns3 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns4 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns5 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns6 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns7 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns8 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns9 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns10 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns11 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns12 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns13 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns14 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns15 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns16 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns17 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns18 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns19 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataKeyedColumns20 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns1 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns2 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns3 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns4 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns5 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns6 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns7 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns8 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns9 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns10 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns11 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns12 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns13 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns14 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns15 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns16 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns17 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns18 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns19 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUDataNonKeyedColumns20 {
+        DFUDataColumn: DFUDataColumn[];
+    }
+    interface DFUGetDataColumnsResponse {
+        Exceptions: Exceptions;
+        LogicalName: string;
+        StartIndex: long;
+        EndIndex: long;
+        DFUDataKeyedColumns1: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns2: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns3: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns4: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns5: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns6: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns7: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns8: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns9: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns10: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns11: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns12: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns13: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns14: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns15: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns16: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns17: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns18: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns19: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataKeyedColumns20: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns1: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns2: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns3: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns4: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns5: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns6: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns7: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns8: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns9: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns10: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns11: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns12: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns13: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns14: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns15: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns16: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns17: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns18: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns19: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        DFUDataNonKeyedColumns20: {
+            DFUDataColumn: DFUDataColumn[];
+        };
+        RowCount: long;
+        ShowColumns: string;
+        ChooseFile: int;
+        Cluster: string;
+        ClusterType: string;
+    }
+    interface DFUGetFileMetaDataRequest {
+        LogicalFileName?: string;
+        ClusterName?: string;
+        IncludeXmlSchema?: boolean;
+        AddHeaderInXmlSchema?: boolean;
+        IncludeXmlXPathSchema?: boolean;
+        AddHeaderInXmlXPathSchema?: boolean;
+    }
+    interface DFUGetFileMetaDataResponse {
+        Exceptions: Exceptions;
+        TotalColumnCount: int;
+        KeyedColumnCount: int;
+        DataColumns: DataColumns;
+        XmlSchema: string;
+        XmlXPathSchema: string;
+        TotalResultRows: long;
+    }
+    interface DFUInfoRequest {
+        Name?: string;
+        Cluster?: string;
+        UpdateDescription?: boolean;
+        QuerySet?: string;
+        Query?: string;
+        FileDesc?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+        Protect?: DFUChangeProtection;
+        Restrict?: DFUChangeRestriction;
+    }
+    interface Stat {
+        MinSkew: string;
+        MaxSkew: string;
+        MinSkewInt64: long;
+        MaxSkewInt64: long;
+        MinSkewPart: long;
+        MaxSkewPart: long;
+    }
+    interface DFUPart {
+        Id: int;
+        Copy: int;
+        Ip: string;
+        Partsize: string;
+        PartSizeInt64: long;
+        CompressedSize: long;
+    }
+    interface DFUFileParts {
+        DFUPart: DFUPart[];
+    }
+    interface DFUFilePartsOnCluster {
+        Cluster: string;
+        BaseDir: string;
+        ReplicateDir: string;
+        Replicate: boolean;
+        CanReplicate: boolean;
+        DFUFileParts: {
+            DFUPart: DFUPart[];
+        };
+    }
+    interface DFUFilePartsOnClusters {
+        DFUFilePartsOnCluster: DFUFilePartsOnCluster[];
+    }
+    interface subfiles {
+        Item: string[];
+    }
+    interface Superfiles {
+        DFULogicalFile: DFULogicalFile[];
+    }
+    interface DFUFileProtect {
+        Owner: string;
+        Modified: string;
+    }
+    interface ProtectList {
+        DFUFileProtect: DFUFileProtect[];
+    }
+    interface Graphs {
+        ECLGraph: string[];
+    }
+    interface FieldNames {
+        Item: string[];
+    }
+    interface Partition {
+        FieldMask: long;
+        FieldNames: {
+            Item: string[];
+        };
+    }
+    interface DFUFileBloom {
+        FieldMask: long;
+        FieldNames: FieldNames;
+        Limit: long;
+        Probability: string;
+    }
+    interface Blooms {
+        DFUFileBloom: DFUFileBloom[];
+    }
+    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: {
+            MinSkew: string;
+            MaxSkew: string;
+            MinSkewInt64: long;
+            MaxSkewInt64: long;
+            MinSkewPart: long;
+            MaxSkewPart: long;
+        };
+        DFUFilePartsOnClusters: {
+            DFUFilePartsOnCluster: DFUFilePartsOnCluster[];
+        };
+        isSuperfile: boolean;
+        ShowFileContent: boolean;
+        subfiles: {
+            Item: string[];
+        };
+        Superfiles: {
+            DFULogicalFile: DFULogicalFile[];
+        };
+        ProtectList: {
+            DFUFileProtect: DFUFileProtect[];
+        };
+        FromRoxieCluster: boolean;
+        Graphs: {
+            ECLGraph: string[];
+        };
+        UserPermission: string;
+        ContentType: string;
+        CompressedFileSize: long;
+        PercentCompressed: string;
+        IsCompressed: boolean;
+        IsRestricted: boolean;
+        BrowseData: boolean;
+        jsonInfo: string;
+        binInfo: base64Binary;
+        PackageID: string;
+        Partition: {
+            FieldMask: long;
+            FieldNames: {
+                Item: string[];
+            };
+        };
+        Blooms: {
+            DFUFileBloom: DFUFileBloom[];
+        };
+        ExpireDays: int;
+        KeyType: string;
+        AtRestCost: double;
+        AccessCost: double;
+    }
+    interface DFUInfoResponse {
+        Exceptions: Exceptions;
+        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: {
+                MinSkew: string;
+                MaxSkew: string;
+                MinSkewInt64: long;
+                MaxSkewInt64: long;
+                MinSkewPart: long;
+                MaxSkewPart: long;
+            };
+            DFUFilePartsOnClusters: {
+                DFUFilePartsOnCluster: DFUFilePartsOnCluster[];
+            };
+            isSuperfile: boolean;
+            ShowFileContent: boolean;
+            subfiles: {
+                Item: string[];
+            };
+            Superfiles: {
+                DFULogicalFile: DFULogicalFile[];
+            };
+            ProtectList: {
+                DFUFileProtect: DFUFileProtect[];
+            };
+            FromRoxieCluster: boolean;
+            Graphs: {
+                ECLGraph: string[];
+            };
+            UserPermission: string;
+            ContentType: string;
+            CompressedFileSize: long;
+            PercentCompressed: string;
+            IsCompressed: boolean;
+            IsRestricted: boolean;
+            BrowseData: boolean;
+            jsonInfo: string;
+            binInfo: base64Binary;
+            PackageID: string;
+            Partition: {
+                FieldMask: long;
+                FieldNames: {
+                    Item: string[];
+                };
+            };
+            Blooms: {
+                DFUFileBloom: DFUFileBloom[];
+            };
+            ExpireDays: int;
+            KeyType: string;
+            AtRestCost: double;
+            AccessCost: double;
+        };
+    }
+    interface DFUQueryRequest {
+        Prefix?: string;
+        NodeGroup?: string;
+        ContentType?: string;
+        LogicalName?: string;
+        Owner?: string;
+        StartDate?: string;
+        EndDate?: string;
+        FileType?: string;
+        FileSizeFrom?: long;
+        FileSizeTo?: long;
+        FirstN?: int;
+        PageSize?: int;
+        PageStartFrom?: int;
+        Sortby?: string;
+        Descending?: boolean;
+        OneLevelDirFileReturn?: boolean;
+        CacheHint?: long;
+        MaxNumberOfFiles?: int;
+        IncludeSuperOwner?: boolean;
+        StartAccessedTime?: string;
+        EndAccessedTime?: string;
+    }
+    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;
+    }
+    interface DFURecordTypeInfoRequest {
+        Name?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+    }
+    interface DFURecordTypeInfoResponse {
+        jsonInfo: string;
+        binInfo: base64Binary;
+    }
+    interface DFUSearchRequest {
+        ShowExample?: string;
+    }
+    interface ClusterNames {
+        ClusterName: string[];
+    }
+    interface FileTypes {
+        FileType: string[];
+    }
+    interface DFUSearchResponse {
+        Exceptions: Exceptions;
+        ShowExample: string;
+        ClusterNames: {
+            ClusterName: string[];
+        };
+        FileTypes: {
+            FileType: string[];
+        };
+    }
+    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;
+    }
+    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;
+    }
+    interface DFUSpaceRequest {
+        CountBy?: string;
+        ScopeUnder?: string;
+        OwnerUnder?: string;
+        Interval?: string;
+        StartDate?: string;
+        EndDate?: string;
+    }
+    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;
+    }
+    interface DFUSpaceItems {
+        DFUSpaceItem: DFUSpaceItem[];
+    }
+    interface DFUSpaceResponse {
+        Exceptions: Exceptions;
+        CountBy: string;
+        ScopeUnder: string;
+        OwnerUnder: string;
+        Interval: string;
+        StartDate: string;
+        EndDate: string;
+        DFUSpaceItems: {
+            DFUSpaceItem: DFUSpaceItem[];
+        };
+    }
+    interface EclRecordTypeInfoRequest {
+        Ecl?: string;
+        IncludeJsonTypeInfo?: boolean;
+        IncludeBinTypeInfo?: boolean;
+    }
+    interface EclRecordTypeInfoResponse {
+        jsonInfo: string;
+        binInfo: base64Binary;
+    }
+    interface EraseHistoryRequest {
+        Name?: string;
+    }
+    interface Origin {
+        Name: string;
+        Operation: string;
+        Timestamp: string;
+        IP: string;
+        Path: string;
+        Owner: string;
+        Workunit: string;
+    }
+    interface History {
+        Origin: Origin[];
+    }
+    interface EraseHistoryResponse {
+        Exceptions: Exceptions;
+        History: {
+            Origin: Origin[];
+        };
+    }
+    interface ListHistoryRequest {
+        Name?: string;
+    }
+    interface ListHistoryResponse {
+        Exceptions: Exceptions;
+        History: History;
+    }
+    interface WsDfuPingRequest {
+    }
+    interface WsDfuPingResponse {
+    }
+    interface SavexmlRequest {
+        name?: string;
+    }
+    interface SavexmlResponse {
+        Exceptions: Exceptions;
+        xmlmap: base64Binary;
+    }
+    interface SuperfileActionRequest {
+        action?: string;
+        superfile?: string;
+        subfiles?: subfiles;
+        before?: string;
+        delete?: boolean;
+        removeSuperfile?: boolean;
+    }
+    interface SuperfileActionResponse {
+        Exceptions: Exceptions;
+        superfile: string;
+        retcode: int;
+    }
+    interface SuperfileListRequest {
+        superfile?: string;
+    }
+    interface SuperfileListResponse {
+        Exceptions: Exceptions;
+        superfile: string;
+        subfiles: subfiles;
+    }
+}
+export declare class DfuServiceBase extends Service {
+    constructor(optsConnection: IOptions | IConnection);
+    Add(request: WsDfu.AddRequest): Promise<WsDfu.AddResponse>;
+    AddRemote(request: WsDfu.AddRemoteRequest): Promise<WsDfu.AddRemoteResponse>;
+    AddtoSuperfile(request: WsDfu.AddtoSuperfileRequest): Promise<WsDfu.AddtoSuperfileResponse>;
+    DFUArrayAction(request: WsDfu.DFUArrayActionRequest): Promise<WsDfu.DFUArrayActionResponse>;
+    DFUBrowseData(request: WsDfu.DFUBrowseDataRequest): Promise<WsDfu.DFUBrowseDataResponse>;
+    DFUDefFile(request: WsDfu.DFUDefFileRequest): Promise<WsDfu.DFUDefFileResponse>;
+    DFUFileAccess(request: WsDfu.DFUFileAccessRequest): Promise<WsDfu.DFUFileAccessResponse>;
+    DFUFileAccessV2(request: WsDfu.DFUFileAccessV2Request): Promise<WsDfu.DFUFileAccessResponse>;
+    DFUFileCreate(request: WsDfu.DFUFileCreateRequest): Promise<WsDfu.DFUFileCreateResponse>;
+    DFUFileCreateV2(request: WsDfu.DFUFileCreateV2Request): Promise<WsDfu.DFUFileCreateResponse>;
+    DFUFilePublish(request: WsDfu.DFUFilePublishRequest): Promise<WsDfu.DFUFilePublishResponse>;
+    DFUFileView(request: WsDfu.DFUFileViewRequest): Promise<WsDfu.DFUFileViewResponse>;
+    DFUGetDataColumns(request: WsDfu.DFUGetDataColumnsRequest): Promise<WsDfu.DFUGetDataColumnsResponse>;
+    DFUGetFileMetaData(request: WsDfu.DFUGetFileMetaDataRequest): Promise<WsDfu.DFUGetFileMetaDataResponse>;
+    DFUInfo(request: WsDfu.DFUInfoRequest): Promise<WsDfu.DFUInfoResponse>;
+    DFUQuery(request: WsDfu.DFUQueryRequest): Promise<WsDfu.DFUQueryResponse>;
+    DFURecordTypeInfo(request: WsDfu.DFURecordTypeInfoRequest): Promise<WsDfu.DFURecordTypeInfoResponse>;
+    DFUSearch(request: WsDfu.DFUSearchRequest): Promise<WsDfu.DFUSearchResponse>;
+    DFUSearchData(request: WsDfu.DFUSearchDataRequest): Promise<WsDfu.DFUSearchDataResponse>;
+    DFUSpace(request: WsDfu.DFUSpaceRequest): Promise<WsDfu.DFUSpaceResponse>;
+    EclRecordTypeInfo(request: WsDfu.EclRecordTypeInfoRequest): Promise<WsDfu.EclRecordTypeInfoResponse>;
+    EraseHistory(request: WsDfu.EraseHistoryRequest): Promise<WsDfu.EraseHistoryResponse>;
+    ListHistory(request: WsDfu.ListHistoryRequest): Promise<WsDfu.ListHistoryResponse>;
+    Ping(request: WsDfu.WsDfuPingRequest): Promise<WsDfu.WsDfuPingResponse>;
+    Savexml(request: WsDfu.SavexmlRequest): Promise<WsDfu.SavexmlResponse>;
+    SuperfileAction(request: WsDfu.SuperfileActionRequest): Promise<WsDfu.SuperfileActionResponse>;
+    SuperfileList(request: WsDfu.SuperfileListRequest): Promise<WsDfu.SuperfileListResponse>;
+}
+export {};
+//# sourceMappingURL=WsDfu.d.ts.map