import { DataItemModel, ModuleAutomation, Parameter } from '../../ModuleAutomation';
import { AML } from '@p2olab/pimad-types';
import { Backbone } from '../../Backbone';
import Attribute = AML.Attribute;
import PiMAdResponseVendor = Backbone.PiMAdResponseVendor;
import PiMAdResponse = Backbone.PiMAdResponse;
import DataAssembly = ModuleAutomation.DataAssembly;
declare abstract class AImporterPart implements ImporterPart {
    protected responseVendor: PiMAdResponseVendor;
    extract(data: object, callback: (response: PiMAdResponse) => void): void;
    /**
     * Extract a specific attribute from an Attribute Array. F.ex. the RefID-Attribute.
     * @param attributeName - The name of the attribute.
     * @param attributes - The attributes array.
     * @param callback - A callback function with an instance of the Response-Interface.
     */
    protected getAttribute(attributeName: string, attributes: Attribute[], callback: (response: PiMAdResponse) => void): void;
    constructor();
}
export declare class HMIPart extends AImporterPart {
}
/**
 * Handles the 'MTPPart' of a ModuleTypePackage file. This means CommunicationSet, HMISet, ServiceSet, ...
 */
export declare class MTPPart extends AImporterPart {
    private communicationInterfaceDataVendor;
    private dataAssemblyVendor;
    private baseDataItemFactory;
    /**
     * This method extracts data from the MTPPart of the ModuleTypePackage and converts it into different objects of the PiMAd-core-IM.
     *
     * Attention! Currently (31.07.2020) only data from the CommunicationSet is processed!
     *
     * <uml>
     *     skinparam shadowing false
     *     partition "extract" {
     *          start
     *          :extract communicationSet;
     *          if (extracted data is valid?) is (true)
     *              :callback the data\nwith SuccessResponse;
     *          else (false)
     *              :callback an\nErrorResponse;
     *          endif
     *          stop
     *     }
     * </uml>
     *
     * @param data - The bare ModuleTypePackage-object of the MTP. Containing a CommunicationSet, HMISet, ServiceSet and TextSet.
     * @param callback - A callback function with an instance of the Response-Interface. The type of the response-content-object-attribute data is {@link ExtractDataFromCommunicationSetResponseType}
     */
    extract(data: {
        CommunicationSet: object[];
        HMISet: object;
        ServiceSet: object;
        TextSet: object;
    }, callback: (response: PiMAdResponse) => void): void;
    private getRefBaseSystemUnitPathElement;
    /**
     * This method extracts data from the ModuleTypePackage-CommunicationSet, evaluates it and then transfers it to the
     * PiMAd-core internal data model. The following diagram visualizes the general method flow:
     *
     * <uml>
     *     skinparam shadowing false
     *     partition "extractDataFromCommunicationSet" {
     *     start
     *       :extract InstanceList & \nSourceList;
     *       if(extracted data seems valid) then (yes)
     *         :parsing SourceList;
     *         :parsing InstanceList;
     *         :CommunicationInterfaceData: communicationInterfaceData, \nDataAssemblies: dataAssemblies ]
     *         stop
     *       else (no)
     *       endif
     *       :CommunicationInterfaceData: [], \nDataAssemblies: [] ]
     *       stop
     *     }
     * </uml>
     *
     * The following activity diagram shows the detailed steps for parsing the SourceList:
     *
     * <uml>
     *     skinparam shadowing false
     *     partition "extractDataFromCommunicationSet:parsing-SourceList" {
     *       start
     *       while (more InternalElements?) is (true)
     *         if (element == OPCUAServer?) then (yes)
     *           :extract opcua-\nserver interface;
     *           :extract external interfaces;
     *          else (no)
     *            stop
     *          endif
     *       endwhile (no)
     *       stop
     *      }
     * </uml>
     *
     * The following activity diagram shows the detailed steps for parsing the InstanceList:
     *
     * <uml>
     *   skinparam shadowing false
     *   partition "buildCommunicationSet:parsing-InstanceList" {
     *     start
     *     while (more InternalElements\nin InstanceList?) is (true)
     *       :setup local\ndata storage;
     *       while (more Attributes\nin InternalElement?) is (true)
     *         if(attributeDataType == xs:IDREF)
     *           :merging attribute data\nwith external interface data;
     *           :initialize DataItemModel with\nmerged data and push\nit to the local storage;
     *         elseif (attributeDataType == xs:ID)
     *           :save the RefID as\nDataAssembly-Identifier;
     *         endif
     *       endwhile (no)
     *     :initialize DataAssembly with\nparsed data and push it\to the local storage;
     *     endwhile (no)
     *     stop
     *   }
     * </uml>
     *
     * @param communicationSet - The bare CommunicationSet-object of the MTP.
     */
    private extractDataFromCommunicationSet;
    constructor();
}
/**
 * Handles the 'ServicePart' of the ModuleTypePackage file.
 */
