import { type ObjectTypesSupportedBitString, type ServicesSupportedBitString, type StatusFlagsBitString } from './bitstring';
import { type ApplicationTag, type EventState, type EventType, type NotifyType, type ObjectType, type PropertyIdentifier, type TimeStamp, type EngineeringUnits, type DeviceStatus, type Segmentation, type Reliability, type BinaryPV, type NodeType, CovType } from './enum';
export interface EncodeBuffer {
    buffer: Buffer;
    offset: number;
}
export interface BACNetAddress {
    net?: number;
    type?: number;
    adr?: number[];
    forwardedFrom?: string;
    address?: string;
    distributeBroadcastToNetwork?: boolean;
}
export interface DecodedNpdu {
    len: number;
    funct: number;
    destination?: BACNetAddress;
    source?: BACNetAddress;
    hopCount: number;
    networkMsgType: number;
    vendorId: number;
}
export interface PropertyReference {
    id: PropertyIdentifier;
    index?: number;
}
export interface TypedValue<Tag extends ApplicationTag = ApplicationTag, Type extends ApplicationTagValueTypeMap[Tag] = ApplicationTagValueTypeMap[Tag]> {
    type: Tag;
    value: Type;
}
export interface TransportSettings {
    port?: number;
    interface?: string;
    broadcastAddress?: string;
    reuseAddr?: boolean;
}
export interface BACNetObjectID {
    type: ObjectType;
    instance: number;
}
export interface BACNetPropertyID {
    id: PropertyIdentifier;
    index: number;
}
export interface BACNetReadAccessSpecification {
    objectId: BACNetObjectID;
    properties: BACNetPropertyID[];
}
export interface BACNetBitString {
    bitsUsed: number;
    value: number[];
}
export interface BACNetRecipient {
    network: number;
    address: number[];
}
export interface BACNetCovSubscription {
    recipient: BACNetRecipient;
    subscriptionProcessId: number;
    monitoredObjectId: BACNetObjectID;
    monitoredProperty: BACNetPropertyID;
    issueConfirmedNotifications: boolean;
    timeRemaining: number;
    covIncrement: number;
}
export interface BACNetAlarm {
    objectId: BACNetObjectID;
    alarmState: number;
    acknowledgedTransitions: BACNetBitString;
}
export interface BACNetEvent {
    objectId: BACNetObjectID;
    eventState: EventState;
    acknowledgedTransitions: BACNetBitString;
    eventTimeStamps: Date[];
    notifyType: NotifyType;
    eventEnable: BACNetBitString;
    eventPriorities: number[];
}
export interface BACNetDevObjRef {
    id: number;
    arrayIndex: number;
    objectId: BACNetObjectID;
    deviceIndentifier: BACNetObjectID;
}
export interface BACNetAppData<Tag extends ApplicationTag = ApplicationTag, Type extends ApplicationTagValueTypeMap[Tag] = ApplicationTagValueTypeMap[Tag]> {
    type: Tag;
    value: Type;
    raw?: unknown;
    encoding?: number;
}
export interface BACNetRawDate {
    year: number;
    month: number;
    day: number;
    wday: number;
}
export type BACNetDateValue = Date | number | BACNetRawDate;
export type BACNetDateAppData = Omit<BACNetAppData<ApplicationTag.DATE>, 'value'> & {
    type: ApplicationTag.DATE;
    value: BACNetDateValue;
};
export type BACNetTimeAppData = Omit<BACNetAppData<ApplicationTag.TIME>, 'value'> & {
    type: ApplicationTag.TIME;
    value: Date | number;
};
export type BACNetEncodableAppData = BACNetAppData | BACNetDateAppData | BACNetTimeAppData;
export interface BACNetWeekNDayValue {
    month: number;
    week: number;
    wday: number;
}
export interface BACNetWeekNDayAppData extends BACNetAppData<ApplicationTag.WEEKNDAY> {
    value: BACNetWeekNDayValue;
}
export interface BACNetDateRangeAppData extends BACNetAppData<ApplicationTag.DATERANGE> {
    value: [BACNetDateAppData, BACNetDateAppData];
}
export interface BACNetTimeValueEntry {
    time: BACNetTimeAppData | Date | number;
    value: BACNetAppData;
}
export type BACNetWeeklySchedulePayload = BACNetTimeValueEntry[][];
export interface BACNetSpecialEventEntry {
    date: BACNetDateAppData | BACNetDateRangeAppData | BACNetWeekNDayAppData;
    events: BACNetTimeValueEntry[];
    priority: BACNetAppData<ApplicationTag.UNSIGNED_INTEGER> | number;
}
export type BACNetExceptionSchedulePayload = BACNetSpecialEventEntry[];
export type BACNetEffectivePeriodPayload = [
    BACNetDateAppData | BACNetDateValue,
    BACNetDateAppData | BACNetDateValue
];
export type BACNetCalendarDateListEntry = BACNetDateAppData | BACNetDateRangeAppData | BACNetWeekNDayAppData;
export type BACNetCalendarDateListPayload = BACNetCalendarDateListEntry[];
export type BACNetWritePropertyValues = BACNetAppData[] | BACNetWeeklySchedulePayload | BACNetExceptionSchedulePayload | BACNetEffectivePeriodPayload | BACNetCalendarDateListPayload;
export interface ApplicationTagValueTypeMap {
    [ApplicationTag.NULL]: null;
    [ApplicationTag.BOOLEAN]: boolean;
    [ApplicationTag.UNSIGNED_INTEGER]: number;
    [ApplicationTag.SIGNED_INTEGER]: number;
    [ApplicationTag.REAL]: number;
    [ApplicationTag.DOUBLE]: number;
    [ApplicationTag.OCTET_STRING]: any;
    [ApplicationTag.CHARACTER_STRING]: string;
    [ApplicationTag.BIT_STRING]: StatusFlagsBitString | ServicesSupportedBitString | ObjectTypesSupportedBitString;
    [ApplicationTag.ENUMERATED]: ObjectType | EventState | EngineeringUnits | PropertyIdentifier | DeviceStatus | Segmentation | Reliability | BinaryPV | NodeType;
    [ApplicationTag.DATE]: Date;
    [ApplicationTag.TIME]: Date;
    [ApplicationTag.OBJECTIDENTIFIER]: BACNetObjectID;
    [ApplicationTag.EMPTYLIST]: any;
    [ApplicationTag.WEEKNDAY]: any;
    [ApplicationTag.DATERANGE]: any;
    [ApplicationTag.DATETIME]: any;
    [ApplicationTag.TIMESTAMP]: BACNetTimestamp;
    [ApplicationTag.ERROR]: any;
    [ApplicationTag.DEVICE_OBJECT_PROPERTY_REFERENCE]: DeviceObjPropertyRef;
    [ApplicationTag.DEVICE_OBJECT_REFERENCE]: BACNetDevObjRef;
    [ApplicationTag.OBJECT_PROPERTY_REFERENCE]: any;
    [ApplicationTag.DESTINATION]: any;
    [ApplicationTag.RECIPIENT]: BACNetRecipient;
    [ApplicationTag.COV_SUBSCRIPTION]: BACNetCovSubscription;
    [ApplicationTag.CALENDAR_ENTRY]: any;
    [ApplicationTag.WEEKLY_SCHEDULE]: any;
    [ApplicationTag.SPECIAL_EVENT]: any;
    [ApplicationTag.READ_ACCESS_SPECIFICATION]: any;
    [ApplicationTag.READ_ACCESS_RESULT]: any;
    [ApplicationTag.LIGHTING_COMMAND]: any;
    [ApplicationTag.CONTEXT_SPECIFIC_DECODED]: any;
    [ApplicationTag.CONTEXT_SPECIFIC_ENCODED]: any;
    [ApplicationTag.LOG_RECORD]: any;
}
export interface BACNetPropertyState {
    type: number;
    state: number;
}
export interface BACNetEventInformation {
    objectId: BACNetObjectID;
    eventState: EventState;
    acknowledgedTransitions: BACNetBitString;
    eventTimeStamps: any[];
    notifyType: NotifyType;
    eventEnable: BACNetBitString;
    eventPriorities: number[];
}
export interface TimeStampValueTypeMap {
    [TimeStamp.DATETIME]: Date;
    [TimeStamp.SEQUENCE_NUMBER]: number;
    [TimeStamp.TIME]: Date;
}
export interface BACNetTimestamp<T extends TimeStamp = TimeStamp> {
    type: T;
    value: TimeStampValueTypeMap[T];
}
export interface Decode<T> {
    len: number;
    value: T;
}
export interface Tag {
    len: number;
    tagNumber: number;
    value?: number;
}
export interface ObjectId {
    len: number;
    objectType: ObjectType;
    instance: number;
}
export interface ApplicationData extends BACNetAppData {
    len: number;
}
export interface BACNetReadAccess {
    objectId: BACNetObjectID;
    values: {
        property: BACNetPropertyID;
        value: any[];
    }[];
}
export interface ReadAccessDecode {
    len: number;
    value: {
        objectId: BACNetObjectID;
        values: ReadAccessProperty[];
    };
}
export interface CharacterString extends Decode<string> {
    encoding: number;
}
export interface CalendarDate {
    len: number;
    year: number;
    month: number;
    day: number;
    wday: number;
}
export interface CalendarDateRange {
    len: number;
    startDate: Decode<Date>;
    endDate: Decode<Date>;
}
export interface CalendarWeekDay {
    len: number;
    month: number;
    week: number;
    wday: number;
}
export interface Calendar {
    len: number;
    value: any[];
}
export interface DeviceObjPropertyRef {
    len: number;
    value: {
        objectId: ObjectId;
        id: Decode<number>;
    };
}
export interface ReadAccessSpec {
    len: number;
    value: BACNetReadAccessSpecification;
}
export interface CovSubscription {
    len: number;
    value: BACNetCovSubscription;
}
export interface ContextTagWithLength {
    len: number;
    value: boolean;
}
export interface ContextCharacterString extends Decode<string> {
    encoding: number;
}
export interface BasePacket {
    len: number;
    type: number;
}
export interface ConfirmedServiceRequest extends BasePacket {
    service: number;
    maxSegments: number;
    maxApdu: number;
    invokeId: number;
    sequencenumber: number;
    proposedWindowNumber: number;
}
export interface UnconfirmedServiceRequest extends BasePacket {
    service: number;
}
export interface SimpleAck extends BasePacket {
    service: number;
    invokeId: number;
}
export interface ComplexAck extends BasePacket {
    service: number;
    invokeId: number;
    sequencenumber: number;
    proposedWindowNumber: number;
}
export interface SegmentAck extends BasePacket {
    originalInvokeId: number;
    sequencenumber: number;
    actualWindowSize: number;
}
export interface BACnetError extends BasePacket {
    service: number;
    invokeId: number;
}
export interface Abort extends BasePacket {
    invokeId: number;
    reason: number;
}
export interface BvlcPacket {
    len: number;
    func: number;
    msgLength: number;
    originatingIP?: string;
}
export interface ClientOptions {
    port?: number;
    interface?: string;
    transport?: any;
    broadcastAddress?: string;
    apduTimeout?: number;
    reuseAddr?: boolean;
}
export interface WhoIsOptions {
    lowLimit?: number;
    highLimit?: number;
}
export interface ServiceOptions {
    maxSegments?: number;
    maxApdu?: number;
    invokeId?: number;
}
export interface ReadPropertyOptions extends ServiceOptions {
    arrayIndex?: number;
}
export interface WriteFileOptions extends ServiceOptions {
    isStream?: boolean;
}
export interface WritePropertyOptions extends ServiceOptions {
    arrayIndex?: number;
    priority?: number;
}
export interface IAMResult {
    address: string;
    deviceId: number;
    maxApdu: number;
    segmentation: number;
    vendorId: number;
}
export interface WhoIsResult {
    address: string;
    lowLimit?: number;
    highLimit?: number;
}
export interface TargetResult {
    target: BACNetAddress;
    len: number;
}
export type ErrorCallback = (err?: Error) => void;
export type DataCallback<T = any> = (err?: Error, result?: T) => void;
export interface DecodeAcknowledgeSingleResult {
    len: number;
    objectId: BACNetObjectID;
    property: {
        id: PropertyIdentifier;
        index: number;
    };
    values: ApplicationData[];
}
export interface ReadAccessProperty {
    id: PropertyIdentifier;
    index: number;
    value: ApplicationData[];
}
export interface ReadAccessError {
    errorClass: number;
    errorCode: number;
}
export interface DecodeAcknowledgeMultipleResult {
    len: number;
    values: ReadAccessDecode['value'][];
}
export interface ReadPropertyRequest {
    len: number;
    objectId: BACNetObjectID;
    property: BACNetPropertyID;
}
export interface WritePropertyRequest {
    len: number;
    objectId: BACNetObjectID;
    value: {
        property: BACNetPropertyID;
        value: ApplicationData[];
        priority: number;
    };
}
export interface DeviceCommunicationOptions extends ServiceOptions {
    password?: string;
}
export interface ReinitializeDeviceOptions extends ServiceOptions {
    password?: string;
}
export interface BACnetMessageHeader {
    apduType: number;
    expectingReply: boolean;
    sender: BACNetAddress;
    func?: number;
    confirmedService?: boolean;
}
export interface BACnetMessageBase {
    len: number;
    type?: number;
    header?: BACnetMessageHeader;
    payload?: any;
}
export interface HasService {
    service: number;
}
export interface HasInvokeId {
    invokeId: number;
}
export interface HasOriginalInvokeId {
    originalInvokeId: number;
}
export interface IsSegmentable {
    sequencenumber: number;
    proposedWindowNumber: number;
}
export type ServiceMessage = BACnetMessageBase & HasService;
export type InvokeMessage = BACnetMessageBase & HasInvokeId;
export type SegmentableMessage = InvokeMessage & IsSegmentable;
export type UnconfirmedServiceRequestMessage = UnconfirmedServiceRequest & ServiceMessage;
export type ConfirmedServiceRequestMessage = ConfirmedServiceRequest & ServiceMessage & SegmentableMessage;
export type SimpleAckMessage = SimpleAck & InvokeMessage & HasService;
export type ComplexAckMessage = ComplexAck & ServiceMessage & SegmentableMessage;
export type SegmentAckMessage = SegmentAck & BACnetMessageBase & HasOriginalInvokeId;
export type BACnetErrorMessage = BACnetError & ServiceMessage & InvokeMessage;
export type AbortMessage = Abort & InvokeMessage;
export type BACnetMessage = UnconfirmedServiceRequestMessage | ConfirmedServiceRequestMessage | SimpleAckMessage | ComplexAckMessage | SegmentAckMessage | BACnetErrorMessage | AbortMessage;
export interface BasicServicePayload {
    header?: BACnetMessageHeader;
}
export interface SimpleAckPayload extends BasicServicePayload {
    success: boolean;
}
export interface CovNotifyPayload extends BasicServicePayload {
    subscriberProcessId: number;
    initiatingDeviceId: number;
    monitoredObjectId: BACNetObjectID;
    timeRemaining: number;
    values: Array<{
        property: PropertyReference;
        value: BACNetAppData[];
    }>;
}
export interface AtomicFilePayload extends BasicServicePayload {
    fileStartPosition: number;
    fileData?: Buffer | number[][];
    endOfFile?: boolean;
    fileSize?: number;
}
export interface SubscribeCovPayload extends BasicServicePayload {
    subscriberProcessId: number;
    monitoredObjectId: BACNetObjectID;
    issueConfirmedNotifications: boolean;
    lifetime: number;
}
export interface DeviceCommunicationControlPayload extends BasicServicePayload {
    timeDuration: number;
    enable: boolean;
    password?: string;
}
export interface ReinitializeDevicePayload extends BasicServicePayload {
    reinitializedStateOfDevice: number;
    password?: string;
}
export interface EventNotificationPayload extends BasicServicePayload {
    processIdentifier: number;
    initiatingDeviceIdentifier: BACNetObjectID;
    eventObjectIdentifier: BACNetObjectID;
    timeStamp: BACNetTimestamp;
    notificationClass: number;
    priority: number;
    eventType: EventType;
    messageText?: string;
    notifyType: NotifyType;
    ackRequired: boolean;
    fromState: number;
    toState: number;
    eventValues: BACNetAppData[];
}
export interface ReadRangePayload extends BasicServicePayload {
    objectId: BACNetObjectID;
    propertyId: PropertyIdentifier;
    position: number;
    count: number;
    values: BACNetAppData[];
}
export interface LogStatusFlags {
    log_disabled: boolean;
    buffer_purged: boolean;
    log_interrupted: boolean;
}
export interface LogRecordStatusFlags {
    out_of_service: boolean;
    overridden: boolean;
    fault: boolean;
    in_alarm: boolean;
}
export type LogRecordValue = number | boolean | BACNetBitString | null | string | BACNetObjectID;
export interface LogRecord {
    timestamp: Date;
    value: LogRecordValue;
    isLogStatus?: boolean;
    isTimeChange?: boolean;
    logStatus?: LogStatusFlags;
    status?: LogRecordStatusFlags;
}
export interface ReadRangeAcknowledge {
    objectId: BACNetObjectID;
    property: BACNetPropertyID;
    resultFlag: BACNetBitString;
    itemCount: number;
    rangeBuffer: Buffer;
    values?: LogRecord[];
    len: number;
}
export interface EnrollmentSummary {
    objectId: BACNetObjectID;
    eventType: number;
    eventState: number;
    priority: number;
    notificationClass: number;
}
export interface EnrollmentOptions extends ServiceOptions {
    enrollmentFilter?: EnrollmentFilter;
    eventStateFilter?: number;
    eventTypeFilter?: number;
    priorityFilter?: PriorityFilter;
    notificationClassFilter?: number;
}
export interface EnrollmentFilter {
    objectId: BACNetObjectID;
    processId: number;
}
export interface PriorityFilter {
    min: number;
    max: number;
}
export interface EnrollmentSummaryAcknowledge {
    enrollmentSummaries: EnrollmentSummary[];
    len: number;
}
export interface EventNotifyDataParams {
    processId: number;
    initiatingObjectId: {
        type: number;
        instance: number;
    };
    eventObjectId: {
        type: number;
        instance: number;
    };
    timeStamp: {
        type: TimeStamp;
        value: Date | number;
    };
    notificationClass: number;
    priority: number;
    eventType: EventType;
    messageText?: string;
    notifyType: NotifyType;
    ackRequired?: boolean;
    fromState?: number;
    toState: number;
    changeOfBitstringReferencedBitString?: BACNetBitString;
    changeOfBitstringStatusFlags?: BACNetBitString;
    changeOfStateNewState?: BACNetPropertyState;
    changeOfStateStatusFlags?: BACNetBitString;
    changeOfValueTag?: CovType;
    changeOfValueChangeValue?: number;
    changeOfValueChangedBits?: BACNetBitString;
    changeOfValueStatusFlags?: BACNetBitString;
    floatingLimitReferenceValue?: number;
    floatingLimitStatusFlags?: BACNetBitString;
    floatingLimitSetPointValue?: number;
    floatingLimitErrorLimit?: number;
    outOfRangeExceedingValue?: number;
    outOfRangeStatusFlags?: BACNetBitString;
    outOfRangeDeadband?: number;
    outOfRangeExceededLimit?: number;
    changeOfLifeSafetyNewState?: number;
    changeOfLifeSafetyNewMode?: number;
    changeOfLifeSafetyStatusFlags?: BACNetBitString;
    changeOfLifeSafetyOperationExpected?: number;
    bufferReadyBufferProperty?: BACNetDevObjRef;
    bufferReadyPreviousNotification?: number;
    bufferReadyCurrentNotification?: number;
    unsignedRangeExceedingValue?: number;
    unsignedRangeStatusFlags?: BACNetBitString;
    unsignedRangeExceededLimit?: number;
}
export interface EventNotifyDataResult extends EventNotifyDataParams {
    len: number;
}
export interface ObjectOperationPayload extends BasicServicePayload {
    objectId: BACNetObjectID;
    propertyValues?: Array<{
        property: PropertyReference;
        value: BACNetAppData[];
        priority?: number;
    }>;
}
export interface ListElementOperationPayload extends BasicServicePayload {
    objectId: BACNetObjectID;
    propertyId: PropertyIdentifier;
    arrayIndex: number;
    listOfElements: BACNetAppData[];
}
export interface PrivateTransferPayload extends BasicServicePayload {
    vendorId: number;
    serviceNumber: number;
    data: any;
}
export interface RegisterForeignDevicePayload extends BasicServicePayload {
    ttl: number;
}
export interface BvlcResultPayload extends BasicServicePayload {
    resultCode: number;
}
export interface WhoHasPayload extends BasicServicePayload {
    lowLimit?: number;
    highLimit?: number;
    objectId?: BACNetObjectID;
    objectName?: string;
}
export interface IHavePayload extends BasicServicePayload {
    deviceId: BACNetObjectID;
    objectId: BACNetObjectID;
    objectName: string;
}
export interface TimeSyncPayload extends BasicServicePayload {
    dateTime: Date;
}
export type ServiceResponse<T> = (content: {
    header?: BACnetMessageHeader;
    payload: T;
}) => void;
export interface BacnetService {
    encode: (buffer: EncodeBuffer, ...args: any[]) => void;
    decode: (buffer: Buffer, offset: number, apduLen: number) => Decode<any>;
}
export interface PropertyResult {
    id: PropertyIdentifier;
    index: number;
    value: ApplicationData[];
}
export interface DeviceObjectResult {
    values: Array<{
        objectId: BACNetObjectID;
        values: PropertyResult[];
    }>;
}
export interface WritePropertyMultipleValue {
    property: PropertyReference;
    value: BACNetAppData[];
    priority: number;
}
export interface WritePropertyMultipleObject {
    objectId: BACNetObjectID;
    values: WritePropertyMultipleValue[];
}
export interface DecodeAtomicWriteFileResult {
    len: number;
    isStream: boolean;
    position: number;
}
export interface DecodeAtomicReadFileResult {
    len: number;
    endOfFile: boolean;
    isStream: boolean;
    position: number;
    buffer: Buffer;
}
export interface NetworkOpResult {
    msg: any;
    buffer: Buffer;
    offset: number;
    length: number;
}