@smarthome.exchange/integrations 1.0.0 → 3.0.0

package/dist_ts/integrations/modbus/modbus.types.d.ts

@@ -1,341 +1,91 @@
-export type TModbusTransport = 'tcp' | 'udp' | 'rtuovertcp' | 'serial';
-export type TModbusRegisterType = 'holding' | 'input';
-export type TModbusCoilType = 'coil' | 'discrete_input';
-export type TModbusDataType = 'custom' | 'string' | 'int' | 'integer' | 'int16' | 'int32' | 'int64' | 'uint' | 'uint16' | 'uint32' | 'uint64' | 'float' | 'float16' | 'float32' | 'float64';
-export type TModbusSwap = 'byte' | 'word' | 'word_byte';
-export type TModbusEntityPlatform = 'sensor' | 'binary_sensor' | 'switch' | 'number';
-export type TModbusEventType = 'snapshot_refreshed' | 'command_mapped' | 'command_executed' | 'command_failed' | 'register_read' | 'register_written' | 'coil_read' | 'coil_written';
-export interface IModbusConfig {
-    hubs?: IModbusHubConfig[];
-    modbus?: IModbusHubConfig[];
-    snapshot?: IModbusSnapshot;
-    manualEntries?: IModbusManualTcpEntry[];
-    connected?: boolean;
-    timeoutMs?: number;
-    commandExecutor?: (commandArg: IModbusCommand) => Promise<IModbusCommandResult | unknown>;
-}
-export interface IHomeAssistantModbusConfig extends IModbusConfig {
-}
-export interface IModbusHubConfig {
-    id?: string;
-    name?: string;
-    type?: TModbusTransport;
-    host?: string;
-    port?: number | string;
-    timeout?: number;
-    timeoutMs?: number;
-    delay?: number;
-    messageWaitMilliseconds?: number;
-    message_wait_milliseconds?: number;
-    slave?: number;
-    unit?: number;
-    unitId?: number;
-    deviceAddress?: number;
-    device_address?: number;
-    connected?: boolean;
-    manufacturer?: string;
-    model?: string;
-    serialNumber?: string;
-    serial_number?: string;
-    metadata?: Record<string, unknown>;
-    slaves?: IModbusSlaveConfig[];
-    registers?: IModbusRegisterConfig[];
-    coils?: IModbusCoilConfig[];
-    sensors?: IModbusRegisterConfig[];
-    binarySensors?: IModbusCoilConfig[];
-    binary_sensors?: IModbusCoilConfig[];
-    switches?: IModbusSwitchConfig[];
-    numbers?: IModbusNumberConfig[];
-}
-export interface IModbusSlaveConfig {
-    id?: string;
-    unitId?: number;
-    unit?: number;
-    slave?: number;
-    deviceAddress?: number;
-    device_address?: number;
-    name?: string;
-    connected?: boolean;
-    manufacturer?: string;
-    model?: string;
-    serialNumber?: string;
-    serial_number?: string;
-    metadata?: Record<string, unknown>;
-}
-export interface IModbusEntityConfigBase {
-    id?: string;
-    name: string;
-    uniqueId?: string;
-    unique_id?: string;
-    platform?: TModbusEntityPlatform;
-    address: number;
-    slave?: number;
-    unit?: number;
-    unitId?: number;
-    deviceAddress?: number;
-    device_address?: number;
-    scanInterval?: number;
-    scan_interval?: number;
-    deviceClass?: string;
-    device_class?: string;
-    available?: boolean;
-    metadata?: Record<string, unknown>;
-}
-export interface IModbusRegisterConfig extends IModbusEntityConfigBase {
-    platform?: 'sensor' | 'number';
-    inputType?: TModbusRegisterType;
-    input_type?: TModbusRegisterType;
-    registerType?: TModbusRegisterType;
-    register_type?: TModbusRegisterType;
-    count?: number;
-    dataType?: TModbusDataType;
-    data_type?: TModbusDataType;
-    structure?: string;
-    scale?: number;
-    offset?: number;
-    precision?: number;
-    swap?: TModbusSwap;
-    unitOfMeasurement?: string;
-    unit_of_measurement?: string;
-    stateClass?: string;
-    state_class?: string;
-    minValue?: number;
-    min_value?: number;
-    maxValue?: number;
-    max_value?: number;
-    nanValue?: number;
-    nan_value?: number;
-    zeroSuppress?: number;
-    zero_suppress?: number;
-    min?: number;
-    max?: number;
-    step?: number;
-    writable?: boolean;
-    value?: number | string | null;
-    registers?: number[];
-}
-export interface IModbusNumberConfig extends IModbusRegisterConfig {
-    platform?: 'number';
-    writable?: true;
-}
-export interface IModbusCoilConfig extends IModbusEntityConfigBase {
-    platform?: 'binary_sensor' | 'switch';
-    inputType?: TModbusCoilType | TModbusRegisterType;
-    input_type?: TModbusCoilType | TModbusRegisterType;
-    coilType?: TModbusCoilType;
-    coil_type?: TModbusCoilType;
-    count?: number;
-    slaveCount?: number;
-    slave_count?: number;
-    virtualCount?: number;
-    virtual_count?: number;
-    writable?: boolean;
-    value?: boolean | number | null;
-    bits?: boolean[];
-}
-export interface IModbusSwitchConfig extends IModbusCoilConfig {
-    platform?: 'switch';
-    writeType?: TModbusWriteType;
-    write_type?: TModbusWriteType;
-    commandOn?: number;
-    command_on?: number;
-    commandOff?: number;
-    command_off?: number;
-    stateOn?: number[];
-    state_on?: number[];
-    stateOff?: number[];
-    state_off?: number[];
-    verify?: IModbusSwitchVerifyConfig | null;
-}
-export interface IModbusSwitchVerifyConfig {
-    address?: number;
-    inputType?: TModbusCoilType | TModbusRegisterType;
-    input_type?: TModbusCoilType | TModbusRegisterType;
-    delay?: number;
-    stateOn?: number[];
-    state_on?: number[];
-    stateOff?: number[];
-    state_off?: number[];
+import type * as plugins from '../../plugins.js';
+import type { INativeIntegrationOwnerOptions } from '../../core/classes.nativeintegrationowner.js';
+export interface IModbusIntegrationOptions extends INativeIntegrationOwnerOptions {
+}
+export interface IModbusMappingBase {
+    readonly id: string;
+    readonly name: string;
+    /** Zero-based wire address; no 40001 notation or vendor interpretation. */
+    readonly address: number;
+    readonly quantity?: number;
+}
+export interface IModbusCoilMapping extends IModbusMappingBase {
+    readonly kind: 'coil';
+    /** Owner permission for one absolute FC5 write. Requires quantity one. */
+    readonly write?: true;
+}
+export interface IModbusDiscreteInputMapping extends IModbusMappingBase {
+    readonly kind: 'discrete_input';
+}
+export interface IModbusHoldingRegisterMapping extends IModbusMappingBase {
+    readonly kind: 'holding';
+    /** Inclusive unsigned raw bounds for one FC6 write. Requires quantity one. */
+    readonly write?: {
+        readonly minimum: number;
+        readonly maximum: number;
+    };
 }
-export type TModbusWriteType = 'holding' | 'holdings' | 'coil' | 'coils';
-export interface IModbusRegisterState {
-    hubId?: string;
-    unitId: number;
-    address: number;
-    count: number;
-    inputType: TModbusRegisterType;
-    dataType: TModbusDataType;
-    registers?: number[];
-    value?: number | string | number[] | null;
-    updatedAt?: string;
-    metadata?: Record<string, unknown>;
+export interface IModbusInputRegisterMapping extends IModbusMappingBase {
+    readonly kind: 'input';
 }
-export interface IModbusCoilState {
-    hubId?: string;
-    unitId: number;
-    address: number;
-    count: number;
-    inputType: TModbusCoilType | TModbusRegisterType;
-    bits?: boolean[];
-    value?: boolean | number | null;
-    updatedAt?: string;
-    metadata?: Record<string, unknown>;
+export type TModbusMapping = IModbusCoilMapping | IModbusDiscreteInputMapping | IModbusHoldingRegisterMapping | IModbusInputRegisterMapping;
+export type TModbusNormalizedMapping = TModbusMapping & {
+    readonly quantity: number;
+};
+export interface IModbusConfig {
+    readonly homeId: string;
+    readonly address: string;
+    readonly unitId: number;
+    readonly expectedVendorName: string;
+    readonly expectedProductCode: string;
+    readonly expectedRevision?: string;
+    readonly allowUnencryptedLan: true;
+    readonly mappings: readonly TModbusMapping[];
+    readonly port?: number;
+    readonly localAddress?: string;
+    readonly name?: string;
+    readonly timeoutMs?: number;
+    readonly maxQueuedOperations?: number;
 }
-export interface IModbusEntitySnapshot {
-    id: string;
-    name: string;
-    uniqueId: string;
-    platform: TModbusEntityPlatform;
-    hubId: string;
-    hubName: string;
-    unitId: number;
-    address: number;
-    available: boolean;
-    writable: boolean;
-    register?: IModbusRegisterState;
-    coil?: IModbusCoilState;
-    state?: unknown;
-    attributes?: Record<string, unknown>;
+export interface IHomeAssistantModbusConfig extends IModbusConfig {
 }
-export interface IModbusSlaveSnapshot {
-    id: string;
-    hubId: string;
-    unitId: number;
-    name: string;
-    online: boolean;
-    manufacturer?: string;
-    model?: string;
-    serialNumber?: string;
-    registers: IModbusRegisterState[];
-    coils: IModbusCoilState[];
-    metadata?: Record<string, unknown>;
+export interface IModbusNormalizedConfig extends Omit<IModbusConfig, 'mappings' | 'port' | 'timeoutMs' | 'maxQueuedOperations'> {
+    readonly mappings: readonly TModbusNormalizedMapping[];
+    readonly port: number;
+    readonly timeoutMs: number;
+    readonly maxQueuedOperations: number;
 }
-export interface IModbusHubSnapshot {
-    id: string;
-    name: string;
-    type: TModbusTransport;
-    host?: string;
-    port?: number | string;
-    online: boolean;
-    manufacturer?: string;
-    model?: string;
-    serialNumber?: string;
-    unsupportedReason?: string;
-    slaves: IModbusSlaveSnapshot[];
-    registers: IModbusRegisterState[];
-    coils: IModbusCoilState[];
-    entities: IModbusEntitySnapshot[];
-    metadata?: Record<string, unknown>;
+export interface IModbusObservation {
+    readonly mapping: TModbusNormalizedMapping;
+    readonly identity: plugins.ecobridgeDeviceManager.IModbusIdentity;
+    readonly values: readonly boolean[] | readonly number[];
+    readonly observedAt: string;
 }
 export interface IModbusSnapshot {
-    hubs: IModbusHubSnapshot[];
-    events: IModbusEvent[];
-    connected: boolean;
-    updatedAt: string;
-    raw?: Record<string, unknown>;
-}
-export interface IModbusEvent {
-    type: TModbusEventType;
-    command?: IModbusCommand;
-    hubId?: string;
-    hubName?: string;
-    unitId?: number;
-    entityId?: string;
-    deviceId?: string;
-    uniqueId?: string;
-    data?: unknown;
-    timestamp: number;
-}
-export type IModbusCommand = IModbusRefreshCommand | IModbusReadRegisterCommand | IModbusWriteRegisterCommand | IModbusReadCoilCommand | IModbusWriteCoilCommand | IModbusStopCommand | IModbusRestartCommand;
-export interface IModbusCommandBase {
-    hub?: string;
-    hubId?: string;
-    unitId?: number;
-    slave?: number;
-    entityId?: string;
-    deviceId?: string;
-    uniqueId?: string;
-}
-export interface IModbusRefreshCommand extends IModbusCommandBase {
-    type: 'refresh';
-}
-export interface IModbusStopCommand extends IModbusCommandBase {
-    type: 'stop';
-}
-export interface IModbusRestartCommand extends IModbusCommandBase {
-    type: 'restart';
-}
-export interface IModbusReadRegisterCommand extends IModbusCommandBase {
-    type: 'read_register';
-    address: number;
-    count?: number;
-    inputType?: TModbusRegisterType;
-    dataType?: TModbusDataType;
-}
-export interface IModbusWriteRegisterCommand extends IModbusCommandBase {
-    type: 'write_register';
-    address: number;
-    value: number | number[];
-}
-export interface IModbusReadCoilCommand extends IModbusCommandBase {
-    type: 'read_coil';
-    address: number;
-    count?: number;
-    inputType?: TModbusCoilType;
-}
-export interface IModbusWriteCoilCommand extends IModbusCommandBase {
-    type: 'write_coil';
-    address: number;
-    value: boolean | boolean[] | number | number[];
-}
-export interface IModbusCommandResult {
-    success: boolean;
-    error?: string;
-    data?: unknown;
-}
-export interface IModbusTcpCommandShape {
-    transport: 'tcp';
-    host?: string;
-    port?: number;
-    unitId: number;
-    transactionId: number;
-    functionCode: number;
-    functionName: string;
-    address?: number;
-    quantity?: number;
-    values?: number[] | boolean[];
-    mbap: {
-        transactionId: number;
-        protocolId: 0;
-        length: number;
-        unitId: number;
-    };
-    pduHex: string;
-    requestHex: string;
-}
-export interface IModbusTcpResponse {
-    transactionId: number;
-    unitId: number;
-    functionCode: number;
-    registers?: number[];
-    bits?: boolean[];
-    address?: number;
-    quantity?: number;
-    rawHex: string;
-}
+    readonly config: IModbusNormalizedConfig;
+    readonly identity: plugins.ecobridgeDeviceManager.IModbusIdentity;
+    readonly observations: readonly IModbusObservation[];
+    readonly observedAt: string;
+}
+export type TModbusCommand = {
+    readonly type: 'read';
+    readonly mappingId: string;
+} | {
+    readonly type: 'write_coil';
+    readonly mappingId: string;
+    readonly value: boolean;
+} | {
+    readonly type: 'write_register';
+    readonly mappingId: string;
+    readonly value: number;
+};
 export interface IModbusManualTcpEntry {
-    host?: string;
-    port?: number;
-    type?: TModbusTransport;
-    protocol?: string;
-    name?: string;
-    id?: string;
-    unitId?: number;
-    slave?: number;
-    manufacturer?: string;
-    model?: string;
-    serialNumber?: string;
-    metadata?: Record<string, unknown>;
-}
-export interface IModbusDiscoveryEntry extends IModbusManualTcpEntry {
+    readonly integrationDomain: 'modbus';
+    readonly address: string;
+    readonly unitId: number;
+    readonly expectedVendorName: string;
+    readonly expectedProductCode: string;
+    readonly expectedRevision?: string;
+    readonly port?: number;
+    readonly name?: string;
 }

package/dist_ts/integrations/modbus/modbus.validation.d.ts

@@ -0,0 +1,10 @@
+import type { IModbusNormalizedConfig, TModbusCommand, TModbusNormalizedMapping } from './modbus.types.js';
+export declare function modbusRecord(valueArg: unknown, allowedArg?: readonly string[]): Record<string, unknown>;
+export declare function modbusText(valueArg: unknown, nameArg: string, maximumArg?: number): string;
+export declare function modbusIdentityText(valueArg: unknown): string;
+export declare function modbusAddress(valueArg: unknown): string;
+export declare function modbusInteger(valueArg: unknown, minimumArg: number, maximumArg: number): number;
+export declare function modbusUnit(valueArg: unknown): number;
+export declare function normalizeModbusConfig(valueArg: unknown): IModbusNormalizedConfig;
+export declare function modbusMappings(valueArg: unknown): readonly TModbusNormalizedMapping[];
+export declare function modbusCommand(valueArg: unknown, configArg: IModbusNormalizedConfig): TModbusCommand;

package/dist_ts/integrations/modbus/modbus.validation.js

@@ -0,0 +1,128 @@
+import * as plugins from '../../plugins.js';
+export function modbusRecord(valueArg, allowedArg) {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg) || ![Object.prototype, null].includes(Object.getPrototypeOf(valueArg))) {
+        throw new TypeError('Modbus inputs must be plain data objects.');
+    }
+    const result = {};
+    for (const key of Reflect.ownKeys(valueArg)) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (typeof key !== 'string' || allowedArg && !allowedArg.includes(key) || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+            throw new TypeError('Modbus inputs may not contain accessors, symbols, hidden or unsupported fields.');
+        }
+        Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+    }
+    return result;
+}
+export function modbusText(valueArg, nameArg, maximumArg = 256) {
+    if (typeof valueArg !== 'string' || !valueArg.length || valueArg.length > maximumArg || valueArg !== valueArg.trim() || /[\p{Cc}\p{Cs}]/u.test(valueArg)) {
+        throw new TypeError(`Modbus ${nameArg} requires bounded nonempty text without control characters.`);
+    }
+    return valueArg;
+}
+export function modbusIdentityText(valueArg) {
+    if (typeof valueArg !== 'string' || !/^[\x20-\x7e]{1,244}$/.test(valueArg))
+        throw new TypeError('Modbus identity requires exact bounded printable ASCII text.');
+    return valueArg;
+}
+export function modbusAddress(valueArg) {
+    if (typeof valueArg !== 'string' || plugins.net.isIP(valueArg) !== 4)
+        throw new TypeError('Modbus requires an explicitly selected local IPv4 address.');
+    const parts = valueArg.split('.').map(Number);
+    const local = parts[0] === 10 || parts[0] === 127 || parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31 ||
+        parts[0] === 192 && parts[1] === 168 || parts[0] === 169 && parts[1] === 254;
+    if (!local || parts[3] === 255)
+        throw new TypeError('Modbus requires a private, link-local or loopback unicast IPv4 address.');
+    return valueArg;
+}
+export function modbusInteger(valueArg, minimumArg, maximumArg) {
+    if (typeof valueArg !== 'number' || !Number.isSafeInteger(valueArg) || valueArg < minimumArg || valueArg > maximumArg) {
+        throw new TypeError(`Modbus value must be an integer from ${minimumArg} through ${maximumArg}.`);
+    }
+    return valueArg;
+}
+export function modbusUnit(valueArg) {
+    const unit = modbusInteger(valueArg, 1, 255);
+    if (unit > 247 && unit !== 255)
+        throw new TypeError('Modbus requires an explicit unit 1–247 or direct TCP unit 255.');
+    return unit;
+}
+export function normalizeModbusConfig(valueArg) {
+    const value = modbusRecord(valueArg, ['homeId', 'address', 'unitId', 'expectedVendorName', 'expectedProductCode', 'expectedRevision',
+        'allowUnencryptedLan', 'mappings', 'port', 'localAddress', 'name', 'timeoutMs', 'maxQueuedOperations']);
+    if (value.allowUnencryptedLan !== true)
+        throw new TypeError('Modbus requires explicit acceptance of unencrypted LAN transport.');
+    const mappings = modbusMappings(value.mappings);
+    return Object.freeze({
+        homeId: modbusText(value.homeId, 'homeId'), address: modbusAddress(value.address), unitId: modbusUnit(value.unitId),
+        expectedVendorName: modbusIdentityText(value.expectedVendorName), expectedProductCode: modbusIdentityText(value.expectedProductCode),
+        ...(value.expectedRevision === undefined ? {} : { expectedRevision: modbusIdentityText(value.expectedRevision) }),
+        ...(value.localAddress === undefined ? {} : { localAddress: modbusAddress(value.localAddress) }),
+        ...(value.name === undefined ? {} : { name: modbusText(value.name, 'name', 128) }), allowUnencryptedLan: true,
+        port: modbusInteger(value.port === undefined ? 502 : value.port, 1, 65535),
+        timeoutMs: modbusInteger(value.timeoutMs === undefined ? 5000 : value.timeoutMs, 1, 60000),
+        maxQueuedOperations: modbusInteger(value.maxQueuedOperations === undefined ? 16 : value.maxQueuedOperations, 1, 128), mappings,
+    });
+}
+export function modbusMappings(valueArg) {
+    if (!Array.isArray(valueArg) || valueArg.length < 1 || valueArg.length > 64)
+        throw new TypeError('Modbus requires one through 64 explicit owner read mappings.');
+    if (Reflect.ownKeys(valueArg).some((key) => key !== 'length' && (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key))))
+        throw new TypeError('Modbus mapping lists contain only indexed data entries.');
+    const mappings = [];
+    for (let index = 0; index < valueArg.length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+        if (!descriptor || !('value' in descriptor) || !descriptor.enumerable)
+            throw new TypeError('Modbus mappings must be dense enumerable data entries.');
+        const value = modbusRecord(descriptor.value, ['id', 'name', 'address', 'quantity', 'kind', 'write']);
+        const id = modbusText(value.id, 'mapping id', 64);
+        if (!/^[a-z0-9][a-z0-9_-]*$/.test(id))
+            throw new TypeError('Modbus mapping IDs require lowercase letters, digits, underscore or hyphen.');
+        const name = modbusText(value.name, 'mapping name', 128);
+        const address = modbusInteger(value.address, 0, 65535);
+        const kind = value.kind;
+        if (kind !== 'coil' && kind !== 'discrete_input' && kind !== 'holding' && kind !== 'input')
+            throw new TypeError('Modbus mapping kind is unsupported.');
+        const quantity = modbusInteger(value.quantity === undefined ? 1 : value.quantity, 1, kind === 'coil' || kind === 'discrete_input' ? 2000 : 125);
+        if (address + quantity > 65536)
+            throw new TypeError('Modbus mapping exceeds the zero-based address space.');
+        if (mappings.some((mapping) => mapping.id === id || mapping.kind === kind && address < mapping.address + mapping.quantity && mapping.address < address + quantity)) {
+            throw new TypeError('Modbus mappings require unique IDs and nonoverlapping ranges per read kind.');
+        }
+        let mapping;
+        if (value.write === undefined)
+            mapping = { id, name, address, quantity, kind };
+        else {
+            if (quantity !== 1)
+                throw new TypeError('Modbus write permission requires one absolute mapped address.');
+            if (kind === 'coil' && value.write === true)
+                mapping = { id, name, address, quantity, kind, write: true };
+            else if (kind === 'holding') {
+                const write = modbusRecord(value.write, ['minimum', 'maximum']);
+                const minimum = modbusInteger(write.minimum, 0, 65535);
+                const maximum = modbusInteger(write.maximum, minimum, 65535);
+                mapping = { id, name, address, quantity, kind, write: Object.freeze({ minimum, maximum }) };
+            }
+            else
+                throw new TypeError('Modbus permits explicit single-coil or bounded single-holding-register writes only.');
+        }
+        mappings.push(Object.freeze(mapping));
+    }
+    return Object.freeze(mappings);
+}
+export function modbusCommand(valueArg, configArg) {
+    const value = modbusRecord(valueArg, ['type', 'mappingId', 'value']);
+    const mappingId = modbusText(value.mappingId, 'mapping id', 64);
+    const mapping = configArg.mappings.find((entry) => entry.id === mappingId);
+    if (!mapping)
+        throw new TypeError('Modbus command must target one explicitly owned read mapping.');
+    if (value.type === 'read' && !Object.hasOwn(value, 'value'))
+        return Object.freeze({ type: 'read', mappingId });
+    if (value.type === 'write_coil' && mapping.kind === 'coil' && mapping.write === true && typeof value.value === 'boolean') {
+        return Object.freeze({ type: 'write_coil', mappingId, value: value.value });
+    }
+    if (value.type === 'write_register' && mapping.kind === 'holding' && mapping.write !== undefined) {
+        return Object.freeze({ type: 'write_register', mappingId, value: modbusInteger(value.value, mapping.write.minimum, mapping.write.maximum) });
+    }
+    throw new TypeError('Modbus command is outside the explicit mapping write permission or absolute raw value contract.');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modbus.validation.js","sourceRoot":"","sources":["../../../ts/integrations/modbus/modbus.validation.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/mqtt/mqtt.classes.client.d.ts

@@ -1,25 +1,32 @@
-import type { IMqttConfig, IMqttConnectionState, IMqttMessage, IMqttPublishOptions, IMqttSnapshot } from './mqtt.types.js';
+import type { IMqttConfig, IMqttConnectionState, IMqttMessage, IMqttPublishOptions, IMqttSnapshot, IMqttTransportCredentials } from './mqtt.types.js';
 type TMqttMessageHandler = (messageArg: IMqttMessage) => void;
 type TMqttStateHandler = (stateArg: IMqttConnectionState) => void;
 export declare const mqttTopicMatches: (filterArg: string, topicArg: string) => boolean;
 export declare const validateMqttTopic: (topicArg: string, filterArg?: boolean) => void;
 export declare class MqttClient {
     private readonly config;
+    private readonly credentials;
     private client?;
     private startPromise?;
     private destroyPromise?;
     private cleanupPromise;
+    private retryPromise?;
+    private readonly transportCleanups;
     private destroyed;
     private ready;
     private hasStarted;
     private generation;
+    private currentGeneration?;
+    private currentStream?;
     private readonly subscriptions;
     private readonly messageHandlers;
     private readonly stateHandlers;
     private readonly messages;
+    private readonly currentMessageTopics;
     private readonly persistentTopics;
     private readonly brokerTopics;
     private readonly pendingOperations;
+    private readonly publications;
     private topicSync?;
     private topicSyncRequested;
     private bufferedBytes;
@@ -28,16 +35,20 @@ export declare class MqttClient {
     private readonly maxMessageTopics;
     private readonly maxPayloadBytes;
     private readonly maxBufferedBytes;
-    constructor(config: IMqttConfig);
+    constructor(config: IMqttConfig, credentials?: IMqttTransportCredentials);
     get connected(): boolean;
     isHealthy(): boolean;
     onConnectionState(handlerArg: TMqttStateHandler): () => void;
     onMessage(handlerArg: TMqttMessageHandler): () => void;
     getSnapshot(abortSignalArg?: AbortSignal): Promise<IMqttSnapshot>;
+    /** Live broker observations only, including arrivals before readiness; never starts a transport. */
+    getCurrentSnapshot(): IMqttMessage[];
     start(abortSignalArg?: AbortSignal): Promise<void>;
     publish(optionsArg: IMqttPublishOptions, abortSignalArg?: AbortSignal): Promise<void>;
     subscribe(topicArg: string, handlerArg?: TMqttMessageHandler, abortSignalArg?: AbortSignal): Promise<() => Promise<void>>;
     destroy(): Promise<void>;
+    /** Retry retained close handles only; this never admits a connection or replays application effects. */
+    retryCleanup(): Promise<void>;
     private startConnection;
     private initializeConnection;
     private synchronizeTopics;
@@ -45,9 +56,11 @@ export declare class MqttClient {
     private handleMessage;
     private storeMessage;
     private removeMessage;
+    private clearCurrentGeneration;
     private destroyConnection;
     private failConnection;
     private closeClient;
+    private performClientClose;
     private bounded;
     private rejectOperations;
     private emitState;