import * as i0 from '@angular/core';
import { EventEmitter, ElementRef, OnInit, OnChanges, ChangeDetectorRef, OnDestroy, DestroyRef, SimpleChanges, QueryList, Injector } from '@angular/core';
import * as _c8y_client from '@c8y/client';
import { FetchClient, InventoryService, IFetchResponse, IOperation, OperationService, IManagedObject } from '@c8y/client';
import { Observable, BehaviorSubject, Subscription } from 'rxjs';
import * as i5 from '@angular/router';
import { Router } from '@angular/router';
import * as i1 from '@c8y/ngx-components';
import { AlertService, ContextRouteComponent, DropAreaComponent, ModalService, DroppedFile, OperationRealtimeService, AppStateService } from '@c8y/ngx-components';
import * as i2 from '@angular/forms';
import { Validator, AbstractControl, FormGroup, NgForm, NgModelGroup } from '@angular/forms';
import * as i3 from 'ngx-bootstrap/buttons';
import * as i4 from '@angular/cdk/tree';
import { NestedTreeControl } from '@angular/cdk/tree';
import * as i6 from 'ngx-bootstrap/tooltip';
import * as i7 from 'ngx-bootstrap/popover';
import * as i8 from '@c8y/ngx-components/operations/operation-details';
import * as i9 from '@angular/platform-browser/animations';
import * as i10 from 'ngx-bootstrap/collapse';
import * as i11 from 'ngx-bootstrap/dropdown';
import * as i12 from '@c8y/ngx-components/device-protocol-object-mappings';
import { BaseObjectMapping, MeasurementObjectMapping, EventObjectMapping, AlarmObjectMapping } from '@c8y/ngx-components/device-protocol-object-mappings';
import * as packages_client_lib from 'packages/client/lib';
import { TranslateService } from '@ngx-translate/core';
import { FormlyFieldConfig } from '@ngx-formly/core';
import { CollectionViewer, SelectionChange } from '@angular/cdk/collections';
import { UpgradeComponent } from '@angular/upgrade/static';

