import { IConnection, IOptions } from "../../../../connection";
import { Service } from "../../../../espConnection";

export type base64Binary = string;
type long = number;
type int = number;
type double = number;

export enum DFUArrayActions {
    Delete = "Delete",
    AddToSuperfile = "AddToSuperfile",
    ChangeProtection = "ChangeProtection",
    ChangeRestriction = "ChangeRestriction"
}

export enum DFUChangeProtection {
    NoChange = 0,
    Protect = 1,
    Unprotect = 2,
    UnprotectAll = 3
}

export enum DFUChangeRestriction {
    NoChange = 0,
    Restrict = 1,
    Unrestricted = 2
}

export enum DFUDefFileFormat {
    Xml = "xml",
    Def = "def"
}

export enum FileAccessRole {
    Token = "Token",
    Engine = "Engine",
    External = "External"
}

export enum SecAccessType {
    None = "None",
    Access = "Access",
    Read = "Read",
    Write = "Write",
    Full = "Full"
}

export enum DFUFileType {
    Flat = "Flat",
    Index = "Index",
    Xml = "Xml",
    Csv = "Csv",
    Json = "Json",
    IndexLocal = "IndexLocal",
    IndexPartitioned = "IndexPartitioned",
    Unset = "Unset"
}

export namespace WsDfu {

    export interface AddRequest {
        dstname?: string;
        xmlmap?: base64Binary;
        dstcluster?: string;
    }

    export interface Exception {
        Code: string;
        Audience: string;
        Source: string;
        Message: string;
    }

    export interface Exceptions {
        Source: string;
        Exception: Exception[];
    }

    export interface AddResponse {
        Exceptions: {
            Source: string;
            Exception: Exception[];
        };
    }

    export interface AddRemoteRequest {
        dstname?: string;
        srcname?: string;
        srcdali?: string;
        srcusername?: string;
        srcpassword?: string;
    }

    export interface AddRemoteResponse {
        Exceptions: Exceptions;
    }

    export interface names {
        Item: string[];
    }

    export interface AddtoSuperfileRequest {
        Superfile?: string;
        Subfiles?: string;
        names?: {
            Item?: string[];
        };
        ExistingFile?: boolean;
        BackToPage?: string;
    }

    export interface SubfileNames {
        SubfileName: string[];
    }

    export interface AddtoSuperfileResponse {
        Exceptions: Exceptions;
        Subfiles: string;
        BackToPage: string;
        SubfileNames: {
            SubfileName: string[];
        };
    }

    export interface LogicalFiles {
        Item: string[];
    }

    export interface DFUArrayActionRequest {
        Type?: DFUArrayActions;
        NoDelete?: boolean;
        BackToPage?: string;
        LogicalFiles?: {
            Item?: string[];
        };
        removeFromSuperfiles?: boolean;
        removeRecursively?: boolean;
        Protect?: DFUChangeProtection;
        Restrict?: DFUChangeRestriction;
    }

    export interface DFUActionInfo {
        FileName: string;
        NodeGroup: string;
        ActionResult: string;
        Failed: boolean;
    }

    export interface ActionResults {
        DFUActionInfo: DFUActionInfo[];
    }

    export interface DFUArrayActionResponse {
        Exceptions: Exceptions;
        BackToPage: string;
        RedirectTo: string;
        ActionResults: {
            DFUActionInfo: DFUActionInfo[];
        };
    }

