/**
 * @module node-opcua-address-space
 */
import type { AddEnumerationTypeOptions, AddMethodOptions, AddObjectOptions, AddObjectTypeOptions, AddReferenceTypeOptions, AddVariableOptions, AddVariableTypeOptions, AddViewOptions, AddYArrayItemOptions, BaseNode, CreateDataTypeOptions, CreateNodeOptions, RequiredModel, UADataType, UAEventType, UAMethod, UAObject, UAObjectType, UAReferenceType, UAVariable, UAVariableType, UAView } from "node-opcua-address-space-base";
import { AccessRestrictionsFlag, type QualifiedNameLike } from "node-opcua-data-model";
import { NodeId } from "node-opcua-nodeid";
import type { UAAnalogItem, UADataItem, UAInitialState, UAState } from "node-opcua-nodeset-ua";
import { type RolePermissionType, type RolePermissionTypeOptions } from "node-opcua-types";
import { DataType, type VariantOptions } from "node-opcua-variant";
import type { AddMultiStateDiscreteOptions, AddMultiStateValueDiscreteOptions, AddTwoStateDiscreteOptions, AddTwoStateVariableOptions } from "../api/address_space_ts.js";
import type { InstantiateAlarmConditionOptions, InstantiateLimitAlarmOptions, InstantiateOffNormalAlarmOptions, UATwoStateDiscreteEx, UAYArrayItemEx } from "../api/index.js";
import type { InstantiateConditionOptions } from "../api/interfaces/alarms_and_conditions/instantiate_condition_options.js";
import type { InstantiateExclusiveDeviationAlarmOptions } from "../api/interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options.js";
import type { InstantiateNonExclusiveDeviationAlarmOptions } from "../api/interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options.js";
import type { InstantiateNonExclusiveLimitAlarmOptions } from "../api/interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options.js";
import type { UAAlarmConditionEx } from "../api/interfaces/alarms_and_conditions/ua_alarm_condition_ex.js";
import type { UAConditionEx } from "../api/interfaces/alarms_and_conditions/ua_condition_ex.js";
import type { UADiscreteAlarmEx } from "../api/interfaces/alarms_and_conditions/ua_discrete_alarm_ex.js";
import type { UAExclusiveDeviationAlarmEx } from "../api/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex.js";
import type { UAExclusiveLimitAlarmEx } from "../api/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex.js";
import type { UALimitAlarmEx } from "../api/interfaces/alarms_and_conditions/ua_limit_alarm_ex.js";
import type { UANonExclusiveDeviationAlarmEx } from "../api/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex.js";
import type { UANonExclusiveLimitAlarmEx } from "../api/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex.js";
import type { UAMultiStateDiscreteEx } from "../api/interfaces/data_access/ua_multistate_discrete_ex.js";
import type { UAMultiStateValueDiscreteEx } from "../api/interfaces/data_access/ua_multistate_value_discrete_ex.js";
import type { UAStateMachineEx } from "../api/interfaces/state_machine/ua_state_machine_type.js";
import type { UATransitionEx } from "../api/interfaces/state_machine/ua_transition_ex.js";
import type { NodesetRecord } from "../api/loader/nodeset_record.js";
import type { AddAnalogDataItemOptions, AddDataItemOptions } from "../api/namespace_data_access.js";
import type { UATwoStateVariableEx } from "../api/ua_two_state_variable_ex.js";
import type { AddressSpacePrivate } from "./address_space_private.js";
import { type UAAcknowledgeableConditionImpl } from "./alarms_and_conditions/index.js";
import { type UAOffNormalAlarmEx } from "./alarms_and_conditions/ua_off_normal_alarm_impl.js";
import { _handle_hierarchy_parent } from "./handle_hierarchy_parent.js";
import { type NamespacePrivate } from "./namespace_private.js";
import { type ConstructNodeIdOptions } from "./nodeid_manager.js";
import type { NamespaceToImageOptions, ToNodesetRecordsOptions } from "./nodeset_tools/nodeset_to_records.js";
export interface AddFolderOptions {
    browseName: QualifiedNameLike;
}
interface NamespaceConstructorOptions {
    addressSpace: AddressSpacePrivate;
    index: number;
    namespaceUri: string;
    publicationDate: Date;
    version: string;
}
/**
 *
 * @constructor
 * @params options {Object}
 * @params options.namespaceUri {string}
 * @params options.addressSpace {IAddressSpace}
 * @params options.index {number}
 * @params options.version="" {string}
 * @params options.publicationDate="" {Date}
 *
 * @internal
 */
