import { Auth } from '@genesislcap/foundation-comms';
import { Connect } from '@genesislcap/foundation-comms';
import { ElementStyles } from '@microsoft/fast-element';
import { GenesisElement } from '@genesislcap/web-core';
import { GridPro } from '@genesislcap/rapid-grid-pro';
import { GridProGenesisDatasource } from '@genesislcap/rapid-grid-pro';
import { InterfaceSymbol } from '@microsoft/fast-foundation';
import { Message } from '@genesislcap/foundation-comms';
import { Modal } from '@genesislcap/rapid-design-system';
import { PartialGenesisElementDefinition } from '@genesislcap/web-core';
import { SyntheticViewTemplate } from '@genesislcap/web-core';
import { Tabs } from '@genesislcap/web-core';
import { TemplateElementDependency } from '@genesislcap/web-core';
import { ViewTemplate } from '@microsoft/fast-element';

export declare type Configuration = {
    NAME?: string;
    RECONCILIATION_CONFIG_ID?: string;
    RECONCILIATION_STRATEGY?: string;
    DICTIONARY_ID?: string;
    RULES?: Array<ReconConfigurationRule>;
    DATASOURCES?: Array<Datasource>;
    MATCH_NULL?: boolean;
    PRIMARY_DATASOURCE_NAME?: string;
    PRIMARY_DATASOURCE?: string;
};

declare class ConfigurationDatasources extends GenesisElement {
    datasourceName: string;
    datasourceType: string;
    configurationMode: (typeof ConfigurationMode)[keyof typeof ConfigurationMode];
    dataPipeline: string;
    dataPipelineList: any[];
    datasourceConfigurations: Datasource;
    showAddButton: boolean;
    connectedCallback(): void;
    addDataSource(datasourceType: DatasourceType): void;
    setDatasource(datasource: Datasource): void;
    setDefaultDatasource(name: string): void;
    getDatasource(index: any): {
        NAME: string;
        TYPE: string;
        CONFIG_DATA: string;
    };
    reset(): void;
}

declare const ConfigurationMode: {
    readonly CREATE: "create";
    readonly EDIT: "edit";
};

declare class ConfigurationsPanel extends GenesisElement {
    reconciliationConfigurationService: ReconciliationConfigurationService;
    dataDictionaryService: DataDictionaryService;
    configurations: Array<Configuration>;
    datasources: Array<DatasourceEdit>;
    dataDictionaries: Array<DataDictionary>;
    selectedConfiguration: Configuration;
    configurationName: string;
    reconciliationFrequency: string;
    reconciliationStrategy: string;
    dataDictionaryId: string;
    configurationMode: (typeof ConfigurationMode)[keyof typeof ConfigurationMode];
    showConfigurationDetails: boolean;
    matchNull: boolean;
    reconRules: Array<ReconConfigurationRule>;
    dataDictionaryFields: Array<DataDictionaryField>;
    filteredRuleFields: Array<DataDictionaryField>;
    firstDatasource: ConfigurationDatasources;
    secondDatasource: ConfigurationDatasources;
    primaryDatasource: string;
    dataPipelineList: any[];
    connectedCallback(): Promise<void>;
    setConfigurations(): Promise<void>;
    setDataPipelines(): Promise<void>;
    setDataDictionaries(): Promise<void>;
    dataDictionaryChanged(): Promise<void>;
    addConfiguration(): void;
    resetDatasources(): void;
    reset(): void;
    selectConfiguration(configuration: Configuration): Promise<void>;
    deleteConfiguration(index: number): void;
    isEditingDatasourceName: boolean;
    addDataSource(datasource: Datasource): void;
    deleteDataSource(index: number): void;
    setDatasources(): void;
    transformDatasources(): {
        INDEX: number;
        IS_EDITING: boolean;
        NAME: string;
        TYPE: DatasourceType;
        CONFIG_DATA?: string;
    }[];
    validateDatasources(): boolean;
    validateConfiguration(): any[];
    saveConfiguration(): void;
    validateResponse(response: any): Promise<void>;
    addReconRule(rule: any): void;
    filterReconRuleFields(): void;
    removeRule(index: any): void;
    updateRule(rule: any, index: any): void;
    clearReconciliationRules(): void;
    onPrimaryDatasourceChange: (selection: any) => void;
    datasourceNameChanged(evt: any, index: any): void;
    clearDatasources(): void;
    reconStrategyChanged(): void;
}