    export 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;
    }

    export interface DFUDataColumn {
        ColumnID: int;
        ColumnLabel: string;
        ColumnType: string;
        ColumnValue: string;
        ColumnSize: int;
        MaxSize: int;
        ColumnEclType: string;
        ColumnRawSize: int;
        IsNaturalColumn: boolean;
        IsKeyedColumn: boolean;
        DataColumns: DataColumns;
    }

    export interface DataColumns {
        DFUDataColumn: DFUDataColumn[];
    }

    export 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[];
        };
    }

    export interface ColumnsHidden {
        ColumnHidden: ColumnHidden[];
    }

    export 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;
    }

    export interface DFUDefFileRequest {
        Name?: string;
        Format?: DFUDefFileFormat;
    }

    export interface DFUDefFileResponse {
        Exceptions: Exceptions;
        defFile: base64Binary;
    }

    export interface RequestBase {
        Name: string;
        Cluster: string;
        JobId: string;
        ExpirySeconds: int;
        AccessRole: FileAccessRole;
        AccessType: SecAccessType;
        ReturnJsonTypeInfo: boolean;
        ReturnBinTypeInfo: boolean;
    }

    export interface DFUFileAccessRequest {
        RequestBase?: {
            Name?: string;
            Cluster?: string;
            JobId?: string;
            ExpirySeconds?: int;
            AccessRole?: FileAccessRole;
            AccessType?: SecAccessType;
            ReturnJsonTypeInfo?: boolean;
            ReturnBinTypeInfo?: boolean;
        };
    }

    export interface DFUPartLocation {
        LocationIndex: int;
        Host: string;
    }

    export interface FileLocations {
        DFUPartLocation: DFUPartLocation[];
    }

    export interface DFUFileCopy {
        CopyIndex: int;
        LocationIndex: int;
        Path: string;
    }

    export interface Copies {
        DFUFileCopy: DFUFileCopy[];
    }

    export interface DFUFilePart {
        PartIndex: int;
        Copies: {
            DFUFileCopy: DFUFileCopy[];
        };
        TopLevelKey: boolean;
    }

    export interface FileParts {
        DFUFilePart: DFUFilePart[];
    }

    export interface AccessInfo {
        MetaInfoBlob: string;
        ExpiryTime: string;
        NumParts: int;
        FileLocations: {
            DFUPartLocation: DFUPartLocation[];
        };
        FileParts: {
            DFUFilePart: DFUFilePart[];
        };
        RecordTypeInfoJson: string;
        fileAccessPort: int;
        fileAccessSSL: boolean;
    }

    export 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;
    }

    export interface DFUFileAccessV2Request {
        Name?: string;
        Cluster?: string;
        RequestId?: string;
        ExpirySeconds?: int;
        ReturnTextResponse?: boolean;
        SessionId?: long;
        LockTimeoutMs?: int;
    }

    export interface PartLocations {
        Item: string[];
    }

    export interface DFUFileCreateRequest {
        ECLRecordDefinition?: string;
        PartLocations?: {
            Item?: string[];
        };
        RequestBase?: RequestBase;
    }

    export interface DFUFileCreateResponse {
        Exceptions: Exceptions;
        FileId: string;
        Warning: string;
        AccessInfo: AccessInfo;
    }

    export interface DFUFileCreateV2Request {
        Name?: string;
        Cluster?: string;
        Type?: DFUFileType;
        ECLRecordDefinition?: string;
        RequestId?: string;
        ExpirySeconds?: int;
        ReturnTextResponse?: boolean;
        Compressed?: boolean;
        SessionId?: long;
        LockTimeoutMs?: int;
    }

    export interface DFUFilePublishRequest {
        FileId?: string;
        Overwrite?: boolean;
        FileDescriptorBlob?: base64Binary;
        SessionId?: long;
        LockTimeoutMs?: int;
        ECLRecordDefinition?: string;
        RecordCount?: long;
        FileSize?: long;
    }

    export interface DFUFilePublishResponse {
        Exceptions: Exceptions;
    }

    export interface DFUFileViewRequest {
        Scope?: string;
        IncludeSuperOwner?: boolean;
    }

    export 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;
    }

    export interface DFULogicalFiles {
        DFULogicalFile: DFULogicalFile[];
    }

    export interface DFUFileViewResponse {
        Exceptions: Exceptions;
        Scope: string;
        NumFiles: int;
        DFULogicalFiles: {
            DFULogicalFile: DFULogicalFile[];
        };
    }

    export interface DFUGetDataColumnsRequest {
        OpenLogicalName?: string;
        LogicalName?: string;
        FilterBy?: string;
        ShowColumns?: string;
        ChooseFile?: int;
        Cluster?: string;
        ClusterType?: string;
        StartIndex?: long;
        EndIndex?: long;
    }

    export interface DFUDataKeyedColumns1 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns2 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns3 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns4 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns5 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns6 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns7 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns8 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns9 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns10 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns11 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns12 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns13 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns14 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns15 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns16 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns17 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns18 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns19 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataKeyedColumns20 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns1 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns2 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns3 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns4 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns5 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns6 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns7 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns8 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns9 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns10 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns11 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns12 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns13 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns14 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns15 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns16 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns17 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns18 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns19 {
        DFUDataColumn: DFUDataColumn[];
    }

    export interface DFUDataNonKeyedColumns20 {
        DFUDataColumn: DFUDataColumn[];
    }

    export 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;
    }

    export interface DFUGetFileMetaDataRequest {
        LogicalFileName?: string;
        ClusterName?: string;
        IncludeXmlSchema?: boolean;
        AddHeaderInXmlSchema?: boolean;
        IncludeXmlXPathSchema?: boolean;
        AddHeaderInXmlXPathSchema?: boolean;
    }

    export interface DFUGetFileMetaDataResponse {
        Exceptions: Exceptions;
        TotalColumnCount: int;
        KeyedColumnCount: int;
        DataColumns: DataColumns;
        XmlSchema: string;
        XmlXPathSchema: string;
        TotalResultRows: long;
    }

    export interface DFUInfoRequest {
        Name?: string;
        Cluster?: string;
        UpdateDescription?: boolean;
        QuerySet?: string;
        Query?: string;
        FileDesc?: string;
        IncludeJsonTypeInfo?: boolean;
        IncludeBinTypeInfo?: boolean;
        Protect?: DFUChangeProtection;
        Restrict?: DFUChangeRestriction;
    }

    export interface Stat {
        MinSkew: string;
        MaxSkew: string;
        MinSkewInt64: long;
        MaxSkewInt64: long;
        MinSkewPart: long;
        MaxSkewPart: long;
    }

    export interface DFUPart {
        Id: int;
        Copy: int;
        Ip: string;
        Partsize: string;
        PartSizeInt64: long;
        CompressedSize: long;
    }

    export interface DFUFileParts {
        DFUPart: DFUPart[];
    }

    export interface DFUFilePartsOnCluster {
        Cluster: string;
        BaseDir: string;
        ReplicateDir: string;
        Replicate: boolean;
        CanReplicate: boolean;
        DFUFileParts: {
            DFUPart: DFUPart[];
        };
    }

    export interface DFUFilePartsOnClusters {
        DFUFilePartsOnCluster: DFUFilePartsOnCluster[];
    }

    export interface subfiles {
        Item: string[];
    }

    export interface Superfiles {
        DFULogicalFile: DFULogicalFile[];
    }

    export interface DFUFileProtect {
        Owner: string;
        Modified: string;
    }

    export interface ProtectList {
        DFUFileProtect: DFUFileProtect[];
    }

    export interface Graphs {
        ECLGraph: string[];
    }

    export interface FieldNames {
        Item: string[];
    }

    export interface Partition {
        FieldMask: long;
        FieldNames: {
            Item: string[];
        };
    }

    export interface DFUFileBloom {
        FieldMask: long;
        FieldNames: FieldNames;
        Limit: long;
        Probability: string;
    }

    export interface Blooms {
        DFUFileBloom: DFUFileBloom[];
    }

    export 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;
    }

    export 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;
        };
    }

    export 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;
    }

    export 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;
    }

    export interface DFURecordTypeInfoRequest {
        Name?: string;
        IncludeJsonTypeInfo?: boolean;
        IncludeBinTypeInfo?: boolean;
    }

    export interface DFURecordTypeInfoResponse {
        jsonInfo: string;
        binInfo: base64Binary;
    }

    export interface DFUSearchRequest {
        ShowExample?: string;
    }

    export interface ClusterNames {
        ClusterName: string[];
    }

    export interface FileTypes {
        FileType: string[];
    }

    export interface DFUSearchResponse {
        Exceptions: Exceptions;
        ShowExample: string;
        ClusterNames: {
            ClusterName: string[];
        };
        FileTypes: {
            FileType: string[];
        };
    }

    export 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;
    }

    export 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;
    }

    export interface DFUSpaceRequest {
        CountBy?: string;
        ScopeUnder?: string;
        OwnerUnder?: string;
        Interval?: string;
        StartDate?: string;
        EndDate?: string;
    }

    export 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;
    }

    export interface DFUSpaceItems {
        DFUSpaceItem: DFUSpaceItem[];
    }

    export interface DFUSpaceResponse {
        Exceptions: Exceptions;
        CountBy: string;
        ScopeUnder: string;
        OwnerUnder: string;
        Interval: string;
        StartDate: string;
        EndDate: string;
        DFUSpaceItems: {
            DFUSpaceItem: DFUSpaceItem[];
        };
    }

    export interface EclRecordTypeInfoRequest {
        Ecl?: string;
        IncludeJsonTypeInfo?: boolean;
        IncludeBinTypeInfo?: boolean;
    }

    export interface EclRecordTypeInfoResponse {
        jsonInfo: string;
        binInfo: base64Binary;
    }

    export interface EraseHistoryRequest {
        Name?: string;
    }

    export interface Origin {
        Name: string;
        Operation: string;
        Timestamp: string;
        IP: string;
        Path: string;
        Owner: string;
        Workunit: string;
    }

    export interface History {
        Origin: Origin[];
    }

    export interface EraseHistoryResponse {
        Exceptions: Exceptions;
        History: {
            Origin: Origin[];
        };
    }

    export interface ListHistoryRequest {
        Name?: string;
    }

    export interface ListHistoryResponse {
        Exceptions: Exceptions;
        History: History;
    }

    export interface WsDfuPingRequest {

    }

    export interface WsDfuPingResponse {

    }

    export interface SavexmlRequest {
        name?: string;
    }

    export interface SavexmlResponse {
        Exceptions: Exceptions;
        xmlmap: base64Binary;
    }

    export interface SuperfileActionRequest {
        action?: string;
        superfile?: string;
        subfiles?: subfiles;
        before?: string;
        delete?: boolean;
        removeSuperfile?: boolean;
    }

    export interface SuperfileActionResponse {
        Exceptions: Exceptions;
        superfile: string;
        retcode: int;
    }

    export interface SuperfileListRequest {
        superfile?: string;
    }

    export interface SuperfileListResponse {
        Exceptions: Exceptions;
        superfile: string;
        subfiles: subfiles;
    }

}