export declare class ServicePart extends AImporterPart {
    private baseProcedureFactory;
    /**
     * This method extracts data from the service part of the ModuleTypePackage and converts it into an intermediate
     * format very similar to the {@link Service} interface of the PiMAd core IM.
     *
     * <uml>
     *     skinparam shadowing false
     *     partition "extract" {
     *          start
     *          while (more services?) is (yes)
     *              :take the next service;
     *              :extract and store\nfirst level data of\nthe service;
     *              while (more InternalElements?) is (yes)
     *                  :take the next element;
     *                  if (element == ServiceProcedure) is (true)
     *                      :extract the data\nof the service procedure;
     *                      :push procedure to service;
     *                  else (no)
     *                      :Skipping this element;
     *                  endif
     *              endwhile (no)
     *              :push service to storage;
     *          endwhile (no)
     *          :callback the extracted\nservices with a\nSuccessResponse;
     *          stop
     *     }
     * </uml>
     *
     * @param data - All service data as object.
     * @param callback - A callback function with an instance of the Response-Interface.
     */
    extract(data: ServicePartExtractInputDataType, callback: (response: PiMAdResponse) => void): void;
    /**
     * Transforming AML-Attributes into AML-Attributes. Ignoring specific one. f. ex. RefID. Needs a Refactor -\> PiMAd
     * needs an attribute interface too!
     * @param attributes - The attributes array.
     * @param callback - A callback function with an instance of the Response-Interface.
     */
    private extractAttributes;
    constructor();
}
export declare class TextPart extends AImporterPart {
}
/**
 * Importers consist of individual parts that each extract specific sections of the information model.
 */
export interface ImporterPart {
    /**
     * Extracts data based on a specific information model and converts it into the internal data model of PiMAd.
     * @param data - The data source.
     * @param callback - Return the results via callback-function.
     */
    extract(data: object, callback: (response: PiMAdResponse) => void): void;
}
/**
 * Type of the object that is created by the method {@link extractDataFromCommunicationSet}
 */
export declare type ExtractDataFromCommunicationSetResponseType = {
    DataAssemblies: DataAssembly[];
    ServerCommunicationInterfaceData: DataItemModel[];
};
/**
 * Types the content object in the {@link SuccessResponse} from {@link ServicePart.extract}
 */
export declare type InternalServiceType = InternalProcedureType & {
    Procedures: InternalProcedureType[];
};
/**
 * Types the Procedures in {@link InternalServiceType}
 */
export declare type InternalProcedureType = {
    Attributes: Attribute[];
    DataAssembly: Attribute;
    Identifier: string;
    MetaModelRef: string;
    Name: string;
    Parameters: Parameter[];
};
/**
 * Types the object that the method {@link ServicePart.extract} expects as input.
 */
export declare type ServicePartExtractInputDataType = {
    Name: string;
    ID: string;
    Version: string;
    InternalElement: object[];
};
export {};