export declare function configure(config: Partial<ReconciliationConfig>): Promise<FoundationReconciliation>;

declare class DataDictionaries extends GenesisElement {
    dataDictionaryService: DataDictionaryService;
    operation: DataDictionaryOperation;
    dictionaries: Array<DataDictionary>;
    dictionarySelected: DataDictionary;
    dictionaryName: string;
    fieldName: string;
    fieldType: string;
    gridOptions: {};
    fields: any[];
    grid: GridPro;
    connectedCallback(): Promise<void>;
    createDataDictionary(): void;
    editDataDictionary(dataDictionary: DataDictionary): Promise<void>;
    setGridOptions(data: any): void;
    deleteDataDictionary(index: number): Promise<void>;
    clear(): void;
    executeDeleteDictionary(index: any): Promise<void>;
    addField(): void;
    private editRow;
    removeRowEvent(params: any): void;
    setGridRows(rows: any): void;
    clearFields(): void;
    close(): void;
    submit(): Promise<void>;
    validateResponse(response: any): Promise<void>;
}

export declare type DataDictionary = {
    DICTIONARY_ID: string;
    DICTIONARY_NAME: string;
};

declare type DataDictionaryField = {
    DICTIONARY_ID?: string;
    FIELD_NAME?: string;
    FIELD_TYPE?: FieldType;
};

declare enum DataDictionaryOperation {
    CREATE = "CREATE",
    UPDATE = "UPDATE",
    DELETE = "DELETE"
}

declare interface DataDictionaryService {
    getDataDictionaries(): any;
    createDataDictionary(dataDictionary: any): any;
    editDataDictionary(dataDictionary: any): any;
    deleteDataDictionary(dataDictionary: any): any;
    getDataDictionaryFields(dataDictionaryId: any): any;
}

declare const DataDictionaryService: InterfaceSymbol<DataDictionaryService>;

export declare type Datasource = {
    NAME: string;
    TYPE: DatasourceType;
    CONFIG_DATA?: string;
};

declare type DatasourceConfiguration = {
    NAME: string;
    RECONCILIATION_CONFIG_ID: string;
    INPUT_PARAMETER?: any;
    TYPE?: string;
    CONFIG_DATA?: string;
    INDEX?: number;
    RECORD_ID?: number;
    TIMESTAMP?: number;
};

declare type DatasourceEdit = {
    IS_EDITING: boolean;
} & Datasource;

export declare enum DatasourceType {
    FILE = "FILE",
    PIPELINE = "PIPELINE"
}

export declare const defaultReconciliationConfig: ReconciliationConfig;

declare enum FieldType {
    STRING = "STRING",
    SHORT = "SHORT",
    INT = "INT",
    LONG = "LONG",
    DOUBLE = "DOUBLE",
    RAW = "RAW",
    BOOLEAN = "BOOLEAN",
    BIGDECIMAL = "BIGDECIMAL",
    DATETIME = "DATETIME",
    DATE = "DATE",
    NANO_TIMESTAMP = "NANO_TIMESTAMP"
}

export declare class FoundationReconciliation extends GenesisElement {
    ready: boolean;
    selectedTab: ReconciliationTab;
    dataDictionaries: DataDictionaries;
    configurationsPanel: ConfigurationsPanel;
    reconciliationsPanel: ReconciliationsPanel;
    connectedCallback(): Promise<void>;
    tabChanged(tab: ReconciliationTab): Promise<void>;
}

export declare const FoundationReconciliationStyles: ElementStyles;

export declare const FoundationReconciliationTemplate: ViewTemplate<FoundationReconciliation, any>;

export declare class RapidReconciliation extends FoundationReconciliation {
    connectedCallback(): Promise<void>;
    protected loadRemotes(): Promise<void>;
}

export declare class Reconciliation extends ZeroReconciliation {
}

declare type Reconciliation_2 = {
    RECONCILIATION_ID?: string;
    RECONCILIATION_NAME?: string;
    STATUS?: ReconciliationStatus;
    DATETIME?: number;
    INPUT_PARAMETERS?: string;
    RECONCILIATION_CONFIG_ID?: string;
    iconName?: string;
    iconClass?: string;
};

export declare interface ReconciliationConfig extends PartialGenesisElementDefinition {
    templateOptions: TemplateOptions;
    designSystemPrefix: string;
}

export declare const ReconciliationConfig: InterfaceSymbol<ReconciliationConfig>;