declare class AddressSpaceService {
    private nodeNavigationData$;
    private client;
    private microserviceUrl;
    private header;
    constructor(fetchClient: FetchClient);
    resetTreeToRootNode(): void;
    triggerNodeToOpen(nodeNavigationData: NodeNavigationData): void;
    getNodeNavData$(): Observable<NodeNavigationData>;
    getNode(serverId: string, nodeId?: string): Promise<_c8y_client.IFetchResponse>;
    getRootNode(serverId: string): Promise<_c8y_client.IFetchResponse>;
    getNodeById(serverId: string, nodeId: string): Promise<_c8y_client.IFetchResponse>;
    getChildrenOf(node: AddressSpaceNode, serverId: string): Promise<_c8y_client.IFetchResponse>;
    childrenAvailable(nodeReferences: AdressSpaceNodeReference[]): boolean;
    getSearchedNodes(searchKey: string, serverId: string): Promise<any>;
    getIcon(nodeClassName: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddressSpaceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddressSpaceService>;
}
interface AddressSpaceNode {
    nodeId: string;
    currentlyLoadingChildren?: boolean;
    nodeClass?: number;
    nodeClassName?: string;
    browseName?: string;
    displayName?: string;
    description?: any;
    references?: AdressSpaceNodeReference[];
    ancestorNodeIds?: [string[]];
    children: AddressSpaceNode[];
    expanded: boolean;
    absolutePaths: [string[]];
    relativePath?: string[];
    parentNode?: AddressSpaceNode;
}
interface AdressSpaceNodeReference {
    referenceId: string;
    targetId: string;
    inverse: boolean;
    hierarchical: boolean;
}
interface SearchedNode {
    absolutePath: string[];
    ancestorNodeIds: [string[]];
    displayName: string;
    nodeClassName: string;
    nodeId: string;
}
interface NodeNavigationData {
    node: AddressSpaceNode;
    selectedAncestorIds: string[];
}

declare class OpcuaAddressSpaceDetailComponent {
    private addressSpaceService;
    set node(n: any);
    nodeDataAttr: Map<string, string>;
    nodeDataRef: object[];
    selected: boolean;
    showDetails: boolean;
    toggleAttrDetail: EventEmitter<AddressSpaceNode>;
    private _node;
    constructor(addressSpaceService: AddressSpaceService);
    setNodeData(nodeData: any): void;
    toggleDetail(node: any): void;
    navigateTo(ancestors: string[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaAddressSpaceDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaAddressSpaceDetailComponent, "opcua-address-space-detail", never, { "node": { "alias": "node"; "required": false; }; }, { "toggleAttrDetail": "toggleAttrDetail"; }, never, never, true, never>;
}

declare const NEW_SERVER_ID = "new";
interface OpcuaServer {
    name: string;
    id: string;
    gatewayId?: string;
    subtitle?: string;
    connectionStatus?: any;
    enabeled?: any;
    config: OpcuaServerConfig;
    quickInfo?: {
        padlock?: string;
        padlockMsg?: string;
    };
    active: true | false;
}
interface OpcuaServerConfig {
    securityMode: string;
    keystorePass?: any;
    keystoreFilename?: string;
    keystoreBinaryId?: any;
    certificatePass?: any;
    userIdentityMode?: string;
    serverUrl?: string;
    userName?: string;
    userPassword?: string;
    passwordEncrypted?: boolean;
    rescanCron?: any;
    timeout?: number;
    autoReconnect?: boolean;
    targetConnectionState?: 'enabled' | 'disabled' | null;
    statusCheckInterval?: number;
    valid?: boolean;
    autoScanAddressSpace?: boolean;
    partialAddressScanNodeIds?: Array<string>;
    partialAddressScan?: boolean;
}

declare class OpcuaService {
    private client;
    private inventoryService;
    private router;
    private alertService;
    private binaryService;
    private microserviceUrlDepr;
    private microserviceUrl;
    private deviceTypeProtocolUrl;
    private header;
    constructor(client: FetchClient, inventoryService: InventoryService, router: Router, alertService: AlertService);
    createServer(data: OpcuaServer): Promise<IFetchResponse>;
    updateServer(server: OpcuaServer): Promise<any>;
    removeServer(data: OpcuaServer): Promise<IFetchResponse>;
    getKeystore(binaryId: string): Promise<_c8y_client.IResult<_c8y_client.IManagedObject>>;
    uploadKeystore(file: File): Promise<_c8y_client.IResult<_c8y_client.IManagedObjectBinary>>;
    updateKeystore(id: string, file: File): Promise<_c8y_client.IResult<_c8y_client.IManagedObjectBinary>>;
    removeKeystore(id: string): Promise<_c8y_client.IResult<null>>;
    getMoId(): string;
    getId(): string;
    getDeviceProtocol(id: string): Promise<IFetchResponse>;
    updateDeviceProtocol(data: any): Promise<IFetchResponse>;
    createDeviceProtocol(data: any): Promise<IFetchResponse>;
    getServers(id: string): Promise<IFetchResponse>;
    getServer(id: string): Promise<IFetchResponse>;
    /**
     * Checks the response for errors and throws exceptions, otherwise returns the response as is.
     *
     * @param response The response from server.
     *
     * @returns If no errors are detected, it returns the same response.
     *
     * @throws If an error is detected, it throws `{ res, data }`, where `data` contains error details from server.
     */
    protected handleErrorStatusCodes(response: IFetchResponse): Promise<IFetchResponse>;
    private doesGatewayIdExist;
    private doesIdExist;
    private cleanUpPayload;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpcuaService>;
}

interface OpcuaDeviceTypeMappingObject {
    id?: number;
    browsePath?: string[];
}
interface OpcuaDeviceType {
    id?: any;
    name: string;
    fieldbusType?: string;
    fieldbusVersion?: number;
    description?: string;
    unit?: string;
    referencedServerId: string;
    referencedRootNodeId: string;
    subscriptionType: {
        type: string;
        cyclicReadParameters?: {
            rate: number;
        };
        subscriptionParameters?: {
            samplingRate?: number;
            deadbandType?: string;
            deadbandValue?: number;
            ranges?: string;
            queueSize?: number;
        };
    };
    mappings?: OpcuaDeviceTypeMappingObject[];
    overriddenSubscriptions?: any;
    applyConstraints: AutoApplyConstraints;
    enabled: string;
}
interface AutoApplyConstraints {
    browsePathMatchesRegex: string;
    serverObjectHasFragment: string;
    matchesNodeIds: string[];
    matchesServerIds: string[];
}

declare class OpcuaAgentGuard {
    type: string;
    canActivate({ data }: {
        data: any;
    }): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaAgentGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpcuaAgentGuard>;
}

declare class OpcuaDeviceProtocolBrowsePathValidation implements Validator {
    private el;
    getMappings: () => [];
    model: any;
    constructor(el: ElementRef);
    validate(control: AbstractControl): {
        [key: string]: any;
    };
    isValidJson(value: any): boolean;
    toArray(str: any): any;
    isBrowsePathUnique(value: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaDeviceProtocolBrowsePathValidation, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OpcuaDeviceProtocolBrowsePathValidation, "[c8yBrowsePathValidator][ngModel]", never, { "getMappings": { "alias": "getMappings"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OpcuaServersComponent implements OnInit {
    private opcuaService;
    private alertService;
    private translateService;
    private context;
    serverObjectList: OpcuaServer[];
    initialServerObject: OpcuaServer;
    server: OpcuaServer;
    active: boolean;
    private moId;
    constructor(opcuaService: OpcuaService, alertService: AlertService, translateService: TranslateService, context: ContextRouteComponent);
    ngOnInit(): Promise<void>;
    localServerObjectExist(): boolean;
    addServer(): void;
    onSaved(server: OpcuaServer): void;
    onUpdated(server: OpcuaServer): void;
    reloadTabs(): void;
    onCanceled(server: OpcuaServer): void;
    onRemoved(server: OpcuaServer): void;
    getKeystore(binaryId: string): Promise<packages_client_lib.IManagedObject>;
    onPresent(server: OpcuaServer, overridePresent?: boolean): Promise<void>;
    private createServer;
    private updateServer;
    private removeServer;
    private removeServerObjectListById;
    private updateServerObjectListById;
    private setQuickInfo;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaServersComponent, [null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaServersComponent, "opcua-servers", never, {}, {}, never, never, true, never>;
}

declare class OpcuaServerListComponent {
    serverList: OpcuaServer[];
    present: EventEmitter<OpcuaServer>;
    presentConfig(server: OpcuaServer): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaServerListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaServerListComponent, "opcua-server-list", never, { "serverList": { "alias": "serverList"; "required": false; }; }, { "present": "present"; }, never, never, true, never>;
}

declare class OpcuaServerConfigComponent implements OnInit, OnChanges {
    private opcuaService;
    private modalService;
    private alertService;
    private readonly changeDetectorRef;
    currentSecMode: string;
    fileName: string;
    targetConnectionState: string;
    minIntervalNumber: number;
    connectionStatusLabel: string;
    autoScanAddressSpace: string;
    advancedSettings: boolean;
    advancedSettingsForm: FormGroup<{}>;
    advancedSettingsFields: FormlyFieldConfig[];
    isNew: i0.WritableSignal<boolean>;
    set opcuaConfigForm(opcuaConfigForm: NgForm);
    dropArea: DropAreaComponent;
    canceled: EventEmitter<OpcuaServer>;
    removed: EventEmitter<OpcuaServer>;
    saved: EventEmitter<OpcuaServer>;
    updated: EventEmitter<OpcuaServer>;
    set server(server: OpcuaServer);
    get server(): OpcuaServer;
    model: OpcuaServer;
    changePassword: boolean;
    initialPasswordRequired: boolean;
    securityModes: string[];
    authenticationMode: any;
    authenticationModes: any[];
    NONE: string;
    SIGN: string;
    SIGN_ENC: string;
    securityPolicies: any;
    private ANONYM;
    private USER_PASSWORD;
    private KEY_BASED;
    private _server;
    private initialKeystore;
    private keystore;
    private authSwitch;
    private opcuaConfigFormValueChange$;
    private opcuaConfigFormChangesSubscribed;
    private destroyRef;
    constructor(opcuaService: OpcuaService, modalService: ModalService, alertService: AlertService, changeDetectorRef: ChangeDetectorRef);
    ngOnInit(): Promise<void>;
    ngOnChanges(): void;
    ngAfterViewChecked(): void;
    cancel(): void;
    remove(): Promise<void>;
    save(): Promise<void>;
    uploadFile(droppedFiles: DroppedFile[]): void;
    setPolicy(data: any): void;
    setServerConnection(data: string): void;
    updateAuthentication(data: any): void;
    updateConnectionStatusLabel(server: any): void;
    setNewPassword(): void;
    toggleChangePassword(): void;
    private uploadKeystore;
    private removeKeystore;
    private resetUserAuthentication;
    private resetKeyBasedAuthentication;
    private restoreUserData;
    private restoreKeyBasedData;
    private getServerConfig;
    private setCurrentSecurityMode;
    private setCurrentAuthenticationMode;
    private getModelConfig;
    private getAdvancedSettingsFields;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaServerConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaServerConfigComponent, "opcua-server-config", never, { "server": { "alias": "server"; "required": false; }; }, { "canceled": "canceled"; "removed": "removed"; "saved": "saved"; "updated": "updated"; }, never, never, true, never>;
}

declare class DynamicDataSource {
    treeControl: NestedTreeControl<AddressSpaceNode>;
    private addressSpaceService;
    private serverId;
    dataChange: BehaviorSubject<AddressSpaceNode[]>;
    get data(): AddressSpaceNode[];
    set data(value: AddressSpaceNode[]);
    constructor(treeControl: NestedTreeControl<AddressSpaceNode>, addressSpaceService: AddressSpaceService, serverId: string);
    connect(collectionViewer: CollectionViewer): Observable<AddressSpaceNode[]>;
    /** Handle expand/collapse behaviors */
    handleTreeControl(change: SelectionChange<AddressSpaceNode>): void;
    /**
     * Toggle the node, remove from display list
     */
    toggleNode(addressSpaceNode: AddressSpaceNode, expand: boolean): Promise<AddressSpaceNode>;
    catch(): void;
    private refreshNestedTree;
    private triggerResize;
}

declare class OpcuaAddressSpaceComponent implements OnInit, OnDestroy {
    private addressSpaceService;
    private opcuaService;
    private operationService;
    private operationRealtimeService;
    private alert;
    private modalService;
    currentNode: AddressSpaceNode;
    selectednode: boolean;
    searchKey: string;
    isSearch: boolean;
    loading: boolean;
    searchInProgress: boolean;
    filterLabel: string;
    dataSource: DynamicDataSource;
    nodeList: any;
    operation?: IOperation;
    isOperationRunning: i0.WritableSignal<boolean>;
    destroyRef: DestroyRef;
    focusStatus: EventEmitter<AddressSpaceNode>;
    private moId;
    constructor(addressSpaceService: AddressSpaceService, opcuaService: OpcuaService, operationService: OperationService, operationRealtimeService: OperationRealtimeService, alert: AlertService, modalService: ModalService);
    ngOnInit(): Promise<void>;
    getRunningScanAddressSpaceOperation(): Promise<IOperation | undefined>;
    ngOnDestroy(): void;
    searchNodes(): Promise<void>;
    clearNodeListAndCheckSearchString(): void;
    clearSearch(): void;
    getIcon(nodeClassName: string): any;
    selectNode(node: any): Promise<void>;
    toggleCurrentNode(node: AddressSpaceNode): void;
    backHandler(node: any): void;
    isNodeSet(node: AddressSpaceNode): boolean;
    rescanAddressSpace(): Promise<void>;
    createConfigurationAwareScanAdressSpaceOperation(config: OpcuaServerConfig): Promise<IOperation>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaAddressSpaceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaAddressSpaceComponent, "opcua-address-space", never, {}, { "focusStatus": "focusStatus"; }, never, never, true, never>;
}

declare class OpcuaAddressSpaceTreeComponent implements OnInit, OnDestroy, OnChanges {
    private addressSpaceService;
    private opcuaService;
    private alertService;
    set moId(id: string);
    node: any;
    focusEmitter: EventEmitter<AddressSpaceNode>;
    selectedNode: EventEmitter<AddressSpaceNode>;
    nestedTreeControl: NestedTreeControl<AddressSpaceNode>;
    dataSource: DynamicDataSource;
    focused: AddressSpaceNode;
    loading: boolean;
    subscriptionRef: Subscription;
    nodeNavDataSubscription: Subscription;
    private _moId;
    private destroy$;
    constructor(addressSpaceService: AddressSpaceService, opcuaService: OpcuaService, alertService: AlertService);
    getChildren: (node: AddressSpaceNode) => AddressSpaceNode[];
    hasChild: (_: number, _nodeData: AddressSpaceNode) => boolean;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    initializeDataSet(): void;
    ngOnDestroy(): void;
    openNode(nodeNavData: NodeNavigationData): Promise<void>;
    setChildNodes(nodes: AddressSpaceNode[], ids: string[]): void;
    setupTree(nodeId?: string): Promise<void>;
    getMoId(): string;
    getIcon(nodeClassName: any): any;
    toggleFocusedNode(node: any): void;
    isFocusedNode(node: AddressSpaceNode): boolean;
    private getRelativePath;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaAddressSpaceTreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaAddressSpaceTreeComponent, "opcua-address-space-tree", never, { "moId": { "alias": "moId"; "required": false; }; "node": { "alias": "node"; "required": false; }; "focusEmitter": { "alias": "focusEmitter"; "required": false; }; }, { "selectedNode": "selectedNode"; }, never, never, true, never>;
}

declare class OpcuaDeviceProtocolDescription {
    _model: any;
    autoScan: string;
    set model(_model: any);
    private moId;
    setAutoScanOption(data: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaDeviceProtocolDescription, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaDeviceProtocolDescription, "opcua-device-protocol-description", never, { "model": { "alias": "model"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OpcuaCustomActionObjectMapping extends BaseObjectMapping {
    constructor();
}

declare class OpcuaMeasurementObjectMapping extends MeasurementObjectMapping {
    protected smallFormGroup: boolean;
    constructor(smallFormGroup?: boolean);
}
declare class OpcuaEventObjectMapping extends EventObjectMapping {
    protected smallFormGroup: boolean;
    constructor(smallFormGroup?: boolean);
}
declare class OpcuaAlarmObjectMapping extends AlarmObjectMapping {
    protected smallFormGroup: boolean;
    constructor(smallFormGroup?: boolean);
}

declare class OpcuaDeviceProtocolMapping implements OnInit, OnChanges {
    private addressSpaceService;
    subFormRef: NgModelGroup;
    browsePathModel: any;
    _model: any;
    index: any;
    getParentAttr: any;
    referencedServerId: any;
    referencedRootNodeId: any;
    onAction: EventEmitter<any>;
    mapping: any;
    isDetailOpen: any;
    referencedNode: any;
    isPathFocused: boolean;
    groupName: string;
    browsePath: string;
    nodeDisplayName: string;
    isBrowsePathUniq: boolean;
    dataReporting: string;
    isTreeOpen: boolean;
    isNew: boolean;
    resetModel: boolean;
    dataReportingName: any;
    mappingTypes: (typeof OpcuaCustomActionObjectMapping | typeof OpcuaMeasurementObjectMapping | typeof OpcuaEventObjectMapping | typeof OpcuaAlarmObjectMapping)[];
    private objectMappingState;
    constructor(addressSpaceService: AddressSpaceService);
    toggleDetail(): void;
    getMappings: () => any;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onMappingUpdate({ dirty, valid }: {
        dirty: boolean;
        valid: boolean;
        touched?: boolean;
    }): void;
    initialFormSetup(): void;
    showAddressSpaceTree(): boolean;
    ngAfterViewInit(): void;
    mapHeadersObjectToList(headers: any): {
        key: string;
        value: any;
    }[];
    stringfyBrowsePath(path: any): string;
    updateBrowsePath(node: any): void;
    updateDisplayname(): void;
    updateBrowsePathInput(): void;
    save(): void;
    cancel(): void;
    onDelete(): void;
    canSave({ valid, dirty }: {
        valid: any;
        dirty: any;
    }): boolean;
    isActive(): any;
    setTreeFromRefNode(): void;
    updateSubscriptionType(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaDeviceProtocolMapping, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaDeviceProtocolMapping, "opcua-device-protocol-mapping", never, { "_model": { "alias": "resource"; "required": false; }; "index": { "alias": "index"; "required": false; }; "getParentAttr": { "alias": "getParentAttr"; "required": false; }; "referencedServerId": { "alias": "referencedServerId"; "required": false; }; "referencedRootNodeId": { "alias": "referencedRootNodeId"; "required": false; }; }, { "onAction": "onAction"; }, never, never, true, never>;
}

declare class OpcuaDeviceProtocolDetailComponent implements OnInit {
    private changeDetectorRef;
    private opcuaService;
    private alertService;
    private router;
    instanceList: QueryList<OpcuaDeviceProtocolMapping>;
    initialModel: OpcuaDeviceType;
    model: any;
    server: any;
    selectedNode: any;
    isLoaded: boolean;
    constructor(changeDetectorRef: ChangeDetectorRef, opcuaService: OpcuaService, alertService: AlertService, router: Router);
    ngAfterContentChecked(): void;
    getParentAttr: (key: any) => any;
    getMapping(): any;
    getEmptyMappingObject(): {
        id: number;
        browsePath: any[];
    };
    getOverriddenSubscriptionsByPath(browsePath: string[]): any;
    getStructuredResource(resource: any): any;
    ngOnInit(): Promise<void>;
    updateViableMapping(model: any): any;
    trackById(_index: number, el: any): number;
    addVariable(): void;
    updateVariable(mappingObject: any): void;
    removeVariable(mappingObject: any): void;
    actionHandler(actionObject: any): void;
    extractOverridSubscriptionType(_mapping: any): any[][];
    prepareRequestJson(_model: any): {};
    save(): Promise<void>;
    canSave(deviceTypeForm: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaDeviceProtocolDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaDeviceProtocolDetailComponent, "opcua-device-protocol-detail", never, {}, {}, never, never, true, never>;
}

declare class OpcuaDeviceProtocolDataReportingComponent {
    set model(_model: any);
    groupName: any;
    _model: object;
    onSubscriptionChange: EventEmitter<any>;
    subscription: {
        type: string;
    };
    subscriptionParameters: {
        samplingRate: any;
        deadbandType: string;
        deadbandValue: any;
        ranges: string;
        queueSize: any;
        dataChangeTrigger: string;
        discardOldest: boolean;
    };
    cyclicReadParameters: {
        rate: any;
    };
    types: any[];
    filters: any[];
    triggers: any[];
    discard: any[];
    requireCyclic: boolean;
    requireSubscription: boolean;
    subscriptionTypeName: string;
    parseReadingInterval: ($event: any) => number;
    updateModel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaDeviceProtocolDataReportingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaDeviceProtocolDataReportingComponent, "opcua-device-protocol-data-reporting", never, { "model": { "alias": "model"; "required": false; }; "groupName": { "alias": "groupName"; "required": false; }; }, { "onSubscriptionChange": "onSubscriptionChange"; }, never, never, true, never>;
}

declare class OpcuaDeviceProtocolObjectMappingStatus extends UpgradeComponent {
    mapping: any;
    constructor(elementRef: ElementRef, injector: Injector);
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaDeviceProtocolObjectMappingStatus, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OpcuaDeviceProtocolObjectMappingStatus, "c8y-object-mapping-status-icons", never, { "mapping": { "alias": "mapping"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OpcuaAutoApplySettingsComponent implements OnInit {
    private inventoryService;
    opcuaServers: IManagedObject[];
    selectedItems: IManagedObject[];
    filteredList: IManagedObject[];
    checked: {};
    readonly sizeToShowFilter: number;
    constraints: AutoApplyConstraints;
    placeholderSelectServerIds: string;
    showServerIds: boolean;
    showBrowsePath: boolean;
    showServerFragment: boolean;
    showRootNodes: boolean;
    updateSelectedItem: EventEmitter<boolean>;
    private _model;
    constructor(inventoryService: InventoryService);
    ngOnInit(): Promise<void>;
    set model(model: IManagedObject);
    get model(): IManagedObject;
    serverIdsSelected(items: IManagedObject[]): void;
    onChangeNodeId(event: any): void;
    onChangeShowServerIds(event: any): void;
    onChangeShowBrowsePath(event: any): void;
    onChangeShowServerFragment(event: any): void;
    add(): void;
    remove(index: any): void;
    trackByFn(index: any, _item: any): any;
    updateConstraints(items: any): void;
    filterItems(filterText: any): void;
    isChecked(item: any): any;
    onSelect(selected: any, item: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaAutoApplySettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OpcuaAutoApplySettingsComponent, "opcua-auto-apply", never, { "model": { "alias": "model"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OpcuaProtocolModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaProtocolModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OpcuaProtocolModule, never, [typeof i1.CoreModule, typeof i1.FormsModule, typeof i2.ReactiveFormsModule, typeof i1.DropAreaModule, typeof i3.ButtonsModule, typeof i4.CdkTreeModule, typeof i5.RouterModule, typeof i6.TooltipModule, typeof i7.PopoverModule, typeof i1.DeviceStatusModule, typeof i8.OperationDetailsModule, typeof i9.BrowserAnimationsModule, typeof i10.CollapseModule, typeof i11.BsDropdownModule, typeof i12.ObjectMappingComponent, typeof i1.DynamicFormsModule, typeof OpcuaServersComponent, typeof OpcuaServerListComponent, typeof OpcuaServerConfigComponent, typeof OpcuaAddressSpaceComponent, typeof OpcuaAddressSpaceTreeComponent, typeof OpcuaAddressSpaceDetailComponent, typeof OpcuaDeviceProtocolDescription, typeof OpcuaDeviceProtocolDetailComponent, typeof OpcuaDeviceProtocolDataReportingComponent, typeof OpcuaDeviceProtocolMapping, typeof OpcuaDeviceProtocolObjectMappingStatus, typeof OpcuaAutoApplySettingsComponent, typeof OpcuaDeviceProtocolBrowsePathValidation], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OpcuaProtocolModule>;
}

declare class OpcuaMicroserviceGuard {
    private app;
    microserviceName: string;
    checkApp: Promise<boolean>;
    constructor(app: AppStateService);
    canActivate(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaMicroserviceGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpcuaMicroserviceGuard>;
}

declare class OpcuaServerGuard {
    type: string;
    canActivate({ data }: {
        data: any;
    }): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpcuaServerGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpcuaServerGuard>;
}

declare const ng1ModulesOPCUA: string[];

export { AddressSpaceService, DynamicDataSource, NEW_SERVER_ID, OpcuaAddressSpaceComponent, OpcuaAddressSpaceDetailComponent, OpcuaAddressSpaceTreeComponent, OpcuaAgentGuard, OpcuaAutoApplySettingsComponent, OpcuaDeviceProtocolBrowsePathValidation, OpcuaDeviceProtocolDataReportingComponent, OpcuaDeviceProtocolDescription, OpcuaDeviceProtocolDetailComponent, OpcuaDeviceProtocolMapping, OpcuaDeviceProtocolObjectMappingStatus, OpcuaMicroserviceGuard, OpcuaProtocolModule, OpcuaServerConfigComponent, OpcuaServerGuard, OpcuaServerListComponent, OpcuaServersComponent, OpcuaService, ng1ModulesOPCUA };
export type { AddressSpaceNode, AdressSpaceNodeReference, AutoApplyConstraints, NodeNavigationData, OpcuaDeviceType, OpcuaDeviceTypeMappingObject, OpcuaServer, OpcuaServerConfig, SearchedNode };
//# sourceMappingURL=index.d.ts.map