export class DfuServiceBase extends Service {

    constructor(optsConnection: IOptions | IConnection) {
        super(optsConnection, "WsDfu", "1.62");
    }

    Add(request: WsDfu.AddRequest): Promise<WsDfu.AddResponse> {
        return this._connection.send("Add", request);
    }

    AddRemote(request: WsDfu.AddRemoteRequest): Promise<WsDfu.AddRemoteResponse> {
        return this._connection.send("AddRemote", request);
    }

    AddtoSuperfile(request: WsDfu.AddtoSuperfileRequest): Promise<WsDfu.AddtoSuperfileResponse> {
        return this._connection.send("AddtoSuperfile", request);
    }

    DFUArrayAction(request: WsDfu.DFUArrayActionRequest): Promise<WsDfu.DFUArrayActionResponse> {
        return this._connection.send("DFUArrayAction", request);
    }

    DFUBrowseData(request: WsDfu.DFUBrowseDataRequest): Promise<WsDfu.DFUBrowseDataResponse> {
        return this._connection.send("DFUBrowseData", request);
    }

    DFUDefFile(request: WsDfu.DFUDefFileRequest): Promise<WsDfu.DFUDefFileResponse> {
        return this._connection.send("DFUDefFile", request);
    }

    DFUFileAccess(request: WsDfu.DFUFileAccessRequest): Promise<WsDfu.DFUFileAccessResponse> {
        return this._connection.send("DFUFileAccess", request);
    }