declare interface ReconciliationConfigurationService {
    getReconciliationConfigurations(): Promise<any>;
    getReconciliationConfigurationDetails(configurationId: string): Promise<any>;
    getReconciliationConfigurationRules(configurationId: string): Promise<any>;
    getReconciliationDatasourceConfiguration(configurationId: string): Promise<Array<any>>;
    getReconciliationDataPipelines(): Promise<any>;
    createReconciliationConfiguration(configuration: any): Promise<Message>;
    updateReconciliationConfiguration(configuration: any): Promise<Message>;
    deleteReconciliationConfiguration(configurationId: string): void;
}

declare const ReconciliationConfigurationService: InterfaceSymbol<ReconciliationConfigurationService>;

declare enum ReconciliationOperation {
    NEW = "NEW",
    HISTORICAL = "HISTORICAL"
}

export declare class ReconciliationSandbox extends GenesisElement {
    connect: Connect;
    auth: Auth;
    ready: boolean;
    connectedCallback(): Promise<void>;
}

declare interface ReconciliationService {
    getReconciliations(): any;
    runReconciliation(reconciliationInsert: any): any;
    stopReconciliation(reconciliationId: string): any;
    getReconciliationRecordResult(reconciliationRecordResultId: string): any;
    updateReconciliationRecordComment(reconciliationRecordResultId: string, text: string): any;
    getReconciliationDatasourcePairs(reconciliationRecordResultId: string): any;
    getReconciliationRecordResults(criteria?: string): any;
}

declare const ReconciliationService: InterfaceSymbol<ReconciliationService>;

declare class ReconciliationsPanel extends GenesisElement {
    reconciliationConfigurationService: ReconciliationConfigurationService;
    reconciliationService: ReconciliationService;
    toggleTodaysReconciliations: boolean;
    togglePreviousReconciliations: boolean;
    reconciliationsInProgress: Array<Reconciliation_2>;
    historicalReconciliationsToday: Array<Reconciliation_2>;
    historicalReconciliationsTodayFiltered: Array<Reconciliation_2>;
    historicalReconciliationsPrevious: Array<Reconciliation_2>;
    historicalReconciliationsPreviousFiltered: Array<Reconciliation_2>;
    datasourceConfigurations: Array<DatasourceConfiguration>;
    reconciliationConfigurations: any;
    reconciliationConfiguration: string;
    reconciliationName: string;
    reconciliation: any;
    private generatedReconciliationId;
    lockInputParameters: boolean;
    runReconciliationButtonDisable: boolean;
    matchedTabCriteria: string;
    breaksTabCriteria: string;
    filterType: string;
    textFilter: string;
    dateFilter: string;
    files: Map<string, any>;
    reconciliationSubscription: any;
    resultDetails: ResultDetails;
    allBreaksDatasource: GridProGenesisDatasource;
    allMatchedDatasource: GridProGenesisDatasource;
    selectedTab: ReconciliationsTab;
    datasourcePairs: Map<string, any>;
    viewDatasourcePairValue: string;
    datasourcePairsItemsOptions: ViewTemplate<any, any>;
    tabs: Tabs;
    connectedCallback(): Promise<void>;
    setReconciliationConfigurations(): Promise<void>;
    disconnectedCallback(): void;
    reconciliationConfigurationChanged(oldValue: any, newValue: any): Promise<void>;
    getReconciliations(): void;
    reloadView(reconciliation: any): Promise<void>;
    filterAndSortReconciliations(reconciliations: any): void;
    filterHistoricalReconciliations(remainingStatuses: Array<Reconciliation_2>): void;
    filterTypeChanged(): void;
    selectReconciliation(reconciliation: Reconciliation_2): Promise<void>;
    newReconciliation(): Promise<void>;
    runReconciliation(): Promise<void>;
    downloadReconciliationReport(): void;
    fileUploaded(datasourceNameAndFileInfo: any): void;
    clearFields(): Promise<void>;
    stopReconciliation(evt: CustomEvent, reconciliationId: string): Promise<void>;
    openResultDetails(params: any): void;
    clearFilters(): void;
    filterByName(evt: any): void;
    filterByDate(evt: any): void;
    reloadDatasource(datasource: GridProGenesisDatasource, operation: ReconciliationOperation): void;
    reconciliationsTabChanged(reconciliationsTab: ReconciliationsTab): void;
    changeViewSelect(): Promise<void>;
    populateDatasourcePairItemsOptions(): void;
    getDatasourcePairs(reconciliationId: any): Promise<void>;
    private reloadGridsAndCriterias;
}

