/** @packageDocumentation
 * Port Basiskomponente, von der alle Ports abgeleitet sind.
 * Ports sind Verbindungskomponenten zu externen Cloud-Diensten.
 *
 * Letzte Aenderung: 16.02.2022
 * Status: rot
 *
 * @module core/port
 * @author SB
 */
import { SpeechErrorFunc } from '../interface/speech-function.type';
import { ErrorBase } from '../error/error-base';
import { EventFunc } from './../event/event-function.type';
import { IPort, PortEventFunc } from './port.interface';
/**
 * Definiert die Basisklasse aller Ports
 */
export declare class Port extends ErrorBase implements IPort {
    protected mPortName: string;
    protected mPluginName: string;
    private mInitEvent;
    private mOpenEvent;
    private mCloseEvent;
    private mStartEvent;
    private mStopEvent;
    private mStartAudioEvent;
    private mStopAudioEvent;
    private mResultEvent;
    private mErrorEvent;
    private mInitFlag;
    private mOpenFlag;
    private mRunFlag;
    /**
     * Erzeugt eine Instanz von Port.
     *
     * @param aPortName - Instanz-Name des Ports
     * @param aRegisterFlag - true, wenn Port in PortManager eingetragen werden soll
     */
    constructor(aPortName: string, aRegisterFlag?: boolean);
    /**
     * pruefen auf Mock-Port zum Testen
     *
     * @return {boolean} mockFlag - true, wenn Port ein Mock zum Testen ist
     */
    isMock(): boolean;
    /**
     * Rueckgabe eines logischen Port-Typs
     *
     * @return {string} logischer Typ des Ports fuer unterschiedliche Anwendungsschnittstellen
     */
    getType(): string;
    /**
     * Rueckgabe der Port-Klasse
     *
     * @return {string} konkrete Klasse des Ports
     */
    getClass(): string;
    /**
     * Rueckgabe des Port-Namens
     *
     * @return {string} Port-Namens, wie er vom PortManager verwendet wird
     */
    getName(): string;
    getVersion(): string;
    /**
     * initialisert den Port
     *
     * erlaubte optionale Parameter:
     *
     *      errorOutputFlag - legt fest, ob die Fehlerausgabe auf der Konsole erfolgt
     *
     *
     * @param {any} aOption - optionale Parameter fuer die Konfiguration des Plugins
     *
     * @return {number} errorCode (0,-1) - Fehlercode
     */
    init(aOption?: any): number;
    /**
     * gibt den Port frei
     *
     * @return {number} errorCode (0,-1) - Fehlercode
     */
    done(): number;
    /**
     * setzt den Port wieder auf Defaultwerte und uebergebene optionale Parameter.
     * Die Fehlerausgabe wird nicht zurueckgesetzt.
     *
     * @param {any} aOption - optionale Parameter
     *
     * @return {number} errorCode (0,-1) - Fehlercode
     */
    reset(aOption?: any): number;
    /**
     * pruefen auf initialisertes Port
     *
     * @return {boolean} true, Port ist initialisiert, false sonst
     */
    isInit(): boolean;
    /**
     * pruefen auf Server-Verbindung
     *
     * @return {boolean} true, Port hat Server-Verbindung, false sonst
     */
    isServer(): boolean;
    /**
     * internes loeschen des Init-Flags, falls Init abgebrochen werden muss
     *
     * @protected
     */
    protected _clearInit(): void;
    /**
     * Rueckgabe der internen Fehlerfunktion fuer innere Klassen
     *
     * @private
     * @return {SpeechErrorFunc} Rueckgabe der Fehlerfunktion fuer ErrorBase
     * @memberof Plugin
     */
    protected _getErrorOutputFunc(): SpeechErrorFunc;
    /**
     * Fehlerausgabe ueber die Konsole ein/ausschalten
     *
     * @protected
     * @param {boolean} aErrorOutputFlag - True, wenn Konsolenausgabe ein
     */
    setErrorOutput(aErrorOutputFlag: boolean): void;
    /**
     * Ereignisfunktion fuer Init aufrufen
     *
     * @private
     * @param {number} aResult - Fehlercode 0 oder -1 von init()
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onInit(aResult: number): number;
    /**
     * Ereignisfunktion fuer Open aufrufen
     *
     * @private
     * @return {number} errorCode(0,-1)
     */
    protected _onOpen(): number;
    /**
     * Ereignisfunktion fuer Close aufrufen
     *
     * @private
     * @return {number} errorCode(0,-1)
     */
    protected _onClose(): number;
    /**
     * Ereignisfunktion fuer Start aufrufen
     *
     * @private
     * @param {string} aDest - Ziel der Operation
     * @param {string} aType - Typ der Operation
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onStart(aDest?: string, aType?: string): number;
    /**
     * Ereignisfunktion fuer Stop aufrufen
     *
     * @private
     * @param {string} aDest - Ziel der Operation
     * @param {string} aType - Typ der Operation
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onStop(aDest?: string, aType?: string): number;
    /**
     * Ereignisfunktion fuer StartAudio aufrufen
     *
     * @private
     * @param {string} aDest - Ziel der Operation
     * @param {string} aType - Typ der Operation
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onStartAudio(aDest?: string, aType?: string): number;
    /**
     * Ereignisfunktion fuer StopAudio aufrufen
     *
     * @private
     * @param {string} aDest - Ziel der Operation
     * @param {string} aType - Typ der Operation
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onStopAudio(aDest?: string, aType?: string): number;
    /**
     * Ereignisfunktion fuer Result aufrufen
     *
     * @private
     * @param {*} aResult - Ergebnisdaten
     * @param {string} aDest - Ziel der Operation
     * @param {string} aType - Typ des Ergebnisses
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onResult(aResultData: any, aDest?: string, aType?: string): number;
    /**
     * Ereignisfunktion fuer Fehler aufrufen
     *
     * @private
     * @param {any} aError - Error Datentransferobjekt
     * @param {string} aDest - Ziel der Operation
     * @param {string} aType - Typ des Fehlers
     *
     * @return {number} errorCode(0,-1)
     */
    protected _onError(aError: any, aDest?: string, aType?: string): number;
    addInitEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addOpenEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addCloseEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addStartEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addStopEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addStartAudioEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addStopAudioEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addResultEvent(aPluginName: string, aEventFunc: PortEventFunc): number;
    addErrorEvent(aPluginName: string, aEventFunc: EventFunc): number;
    removeInitEvent(aPluginName: string): number;
    removeOpenEvent(aPluginName: string): number;
    removeCloseEvent(aPluginName: string): number;
    removeStartEvent(aPluginName: string): number;
    removeStopEvent(aPluginName: string): number;
    removeStartAudioEvent(aPluginName: string): number;
    removeStopAudioEvent(aPluginName: string): number;
    removeResultEvent(aPluginName: string): number;
    removeErrorEvent(aPluginName: string): number;
    removeAllEvent(aPluginName: string): number;
    /**
     * Dynamische Konfiguration des Ports
     *
     * @param {any} aConfigData - Konfigurationsdaten
     *
     * @return {number} Fehlercode 0 oder -1
     */
    setConfig(aConfigData: any): number;
    /**
     * Rueckgabe der aktuellen Port-Konfiguration
     *
     * @return {any} aktuelle Portkonfigurationsdaten
     */
    getConfig(): any;
    /**
     * Pruefen auf geoeffneten Port
     *
     * @return {boolean} True, wenn Port offen ist, False sonst
     */
    isOpen(): boolean;
    /**
     * Port oeffnen
     *
     * @param {*} aOption - optionale Parameter
     * @return {number} Fehlercode 0 oder -1
     */
    open(aOption?: any): number;
    /**
     * Port schliessen
     *
     * @return {number} Fehlercode 0 oder -1
     */
    close(): number;
    /**
     * Rueckgabe des Pluginnamens, der gerade eine Transaktion ausfuehrt
     *
     * @return {string} PluginName oder leerer String
     */
    getPluginName(): string;
    /**
     * Rueckgabe des Aktionsnames, der gerade eine Transaktion ausfuehrt
     *
     * @return {string} ActionName oder leerer String
     */
    getActionName(): string;
    /**
     * Pruefen, ob Port eine Aufgabe ausfuehrt, zu einem bestimmten Plugin
     * und zu einer bestimmten Aufgabe.
     *
     * @param {string} aPluginName - optionaler Pluginname
     * @param {string} aAction - optionaler Aktionsname
     *
     * @return {boolean} True, wenn Port beschaeftigt ist, False sonst
     */
    isRunning(aPluginName?: string, aAction?: string): boolean;
    /**
     * Pruefen, ob eine Aktion im Port ausgefuehrt werden kann oder nicht.
     *
     * @param {string} aAction - Name der zu pruefenden Aktion
     *
     * @returns {boolean} True, wenn Aktion ausfuehrbar ist, False sonst
     */
    isAction(aAction?: string): boolean;
    /**
     * Dient zum Setzen eines Timeouts, um Aktionen abzubrechen.
     * Bei Timeout 0 wird kein Timeout gesetzt.
     *
     * @param aTimeout - Zeit in Millisekunden bis die Aktion abgebrochen wird
     */
    setActionTimeout(aTimeout: number): void;
    /**
     * Portaktion starten
     *
     * @param {string} aPluginName - Name des Aufrufers der Transaktion
     * @param {string} aAction - optional auszufuehrende Aktion
     * @param {*} aOption - optionale Parameter
     *
     * @return {number} Fehlercode 0 oder -1
     */
    start(aPluginName: string, aAction?: string, aOption?: any): number;
    /**
     * Portaktion beenden
     *
     * @param {string} aPluginName - Name des Aufrufers der Transaktion
     * @param {string} aAction - optional zu beendende Aktion
     * @param {*} aOption - optionale Parameter
     *
     * @return {number} Fehlercode 0 oder -1
     */
    stop(aPluginName: string, aAction?: string, aOption?: any): number;
    /**
     * Fuehrt Testkommandos aus, um interne Tests ablaufen lassen zu koennen
     *
     * @param {string} aPluginName - Name des Aufrufers der Transaktion
     * @param {string} aTestCommand - Testkommando
     * @param {*} aTestData - optionale Testdaten
     *
     * @return {*} Rueckgabe der Testergebnisse
     */
    test(aPluginName: string, aTestCommand: string, aTestData?: any): any;
}