    DFUFileAccessV2(request: WsDfu.DFUFileAccessV2Request): Promise<WsDfu.DFUFileAccessResponse> {
        return this._connection.send("DFUFileAccessV2", request);
    }

    DFUFileCreate(request: WsDfu.DFUFileCreateRequest): Promise<WsDfu.DFUFileCreateResponse> {
        return this._connection.send("DFUFileCreate", request);
    }

    DFUFileCreateV2(request: WsDfu.DFUFileCreateV2Request): Promise<WsDfu.DFUFileCreateResponse> {
        return this._connection.send("DFUFileCreateV2", request);
    }

    DFUFilePublish(request: WsDfu.DFUFilePublishRequest): Promise<WsDfu.DFUFilePublishResponse> {
        return this._connection.send("DFUFilePublish", request);
    }

    DFUFileView(request: WsDfu.DFUFileViewRequest): Promise<WsDfu.DFUFileViewResponse> {
        return this._connection.send("DFUFileView", request);
    }

    DFUGetDataColumns(request: WsDfu.DFUGetDataColumnsRequest): Promise<WsDfu.DFUGetDataColumnsResponse> {
        return this._connection.send("DFUGetDataColumns", request);
    }

    DFUGetFileMetaData(request: WsDfu.DFUGetFileMetaDataRequest): Promise<WsDfu.DFUGetFileMetaDataResponse> {
        return this._connection.send("DFUGetFileMetaData", request);
    }