declare enum ReconciliationsTab {
    ALL_BREAKS = 0,
    ALL_MATCHED = 1
}

declare enum ReconciliationStatus {
    IN_PROGRESS = "IN_PROGRESS",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    CANCELLED = "CANCELLED"
}

export declare enum ReconciliationTab {
    Configurations = "CONFIGURATIONS",
    Reconciliations = "RECONCILIATIONS",
    DataDictionariesTab = "DATA_DICTIONARIES"
}

export declare type ReconConfigurationRule = {
    RECONCILIATION_CONFIG_ID?: string;
    FIELD_TYPE: FieldType;
    FIELD_NAME: string;
    TOLERANCE_TYPE: ToleranceType;
    TOLERANCE_VALUE: string;
    IS_MATCH_KEY: boolean;
};

declare type RecordInformation = {
    datasources: RecordInformationField;
    fields: RecordInformationField & {
        result?: string;
    }[];
    primaryKeyResult: RecordInformationField;
    comparisonResult: RecordInformationField;
    missingInDictionaryFields: RecordInformationField[];
    noRuleConfiguredFields: RecordInformationField[];
};

declare type RecordInformationField = {
    fieldName: string;
    firstValue: string;
    secondValue: string;
};

declare class ResultDetails extends GenesisElement {
    reconciliationService: ReconciliationService;
    recordInformation: RecordInformation;
    commentText: string;
    commentedBy: string;
    commentTimestamp: any;
    reconciliationRecordResultId: string;
    fields: RecordInformationField[];
    modal: Modal;
    open(reconciliationRecordResultId: string, datasourceConfigurations: any, comment: any): Promise<void>;
    close(): void;
    createRecordInformation(reconciliationRecordResultId: any, datasourceConfigurations: any): Promise<{
        datasources: {
            fieldName: string;
            firstValue: any;
            secondValue: any;
        };
        fields: any;
        primaryKeyResult: {
            fieldName: string;
            firstValue: any;
            secondValue: any;
        };
        comparisonResult: {
            fieldName: string;
            firstValue: any;
            secondValue: any;
        };
        missingInDictionaryFields: any;
        noRuleConfiguredFields: any;
    }>;
    getFields(reconciliationRecordPairResult: any, resultType: string[]): any;
    isEmpty(value: any): boolean;
    get columns(): any[];
    saveComment(): void;
    validateResponse(response: any): Promise<void>;
    private createSingleRow;
    private createFieldsRows;
    applyStyle(attribute: any, propertyName?: any): "" | "red" | "green" | "amber";
    modalBackdropClickHandler(modal: any, closeEvent: any): void;
}

declare type TemplateComponents = {
    badge: TemplateElementDependency;
    button: TemplateElementDependency;
    divider: TemplateElementDependency;
    grid: TemplateElementDependency;
    icon: TemplateElementDependency;
    option: TemplateElementDependency;
    progress: TemplateElementDependency;
    progressRing: TemplateElementDependency;
    textField: TemplateElementDependency;
    select: TemplateElementDependency;
    segmentedControl: TemplateElementDependency;
    segmentedItem: TemplateElementDependency;
    tabs: TemplateElementDependency;
    tab: TemplateElementDependency;
    tabPanel: TemplateElementDependency;
    numberField: TemplateElementDependency;
    checkbox: TemplateElementDependency;
    switch: TemplateElementDependency;
    modal: TemplateElementDependency;
    dialog: TemplateElementDependency;
    toast: TemplateElementDependency;
    datePicker: TemplateElementDependency;
    textArea: TemplateElementDependency;
    radio: TemplateElementDependency;
    radioGroup: TemplateElementDependency;
};

declare type TemplateOptions = Partial<TemplateComponents> & {
    somePartial?: string | SyntheticViewTemplate;
};

declare enum ToleranceType {
    ABSOLUTE = "ABSOLUTE",
    PERCENTAGE = "PERCENTAGE",
    EQUALITY = "EQUALITY",
    DAYS = "DAYS",
    MINUTES = "MINUTES"
}

export declare interface UploadedEventDetail {
    DATASOURCE_CONFIG_NAME: string;
    FILE_INFO: {
        FILE_STORAGE_ID: string;
        FILE_NAME: string;
    };
}

export declare class ZeroReconciliation extends FoundationReconciliation {
    connectedCallback(): Promise<void>;
    protected loadRemotes(): Promise<void>;
}

export { }