export declare class NamespaceImpl implements NamespacePrivate {
    static _handle_hierarchy_parent: typeof _handle_hierarchy_parent;
    static isNonEmptyQualifiedName: typeof isNonEmptyQualifiedName;
    readonly namespaceUri: string;
    addressSpace: AddressSpacePrivate;
    readonly index: number;
    emulateVersion103: boolean;
    version: string;
    publicationDate: Date;
    registerSymbolicNames: boolean;
    private _requiredModels?;
    private _objectTypeMap;
    private _variableTypeMap;
    private _referenceTypeMap;
    private _dataTypeMap;
    private _referenceTypeMapInv;
    private _nodeIdManager;
    private _nodeid_index;
    private _aliases;
    private defaultAccessRestrictions?;
    private defaultRolePermissions?;
    constructor(options: NamespaceConstructorOptions);
    getDefaultNamespace(): NamespacePrivate;
    toJSON(): Record<string, string | number | undefined>;
    toString(): string;
    dispose(): void;
    nodeIterator(): IterableIterator<BaseNode>;
    objectTypeIterator(): IterableIterator<UAObjectType>;
    objectTypeCount(): number;
    variableTypeIterator(): IterableIterator<UAVariableType>;
    variableTypeCount(): number;
    dataTypeIterator(): IterableIterator<UADataType>;
    dataTypeCount(): number;
    referenceTypeIterator(): IterableIterator<UAReferenceType>;
    referenceTypeCount(): number;
    aliasCount(): number;
    /** @deprecated use `objectTypeIterator` */
    _objectTypeIterator(): IterableIterator<UAObjectType>;
    /** @deprecated use `objectTypeCount` */
    _objectTypeCount(): number;
    /** @deprecated use `variableTypeIterator` */
    _variableTypeIterator(): IterableIterator<UAVariableType>;
    /** @deprecated use `variableTypeCount` */
    _variableTypeCount(): number;
    /** @deprecated use `dataTypeIterator` */
    _dataTypeIterator(): IterableIterator<UADataType>;
    /** @deprecated use `dataTypeCount` */
    _dataTypeCount(): number;
    /** @deprecated use `referenceTypeIterator` */
    _referenceTypeIterator(): IterableIterator<UAReferenceType>;
    /** @deprecated use `referenceTypeCount` */
    _referenceTypeCount(): number;
    /** @deprecated use `aliasCount` */
    _aliasCount(): number;
    findNode2(nodeId: NodeId): BaseNode | null;
    findNode(nodeId: string | NodeId): BaseNode | null;
    /**
     *
     * @param objectTypeName {String}
     * @return {UAObjectType|null}
     */
    findObjectType(objectTypeName: string): UAObjectType | null;
    /**
     *
     * @param variableTypeName {String}
     * @returns {UAVariableType|null}
     */
    findVariableType(variableTypeName: string): UAVariableType | null;
    /**
     *
     * @param dataTypeName {String}
     * @returns {UADataType|null}
     */
    findDataType(dataTypeName: string): UADataType | null;
    /**
     *
     * @param referenceTypeName {String}
     * @returns  {ReferenceType|null}
     */
    findReferenceType(referenceTypeName: string): UAReferenceType | null;
    /**
     * find a ReferenceType by its inverse name.

     * @param inverseName {String} the inverse name of the ReferenceType to find
     * @return {ReferenceType}
     */
    findReferenceTypeFromInverseName(inverseName: string): UAReferenceType | null;
    /**
     *

     * @param alias_name {String} the alias name
     * @param nodeId {NodeId} NodeId must belong to this namespace
     */
    addAlias(alias_name: string, nodeId: NodeId): void;
    resolveAlias(name: string): NodeId | null;
    /**
     * add a new Object type to the address space

     * @param options
     * @param options.browseName {String} the object type name
     * @param [options.displayName] {String|LocalizedText} the display name
     * @param [options.subtypeOf="BaseObjectType"] {String|NodeId|BaseNode} the base class
     * @param [options.nodeId] {String|NodeId} an optional nodeId for this objectType,
     *                                         if not provided a new nodeId will be created
     * @param [options.isAbstract = false] {Boolean}
     * @param [options.eventNotifier = 0] {Integer}
     * @param [options.postInstantiateFunc = null] {Function}
     *
     */
    addObjectType(options: AddObjectTypeOptions): UAObjectType;
    /**
     * add a new Variable type to the address space

     * @param options
     * @param options.browseName {String} the object type name
     * @param [options.displayName] {String|LocalizedText} the display name
     * @param [options.subtypeOf="BaseVariableType"] {String|NodeId|BaseNode} the base class
     * @param [options.nodeId] {String|NodeId} an optional nodeId for this objectType,
     *                                             if not provided a new nodeId will be created
     * @param [options.isAbstract = false] {Boolean}
     * @param options.dataType {String|NodeId} the variable DataType
     * @param [options.valueRank = -1]
     * @param [options.arrayDimensions = null] { Array<Int>>
     *
     */
    addVariableType(options: AddVariableTypeOptions): UAVariableType;
    /**
     * add a variable as a component of the parent node
     */
    addVariable(options: AddVariableOptions): UAVariable;
    addView(options: AddViewOptions): UAView;
    addObject(options1: AddObjectOptions): UAObject;
    /**
     *

     * @param parentFolder
     * @param options {String|Object}
     * @param options.browseName {String} the name of the folder
     * @param [options.nodeId] {NodeId}. An optional nodeId for this object
     *
     * @return {BaseNode}
     */
    addFolder(parentFolder: UAObject, options: AddFolderOptions | string): UAObject;
    /**

     * @param options
     * @param options.isAbstract
     * @param options.browseName
     * @param options.inverseName
     */
    addReferenceType(options: AddReferenceTypeOptions): UAReferenceType;
    /**
     */
    addMultiStateDiscrete<T, DT extends DataType>(options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteEx<T, DT>;
    /**

     */
    createDataType(options: CreateDataTypeOptions): UADataType;
    /**

     * @param options
     * @param options.nodeClass
     * @param [options.nodeVersion {String} = "0" ] install nodeVersion
     * @param [options.modellingRule {String} = null]
     * @internal
     */
    createNode(options: CreateNodeOptions): BaseNode;
    /**
     * remove the specified Node from the address space
     *

     * @param  nodeOrNodeId
     *
     *
     */
    deleteNode(nodeOrNodeId: NodeId | BaseNode): void;
    /**
     * @internal
     */
    getStandardsNodeIds(): {
        referenceTypeIds: {
            [key: string]: string;
        };
        objectTypeIds: {
            [key: string]: string;
        };
    };
    /**
     * add a new event type to the address space

     * @param options
     * @param options.browseName {String} the eventType name
     * @param [options.subtypeOf ="BaseEventType"]
     * @param [options.isAbstract = true]
     * @return {UAObjectType} : the object type
     *
     * @example
     *
     *      var evtType = namespace.addEventType({
     *          browseName: "MyAuditEventType",
     *          subtypeOf:  "AuditEventType"
     *      });
     *      var myConditionType = namespace.addEventType({
     *          browseName: "MyConditionType",
     *          subtypeOf:  "ConditionType",
     *          isAbstract: false
     *      });
     *
     */
    addEventType(options: AddObjectTypeOptions): UAObjectType;
    /**
     *
     */
    addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT>;
    /**
     *

     *
     * AnalogDataItem DataItems that represent continuously-variable physical quantities ( e.g., length, temperature),
     * in contrast to the digital representation of data in discrete  items
     * NOTE Typical examples are the values provided by temperature sensors or pressure sensors. OPC UA defines a
     * specific UAVariableType to identify an AnalogItem. Properties describe the possible ranges of  AnalogItems.
     *
     *
     * @example:
     *
     *
     *   namespace.add_analog_dataItem({
     *      componentOf: parentObject,
     *      browseName: "TemperatureSensor",
     *
     *      definition: "(tempA -25) + tempB",
     *      valuePrecision: 0.5,
     *      //-
     *      instrumentRange: { low: 100 , high: 200}, // optional
     *      engineeringUnitsRange: { low: 100 , high: 200}, // mandatory
     *      engineeringUnits: standardUnits.degree_celsius,, // optional
     *
     *      // access level
     *      accessLevel: 1
     *      minimumSamplingInterval: 10,
     *
     *   });
     *
  
     * @return {UAVariable}
     */
    addAnalogDataItem<T, DT extends DataType>(options: AddAnalogDataItemOptions): UAAnalogItem<T, DT>;
    /**
     *

     * @param options {Object}
     * @param options.browseName {String}
     * @param [options.nodeId  {NodeId}]
     * @param [options.value {UInt32} = 0 }
     * @param options.enumValues { EnumValueType[]| {Key,Value} }
     * @return {Object|UAVariable}
     *
     * @example
     *
     *
     *      namespace.addMultiStateValueDiscrete({
     *          componentOf:parentObj,
     *          browseName: "myVar",
     *          enumValues: {
     *              "Red":    0xFF0000,
     *              "Green":  0x00FF00,
     *              "Blue":   0x0000FF
     *          }
     *      });
     *      addMultiStateValueDiscrete(parentObj,{
     *          browseName: "myVar",
     *          enumValues: [
     *              {
     *                 value: 0xFF0000,
     *                 displayName: "Red",
     *                 description: " The color Red"
     *              },
     *              {
     *                 value: 0x00FF000,
     *                 displayName: "Green",
     *                 description: " The color Green"
     *              },
     *              {
     *                 value: 0x0000FF,
     *                 displayName: "Blue",
     *                 description: " The color Blue"
     *              }
     *
     *          ]
     *      });
     */
    addMultiStateValueDiscrete<T, DT extends DataType>(options: AddMultiStateValueDiscreteOptions): UAMultiStateValueDiscreteEx<T, DT>;
    /**
     *

     * @param options
     * @param options.componentOf {NodeId}
     * @param options.browseName {String}
     * @param options.title {String}
     * @param [options.instrumentRange]
     * @param [options.instrumentRange.low] {Double}
     * @param [options.instrumentRange.high] {Double}
     * @param options.engineeringUnitsRange.low {Double}
     * @param options.engineeringUnitsRange.high {Double}
     * @param options.engineeringUnits {String}
     * @param [options.nodeId = {NodeId}]
     * @param options.accessLevel
     * @param options.userAccessLevel
     * @param options.title {String}
     * @param options.axisScaleType {AxisScaleEnumeration}
     *
     * @param options.xAxisDefinition {AxisInformation}
     * @param options.xAxisDefinition.engineeringUnits  EURange
     * @param options.xAxisDefinition.range
     * @param options.xAxisDefinition.range.low
     * @param options.xAxisDefinition.range.high
     * @param options.xAxisDefinition.title  {LocalizedText}
     * @param options.xAxisDefinition.axisScaleType {AxisScaleEnumeration}
     * @param options.xAxisDefinition.axisSteps = <null>  {Array<Double>}
     * @param options.value
     */
    addYArrayItem<DT extends DataType.Double | DataType.Float>(options: AddYArrayItemOptions): UAYArrayItemEx<DT>;
    /**

     * @param parentObject {Object}
     * @param options {Object}
     * @param [options.nodeId=null] {NodeId} the object nodeid.
     * @param [options.browseName=""] {String} the object browse name.
     * @param [options.description=""] {String} the object description.
     * @param options.inputArguments  {Array<Argument>}
     * @param options.outputArguments {Array<Argument>}
     * @return {Object}
     */
    addMethod(parentObject: UAObject, options: AddMethodOptions): UAMethod;
    /**
     *

     * @param options
     * @param options.browseName  {String}
     * @param options.enumeration {Array}
     * @param options.enumeration[].displayName {String|LocalizedText}
     * @param options.enumeration[].value       {Number}
     * @param options.enumeration[].description {String|LocalizedText|null}
     */
    addEnumerationType(options: AddEnumerationTypeOptions): UADataType;
    toNodeset2XML(): string;
    toNodesetRecords(_options?: ToNodesetRecordsOptions): Iterable<NodesetRecord>;
    toNodesetImage(_options?: NamespaceToImageOptions): Promise<Uint8Array>;
    setRequiredModels(requiredModels: RequiredModel[]): void;
    getRequiredModels(): RequiredModel[] | undefined;
    /**
     */
    addState(component: UAStateMachineEx, stateName: QualifiedNameLike, stateNumber: number, isInitialState: boolean): UAState | UAInitialState;
    /**
     */
    addTransition(component: UAStateMachineEx, fromState: string, toState: string, transitionNumber: number, browseName?: QualifiedNameLike): UATransitionEx;
    /**

     *
     * @return {UATwoStateVariable}
     */
    addTwoStateVariable(options: AddTwoStateVariableOptions): UATwoStateVariableEx;
    /**

     *
     * Add a TwoStateDiscrete Variable
     * @return {UATwoStateDiscrete}
     */
    addTwoStateDiscrete(options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx;
    instantiateCondition(conditionTypeId: UAEventType | NodeId | string, options: InstantiateConditionOptions, data: Record<string, VariantOptions>): UAConditionEx;
    instantiateAcknowledgeableCondition(conditionTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UAAcknowledgeableConditionImpl;
    instantiateAlarmCondition(alarmConditionTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UAAlarmConditionEx;
    instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UALimitAlarmEx;
    instantiateExclusiveLimitAlarm(exclusiveLimitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLimitAlarmEx;
    instantiateExclusiveDeviationAlarm(options: InstantiateExclusiveDeviationAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveDeviationAlarmEx;
    instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateNonExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UANonExclusiveLimitAlarmEx;
    instantiateNonExclusiveDeviationAlarm(options: InstantiateNonExclusiveDeviationAlarmOptions, data?: Record<string, VariantOptions>): UANonExclusiveDeviationAlarmEx;
    instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UADiscreteAlarmEx;
    instantiateOffNormalAlarm(options: InstantiateOffNormalAlarmOptions, data?: Record<string, VariantOptions>): UAOffNormalAlarmEx;
    setDefaultRolePermissions(rolePermissions: RolePermissionTypeOptions[] | null): void;
    getDefaultRolePermissions(): RolePermissionType[] | null;
    setDefaultAccessRestrictions(accessRestrictions: AccessRestrictionsFlag): void;
    getDefaultAccessRestrictions(): AccessRestrictionsFlag;
    constructNodeId(options: ConstructNodeIdOptions): NodeId;
    _register(node: BaseNode): void;
    /**

     * @internal
     */
    internalCreateNode(options: CreateNodeOptions): BaseNode;
    _deleteNode(node: BaseNode): void;
    private _addObjectOrVariableType;
    private _registerObjectType;
    private _registerVariableType;
    private _registerReferenceType;
    private _registerDataType;
    private _unregisterObjectType;
    private _unregisterVariableType;
    /**
     * @private
     */
    private _addVariable;
    /**
     * @private
     */
    private _addMethod;
}
export declare function isNonEmptyQualifiedName(browseName: QualifiedNameLike): boolean;
export {};