    DFUInfo(request: WsDfu.DFUInfoRequest): Promise<WsDfu.DFUInfoResponse> {
        return this._connection.send("DFUInfo", request);
    }

    DFUQuery(request: WsDfu.DFUQueryRequest): Promise<WsDfu.DFUQueryResponse> {
        return this._connection.send("DFUQuery", request);
    }

    DFURecordTypeInfo(request: WsDfu.DFURecordTypeInfoRequest): Promise<WsDfu.DFURecordTypeInfoResponse> {
        return this._connection.send("DFURecordTypeInfo", request);
    }

    DFUSearch(request: WsDfu.DFUSearchRequest): Promise<WsDfu.DFUSearchResponse> {
        return this._connection.send("DFUSearch", request);
    }

    DFUSearchData(request: WsDfu.DFUSearchDataRequest): Promise<WsDfu.DFUSearchDataResponse> {
        return this._connection.send("DFUSearchData", request);
    }

    DFUSpace(request: WsDfu.DFUSpaceRequest): Promise<WsDfu.DFUSpaceResponse> {
        return this._connection.send("DFUSpace", request);
    }

    EclRecordTypeInfo(request: WsDfu.EclRecordTypeInfoRequest): Promise<WsDfu.EclRecordTypeInfoResponse> {
        return this._connection.send("EclRecordTypeInfo", request);
    }

    EraseHistory(request: WsDfu.EraseHistoryRequest): Promise<WsDfu.EraseHistoryResponse> {
        return this._connection.send("EraseHistory", request);
    }

    ListHistory(request: WsDfu.ListHistoryRequest): Promise<WsDfu.ListHistoryResponse> {
        return this._connection.send("ListHistory", request);
    }

    Ping(request: WsDfu.WsDfuPingRequest): Promise<WsDfu.WsDfuPingResponse> {
        return this._connection.send("Ping", request);
    }

    Savexml(request: WsDfu.SavexmlRequest): Promise<WsDfu.SavexmlResponse> {
        return this._connection.send("Savexml", request);
    }

    SuperfileAction(request: WsDfu.SuperfileActionRequest): Promise<WsDfu.SuperfileActionResponse> {
        return this._connection.send("SuperfileAction", request);
    }

    SuperfileList(request: WsDfu.SuperfileListRequest): Promise<WsDfu.SuperfileListResponse> {
        return this._connection.send("SuperfileList", request);
    }

}