ZCLIP.js

A javascript implementation of ZCL over IP.

* Installation
* Examples
* API
* Supported Clusters
* Run the tests
* Support

Installation

``sh
npm install zclip
`

Examples

Examples are located in /examples

`sh
var coap = require('coap');
var zcl = require('../.')(coap);

var deviceIp = '::1';
var clusterEndpoint = 1;

var onOff = zcl.clusters.OnOff({
ip: deviceIp,
endpoint: clusterEndpoint
});

onOff.on({}, (err, response) => {
if (err) {
console.error(err);
}

console.log(response.code);
});
`

API

`javascript
var alarmsCluster = zcl.clusters.Alarms({
ip: ,
endpoint:
});
`
#### alarms.bind

`javascript
alarmsCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### alarms.read

`javascript
alarmsCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* alarmCount \ \(server)
* responseCode


#### alarms.alarm

`javascript
alarms.alarm(args, callback);
`
* args
* alarmCode \
* clusterId \
* callback
* err
* response
* responseCode


#### alarms.getAlarmResponse

`javascript
alarms.getAlarmResponse(args, callback);
`
* args
* status \
* alarmCode \
* clusterId \
* timeStamp \
* callback
* err
* response
* responseCode


#### alarms.getAlarm

`javascript
alarms.getAlarm(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### alarms.resetAlarmLog

`javascript
alarms.resetAlarmLog(args, callback);
`
* args - None
* callback
* err
* response
* responseCode

---

$3

`javascript
var applianceControlCluster = zcl.clusters.ApplianceControl({
ip: ,
endpoint:
});
`
#### applianceControl.bind

`javascript
applianceControlCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### applianceControl.read

`javascript
applianceControlCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* startTime \ \(server)
* finishTime \ \(server)
* remainingTime \ \(server)
* responseCode


#### applianceControl.signalStateResponse

`javascript
applianceControl.signalStateResponse(args, callback);
`
* args
* applianceStatus \
* remoteEnableFlagsAndDeviceStatus2 \
* applianceStatus2 \
* callback
* err
* response
* responseCode


#### applianceControl.signalStateNotification

`javascript
applianceControl.signalStateNotification(args, callback);
`
* args
* applianceStatus \
* remoteEnableFlagsAndDeviceStatus2 \
* applianceStatus2 \
* callback
* err
* response
* responseCode


#### applianceControl.writeFunctions

`javascript
applianceControl.writeFunctions(args, callback);
`
* args
* functionId \
* functionDataType \
* functionData \
* callback
* err
* response
* responseCode


#### applianceControl.overloadPauseResume

`javascript
applianceControl.overloadPauseResume(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### applianceControl.overloadPause

`javascript
applianceControl.overloadPause(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### applianceControl.overloadWarning

`javascript
applianceControl.overloadWarning(args, callback);
`
* args
* warningEvent \
* callback
* err
* response
* responseCode

---

$3

`javascript
var applianceEventsAndAlertCluster = zcl.clusters.ApplianceEventsAndAlert({
ip: ,
endpoint:
});
`
#### applianceEventsAndAlert.bind

`javascript
applianceEventsAndAlertCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### applianceEventsAndAlert.read

`javascript
applianceEventsAndAlertCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### applianceEventsAndAlert.getAlertsResponse

`javascript
applianceEventsAndAlert.getAlertsResponse(args, callback);
`
* args
* alertsCount \
* alertStructures \
* callback
* err
* response
* responseCode


#### applianceEventsAndAlert.alertsNotification

`javascript
applianceEventsAndAlert.alertsNotification(args, callback);
`
* args
* alertsCount \
* alertStructures \
* callback
* err
* response
* responseCode


#### applianceEventsAndAlert.eventsNotification

`javascript
applianceEventsAndAlert.eventsNotification(args, callback);
`
* args
* eventHeader \
* eventId \
* callback
* err
* response
* responseCode

---

$3

`javascript
var applianceIdentificationCluster = zcl.clusters.ApplianceIdentification({
ip: ,
endpoint:
});
`
#### applianceIdentification.bind

`javascript
applianceIdentificationCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### applianceIdentification.read

`javascript
applianceIdentificationCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* basicIdentification \ \(server)
* companyName \ \(server)
* companyId \ \(server)
* brandName \ \(server)
* brandId \ \(server)
* model \ \(server)
* partNumber \ \(server)
* productRevision \ \(server)
* softwareRevision \ \(server)
* productTypeName \ \(server)
* productTypeId \ \(server)
* cecedSpecificationVersion \ \(server)
* responseCode

---

$3

`javascript
var applianceStatisticsCluster = zcl.clusters.ApplianceStatistics({
ip: ,
endpoint:
});
`
#### applianceStatistics.bind

`javascript
applianceStatisticsCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### applianceStatistics.read

`javascript
applianceStatisticsCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* logMaxSize \ \(server)
* logQueueMaxSize \ \(server)
* responseCode


#### applianceStatistics.logRequest

`javascript
applianceStatistics.logRequest(args, callback);
`
* args
* logId \
* callback
* err
* response
* responseCode


#### applianceStatistics.logQueueRequest

`javascript
applianceStatistics.logQueueRequest(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### applianceStatistics.logQueueResponse

`javascript
applianceStatistics.logQueueResponse(args, callback);
`
* args
* logQueueSize \
* logIds \
* callback
* err
* response
* responseCode


#### applianceStatistics.statisticsAvailable

`javascript
applianceStatistics.statisticsAvailable(args, callback);
`
* args
* logQueueSize \
* logIds \
* callback
* err
* response
* responseCode

---

$3

`javascript
var ballastConfigurationCluster = zcl.clusters.BallastConfiguration({
ip: ,
endpoint:
});
`
#### ballastConfiguration.bind

`javascript
ballastConfigurationCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### ballastConfiguration.read

`javascript
ballastConfigurationCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* physicalMinLevel \ \(server)
* physicalMaxLevel \ \(server)
* ballastStatus \ \(server)
* minLevel \ \(server)
* maxLevel \ \(server)
* powerOnLevel \ \(server)
* powerOnFadeTime \ \(server)
* intrinsicBallastFactor \ \(server)
* ballastFactorAdjustment \ \(server)
* lampQuality \ \(server)
* lampType \ \(server)
* lampManufacturer \ \(server)
* lampRatedHours \ \(server)
* lampBurnHours \ \(server)
* lampAlarmMode \ \(server)
* lampBurnHoursTripPoint \ \(server)
* responseCode

---

$3

`javascript
var basicCluster = zcl.clusters.Basic({
ip: ,
endpoint:
});
`
#### basic.bind

`javascript
basicCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### basic.read

`javascript
basicCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* zclVersion \ \(server)
* applicationVersion \ \(server)
* stackVersion \ \(server)
* hardwareVersion \ \(server)
* manufacturerName \ \(server)
* modelIdentifier \ \(server)
* dateCode \ \(server)
* powerSource \ \(server)
* genericDeviceClass \ \(server)
* genericDeviceType \ \(server)
* productCode \ \(server)
* productUrl \ \(server)
* locationDescription \ \(server)
* physicalEnvironment \ \(server)
* deviceEnabled \ \(server)
* alarmMask \ \(server)
* disableLocalConfig \ \(server)
* responseCode


#### basic.resetToFactoryDefaults

`javascript
basic.resetToFactoryDefaults(args, callback);
`
* args - None
* callback
* err
* response
* responseCode

---

$3

`javascript
var binaryInputBasicCluster = zcl.clusters.BinaryInputBasic({
ip: ,
endpoint:
});
`
#### binaryInputBasic.bind

`javascript
binaryInputBasicCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### binaryInputBasic.read

`javascript
binaryInputBasicCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* activeText \ \(server)
* description \ \(server)
* inactiveText \ \(server)
* outOfService \ \(server)
* polarity \ \(server)
* presentValue \ \(server)
* reliability \ \(server)
* statusFlags \ \(server)
* applicationType \ \(server)
* responseCode

---

$3

`javascript
var colorControlCluster = zcl.clusters.ColorControl({
ip: ,
endpoint:
});
`
#### colorControl.bind

`javascript
colorControlCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### colorControl.read

`javascript
colorControlCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* currentHue \ \(server)
* currentSaturation \ \(server)
* remainingTime \ \(server)
* currentX \ \(server)
* currentY \ \(server)
* driftCompensation \ \(server)
* compensationText \ \(server)
* colorTemperature \ \(server)
* colorMode \ \(server)
* colorControlOptions \ \(server)
* numberOfPrimaries \ \(server)
* primary1X \ \(server)
* primary1Y \ \(server)
* primary1Intensity \ \(server)
* primary2X \ \(server)
* primary2Y \ \(server)
* primary2Intensity \ \(server)
* primary3X \ \(server)
* primary3Y \ \(server)
* primary3Intensity \ \(server)
* primary4X \ \(server)
* primary4Y \ \(server)
* primary4Intensity \ \(server)
* primary5X \ \(server)
* primary5Y \ \(server)
* primary5Intensity \ \(server)
* primary6X \ \(server)
* primary6Y \ \(server)
* primary6Intensity \ \(server)
* whitePointX \ \(server)
* whitePointY \ \(server)
* colorPointRX \ \(server)
* colorPointRY \ \(server)
* colorPointRIntensity \ \(server)
* colorPointGX \ \(server)
* colorPointGY \ \(server)
* colorPointGIntensity \ \(server)
* colorPointBX \ \(server)
* colorPointBY \ \(server)
* colorPointBIntensity \ \(server)
* coupleColorTempToLevelMinMireds \ \(server)
* startUpColorTemperatureMireds \ \(server)
* responseCode


#### colorControl.moveToColorTemperature

`javascript
colorControl.moveToColorTemperature(args, callback);
`
* args
* colorTemperature \
* transitionTime \
* callback
* err
* response
* responseCode


#### colorControl.moveHue

`javascript
colorControl.moveHue(args, callback);
`
* args
* moveMode \
* rate \
* callback
* err
* response
* responseCode


#### colorControl.stepHue

`javascript
colorControl.stepHue(args, callback);
`
* args
* stepMode \
* stepSize \
* transitionTime \
* callback
* err
* response
* responseCode


#### colorControl.moveToSaturation

`javascript
colorControl.moveToSaturation(args, callback);
`
* args
* saturation \
* transitionTime \
* callback
* err
* response
* responseCode


#### colorControl.moveSaturation

`javascript
colorControl.moveSaturation(args, callback);
`
* args
* moveMode \
* rate \
* callback
* err
* response
* responseCode


#### colorControl.stepSaturation

`javascript
colorControl.stepSaturation(args, callback);
`
* args
* stepMode \
* stepSize \
* transitionTime \
* callback
* err
* response
* responseCode


#### colorControl.moveToHueAndSaturation

`javascript
colorControl.moveToHueAndSaturation(args, callback);
`
* args
* hue \
* saturation \
* transitionTime \
* callback
* err
* response
* responseCode


#### colorControl.moveToColor

`javascript
colorControl.moveToColor(args, callback);
`
* args
* colorx \
* colory \
* transitionTime \
* callback
* err
* response
* responseCode


#### colorControl.moveColor

`javascript
colorControl.moveColor(args, callback);
`
* args
* ratex \
* ratey \
* callback
* err
* response
* responseCode


#### colorControl.stepColor

`javascript
colorControl.stepColor(args, callback);
`
* args
* stepx \
* stepy \
* transitionTime \
* callback
* err
* response
* responseCode

---

$3

`javascript
var commissioningCluster = zcl.clusters.Commissioning({
ip: ,
endpoint:
});
`
#### commissioning.bind

`javascript
commissioningCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### commissioning.read

`javascript
commissioningCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* shortAddress \ \(server)
* extendedPanId \ \(server)
* panId \ \(server)
* channelMask \ \(server)
* protocolVersion \ \(server)
* stackProfile \ \(server)
* startupControl \ \(server)
* trustCenterAddress \ \(server)
* trustCenterMasterKey \ \(server)
* networkKey \ \(server)
* useInsecureJoin \ \(server)
* preconfiguredLinkKey \ \(server)
* networkKeySequenceNumber \ \(server)
* networkKeyType \ \(server)
* networkManagerAddress \ \(server)
* scanAttempts \ \(server)
* timeBetweenScans \ \(server)
* rejoinInterval \ \(server)
* maxRejoinInterval \ \(server)
* indirectPollRate \ \(server)
* parentRetryThreshold \ \(server)
* concentratorFlag \ \(server)
* concentratorRadius \ \(server)
* concentratorDiscoveryTime \ \(server)
* responseCode


#### commissioning.restartDeviceResponse

`javascript
commissioning.restartDeviceResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### commissioning.saveStartupParametersResponse

`javascript
commissioning.saveStartupParametersResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### commissioning.restoreStartupParametersResponse

`javascript
commissioning.restoreStartupParametersResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### commissioning.resetStartupParametersResponse

`javascript
commissioning.resetStartupParametersResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode

---

$3

`javascript
var dehumidificationControlCluster = zcl.clusters.DehumidificationControl({
ip: ,
endpoint:
});
`
#### dehumidificationControl.bind

`javascript
dehumidificationControlCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### dehumidificationControl.read

`javascript
dehumidificationControlCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* relativeHumidity \ \(server)
* dehumidificationCooling \ \(server)
* rhDehumidificationSetpoint \ \(server)
* relativeHumidityMode \ \(server)
* dehumidificationLockout \ \(server)
* dehumidificationHysteresis \ \(server)
* dehumidificationMaxCool \ \(server)
* relativeHumidityDisplay \ \(server)
* responseCode

---

$3

`javascript
var deviceTemperatureConfigurationCluster = zcl.clusters.DeviceTemperatureConfiguration({
ip: ,
endpoint:
});
`
#### deviceTemperatureConfiguration.bind

`javascript
deviceTemperatureConfigurationCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### deviceTemperatureConfiguration.read

`javascript
deviceTemperatureConfigurationCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* currentTemperature \ \(server)
* minTempExperienced \ \(server)
* maxTempExperienced \ \(server)
* overTempTotalDwell \ \(server)
* deviceTempAlarmMask \ \(server)
* lowTempThreshold \ \(server)
* highTempThreshold \ \(server)
* lowTempDwellTripPoint \ \(server)
* highTempDwellTripPoint \ \(server)
* responseCode

---

$3

`javascript
var diagnosticsCluster = zcl.clusters.Diagnostics({
ip: ,
endpoint:
});
`
#### diagnostics.bind

`javascript
diagnosticsCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### diagnostics.read

`javascript
diagnosticsCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* numberOfResets \ \(server)
* persistentMemoryWrites \ \(server)
* macRxBroadcast \ \(server)
* macTxBroadcast \ \(server)
* macRxUnicast \ \(server)
* macTxUnicast \ \(server)
* macTxUnicastRetry \ \(server)
* macTxUnicastFail \ \(server)
* apsRxBroadcast \ \(server)
* apsTxBroadcast \ \(server)
* apsRxUnicast \ \(server)
* apsUnicastSuccess \ \(server)
* apsTxUnicastRetries \ \(server)
* apsTxUnicastFailures \ \(server)
* routeDiscoveryInitiated \ \(server)
* neighborAdded \ \(server)
* neighborMoved \ \(server)
* neighborStale \ \(server)
* joinIndication \ \(server)
* childMoved \ \(server)
* networkFrameControlFailure \ \(server)
* apsFrameControlFailure \ \(server)
* apsUnauthorizedKey \ \(server)
* networkDecryptionFailure \ \(server)
* apsDecryptionFailure \ \(server)
* packetBufferAllocationFailures \ \(server)
* relayedUnicasts \ \(server)
* phyToMacQueueLimitReached \ \(server)
* packetValidateDropCount \ \(server)
* averageMacRetryPerApsMessageSent \ \(server)
* lastMessageLqi \ \(server)
* lastMessageRssi \ \(server)
* responseCode

---

$3

`javascript
var doorLockCluster = zcl.clusters.DoorLock({
ip: ,
endpoint:
});
`
#### doorLock.bind

`javascript
doorLockCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### doorLock.read

`javascript
doorLockCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* lockState \ \(server)
* lockType \ \(server)
* actuatorEnabled \ \(server)
* doorState \ \(server)
* doorOpenEvents \ \(server)
* doorClosedEvents \ \(server)
* openPeriod \ \(server)
* numLockRecordsSupported \ \(server)
* numTotalUsersSupported \ \(server)
* numPinUsersSupported \ \(server)
* numRfidUsersSupported \ \(server)
* numWeekdaySchedulesSupportedPerUser \ \(server)
* numYeardaySchedulesSupportedPerUser \ \(server)
* numHolidaySchedulesSupportedPerUser \ \(server)
* maxPinLength \ \(server)
* minPinLength \ \(server)
* maxRfidCodeLength \ \(server)
* minRfidCodeLength \ \(server)
* enableLogging \ \(server)
* language \ \(server)
* ledSettings \ \(server)
* autoRelockTime \ \(server)
* soundVolume \ \(server)
* operatingMode \ \(server)
* supportedOperatingModes \ \(server)
* defaultConfigurationRegister \ \(server)
* enableLocalProgramming \ \(server)
* enableOneTouchLocking \ \(server)
* enableInsideStatusLed \ \(server)
* enablePrivacyModeButton \ \(server)
* wrongCodeEntryLimit \ \(server)
* userCodeTemporaryDisableTime \ \(server)
* sendPinOverTheAir \ \(server)
* requirePinForRfOperation \ \(server)
* zigbeeSecurityLevel \ \(server)
* alarmMask \ \(server)
* keypadOperationEventMask \ \(server)
* rfOperationEventMask \ \(server)
* manualOperationEventMask \ \(server)
* rfidOperationEventMask \ \(server)
* keypadProgrammingEventMask \ \(server)
* rfProgrammingEventMask \ \(server)
* rfidProgrammingEventMask \ \(server)
* responseCode


#### doorLock.getYeardayScheduleResponse

`javascript
doorLock.getYeardayScheduleResponse(args, callback);
`
* args
* scheduleId \
* userId \
* status \
* localStartTime \
* localEndTime \
* callback
* err
* response
* responseCode


#### doorLock.unlockDoorResponse

`javascript
doorLock.unlockDoorResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.toggleResponse

`javascript
doorLock.toggleResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.unlockWithTimeoutResponse

`javascript
doorLock.unlockWithTimeoutResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.getLogRecordResponse

`javascript
doorLock.getLogRecordResponse(args, callback);
`
* args
* logEntryId \
* timestamp \
* eventType \
* source \
* eventIdOrAlarmCode \
* userId \
* pin \
* callback
* err
* response
* responseCode


#### doorLock.setPinResponse

`javascript
doorLock.setPinResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.getPinResponse

`javascript
doorLock.getPinResponse(args, callback);
`
* args
* userId \
* userStatus \
* userType \
* pin \
* callback
* err
* response
* responseCode


#### doorLock.clearPinResponse

`javascript
doorLock.clearPinResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.clearAllPinsResponse

`javascript
doorLock.clearAllPinsResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.setUserStatusResponse

`javascript
doorLock.setUserStatusResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.clearYeardayScheduleResponse

`javascript
doorLock.clearYeardayScheduleResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.setHolidayScheduleResponse

`javascript
doorLock.setHolidayScheduleResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.getHolidayScheduleResponse

`javascript
doorLock.getHolidayScheduleResponse(args, callback);
`
* args
* scheduleId \
* status \
* localStartTime \
* localEndTime \
* operatingModeDuringHoliday \
* callback
* err
* response
* responseCode


#### doorLock.clearHolidayScheduleResponse

`javascript
doorLock.clearHolidayScheduleResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.setUserTypeResponse

`javascript
doorLock.setUserTypeResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.getUserTypeResponse

`javascript
doorLock.getUserTypeResponse(args, callback);
`
* args
* userId \
* userType \
* callback
* err
* response
* responseCode


#### doorLock.setRfidResponse

`javascript
doorLock.setRfidResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.getRfidResponse

`javascript
doorLock.getRfidResponse(args, callback);
`
* args
* userId \
* userStatus \
* userType \
* rfid \
* callback
* err
* response
* responseCode


#### doorLock.clearRfidResponse

`javascript
doorLock.clearRfidResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.clearAllRfidsResponse

`javascript
doorLock.clearAllRfidsResponse(args, callback);
`
* args
* status \
* callback
* err
* response
* responseCode


#### doorLock.operationEventNotification

`javascript
doorLock.operationEventNotification(args, callback);
`
* args
* source \
* eventCode \
* userId \
* pin \
* timeStamp \
* data \
* callback
* err
* response
* responseCode


#### doorLock.programmingEventNotification

`javascript
doorLock.programmingEventNotification(args, callback);
`
* args
* source \
* eventCode \
* userId \
* pin \
* userType \
* userStatus \
* timeStamp \
* data \
* callback
* err
* response
* responseCode

---

$3

`javascript
var electricalMeasurementCluster = zcl.clusters.ElectricalMeasurement({
ip: ,
endpoint:
});
`
#### electricalMeasurement.bind

`javascript
electricalMeasurementCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### electricalMeasurement.read

`javascript
electricalMeasurementCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* measurementType \ \(server)
* dcVoltage \ \(server)
* dcVoltageMin \ \(server)
* dcVoltageMax \ \(server)
* dcCurrent \ \(server)
* dcCurrentMin \ \(server)
* dcCurrentMax \ \(server)
* dcPower \ \(server)
* dcPowerMin \ \(server)
* dcPowerMax \ \(server)
* dcVoltageMultiplier \ \(server)
* dcVoltageDivisor \ \(server)
* dcCurrentMultiplier \ \(server)
* dcCurrentDivisor \ \(server)
* dcPowerMultiplier \ \(server)
* dcPowerDivisor \ \(server)
* acFrequency \ \(server)
* acFrequencyMin \ \(server)
* acFrequencyMax \ \(server)
* neutralCurrent \ \(server)
* totalActivePower \ \(server)
* totalReactivePower \ \(server)
* totalApparentPower \ \(server)
* measured1stHarmonicCurrent \ \(server)
* measured3rdHarmonicCurrent \ \(server)
* measured5thHarmonicCurrent \ \(server)
* measured7thHarmonicCurrent \ \(server)
* measured9thHarmonicCurrent \ \(server)
* measured11thHarmonicCurrent \ \(server)
* measuredPhase1stHarmonicCurrent \ \(server)
* measuredPhase3rdHarmonicCurrent \ \(server)
* measuredPhase5thHarmonicCurrent \ \(server)
* measuredPhase7thHarmonicCurrent \ \(server)
* measuredPhase9thHarmonicCurrent \ \(server)
* measuredPhase11thHarmonicCurrent \ \(server)
* acFrequencyMultiplier \ \(server)
* acFrequencyDivisor \ \(server)
* powerMultiplier \ \(server)
* powerDivisor \ \(server)
* harmonicCurrentMultiplier \ \(server)
* phaseHarmonicCurrentMultiplier \ \(server)
* instantaneousVoltage \ \(server)
* instantaneousLineCurrent \ \(server)
* instantaneousActiveCurrent \ \(server)
* instantaneousReactiveCurrent \ \(server)
* instantaneousPower \ \(server)
* rmsVoltage \ \(server)
* rmsVoltageMin \ \(server)
* rmsVoltageMax \ \(server)
* rmsCurrent \ \(server)
* rmsCurrentMin \ \(server)
* rmsCurrentMax \ \(server)
* activePower \ \(server)
* activePowerMin \ \(server)
* activePowerMax \ \(server)
* reactivePower \ \(server)
* apparentPower \ \(server)
* powerFactor \ \(server)
* averageRmsVoltageMeasurementPeriod \ \(server)
* averageRmsUnderVoltageCounter \ \(server)
* rmsExtremeOverVoltagePeriod \ \(server)
* rmsExtremeUnderVoltagePeriod \ \(server)
* rmsVoltageSagPeriod \ \(server)
* rmsVoltageSwellPeriod \ \(server)
* acVoltageMultiplier \ \(server)
* acVoltageDivisor \ \(server)
* acCurrentMultiplier \ \(server)
* acCurrentDivisor \ \(server)
* acPowerMultiplier \ \(server)
* acPowerDivisor \ \(server)
* overloadAlarmsMask \ \(server)
* voltageOverload \ \(server)
* currentOverload \ \(server)
* acOverloadAlarmsMask \ \(server)
* acVoltageOverload \ \(server)
* acCurrentOverload \ \(server)
* acActivePowerOverload \ \(server)
* acReactivePowerOverload \ \(server)
* averageRmsOverVoltage \ \(server)
* averageRmsUnderVoltage \ \(server)
* rmsExtremeOverVoltage \ \(server)
* rmsExtremeUnderVoltage \ \(server)
* rmsVoltageSag \ \(server)
* rmsVoltageSwell \ \(server)
* lineCurrentPhaseB \ \(server)
* activeCurrentPhaseB \ \(server)
* reactiveCurrentPhaseB \ \(server)
* rmsVoltagePhaseB \ \(server)
* rmsVoltageMinPhaseB \ \(server)
* rmsVoltageMaxPhaseB \ \(server)
* rmsCurrentPhaseB \ \(server)
* rmsCurrentMinPhaseB \ \(server)
* rmsCurrentMaxPhaseB \ \(server)
* activePowerPhaseB \ \(server)
* activePowerMinPhaseB \ \(server)
* activePowerMaxPhaseB \ \(server)
* reactivePowerPhaseB \ \(server)
* apparentPowerPhaseB \ \(server)
* powerFactorPhaseB \ \(server)
* averageRmsVoltageMeasurementPeriodPhaseB \ \(server)
* averageRmsOverVoltageCounterPhaseB \ \(server)
* averageRmsUnderVoltageCounterPhaseB \ \(server)
* rmsExtremeOverVoltagePeriodPhaseB \ \(server)
* rmsExtremeUnderVoltagePeriodPhaseB \ \(server)
* rmsVoltageSagPeriodPhaseB \ \(server)
* rmsVoltageSwellPeriodPhaseB \ \(server)
* lineCurrentPhaseC \ \(server)
* activeCurrentPhaseC \ \(server)
* reactiveCurrentPhaseC \ \(server)
* rmsVoltagePhaseC \ \(server)
* rmsVoltageMinPhaseC \ \(server)
* rmsVoltageMaxPhaseC \ \(server)
* rmsCurrentPhaseB \ \(server)
* rmsCurrentMinPhaseC \ \(server)
* rmsCurrentMaxPhaseC \ \(server)
* activePowerPhaseC \ \(server)
* activePowerMinPhaseC \ \(server)
* activePowerMaxPhaseC \ \(server)
* reactivePowerPhaseC \ \(server)
* apparentPowerPhaseC \ \(server)
* powerFactorPhaseC \ \(server)
* averageRmsVoltageMeasurementPeriodPhaseC \ \(server)
* averageRmsOverVoltageCounterPhaseC \ \(server)
* averageRmsUnderVoltageCounterPhaseC \ \(server)
* rmsExtremeOverVoltagePeriodPhaseC \ \(server)
* rmsExtremeUnderVoltagePeriodPhaseC \ \(server)
* rmsVoltageSagPeriodPhaseC \ \(server)
* rmsVoltageSwellPeriodPhaseC \ \(server)
* responseCode


#### electricalMeasurement.getProfileInfoCommand

`javascript
electricalMeasurement.getProfileInfoCommand(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### electricalMeasurement.getMeasurementProfileCommand

`javascript
electricalMeasurement.getMeasurementProfileCommand(args, callback);
`
* args
* attributeId \
* startTime \
* numberOfIntervals \
* callback
* err
* response
* responseCode

---

$3

`javascript
var fanControlCluster = zcl.clusters.FanControl({
ip: ,
endpoint:
});
`
#### fanControl.bind

`javascript
fanControlCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### fanControl.read

`javascript
fanControlCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* fanMode \ \(server)
* fanModeSequence \ \(server)
* responseCode

---

$3

`javascript
var flowMeasurementCluster = zcl.clusters.FlowMeasurement({
ip: ,
endpoint:
});
`
#### flowMeasurement.bind

`javascript
flowMeasurementCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### flowMeasurement.read

`javascript
flowMeasurementCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* measuredValue \ \(server)
* minMeasuredValue \ \(server)
* maxMeasuredValue \ \(server)
* tolerance \ \(server)
* responseCode

---

$3

`javascript
var groupsCluster = zcl.clusters.Groups({
ip: ,
endpoint:
});
`
#### groups.bind

`javascript
groupsCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### groups.read

`javascript
groupsCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* nameSupport \ \(server)
* responseCode


#### groups.addGroupResponse

`javascript
groups.addGroupResponse(args, callback);
`
* args
* status \
* groupId \
* callback
* err
* response
* responseCode


#### groups.viewGroupResponse

`javascript
groups.viewGroupResponse(args, callback);
`
* args
* status \
* groupId \
* groupName \
* callback
* err
* response
* responseCode


#### groups.getGroupMembershipResponse

`javascript
groups.getGroupMembershipResponse(args, callback);
`
* args
* capacity \
* groupCount \
* groupList \
* callback
* err
* response
* responseCode


#### groups.removeGroupResponse

`javascript
groups.removeGroupResponse(args, callback);
`
* args
* status \
* groupId \
* callback
* err
* response
* responseCode


#### groups.removeAllGroups

`javascript
groups.removeAllGroups(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### groups.addGroupIfIdentifying

`javascript
groups.addGroupIfIdentifying(args, callback);
`
* args
* groupId \
* groupName \
* callback
* err
* response
* responseCode

---

$3

`javascript
var iasAceCluster = zcl.clusters.IasAce({
ip: ,
endpoint:
});
`
#### iasAce.bind

`javascript
iasAceCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### iasAce.read

`javascript
iasAceCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### iasAce.armResponse

`javascript
iasAce.armResponse(args, callback);
`
* args
* armNotification \
* callback
* err
* response
* responseCode


#### iasAce.getZoneIdMapResponse

`javascript
iasAce.getZoneIdMapResponse(args, callback);
`
* args
* section0 \
* section1 \
* section2 \
* section3 \
* section4 \
* section5 \
* section6 \
* section7 \
* section8 \
* section9 \
* section10 \
* section11 \
* section12 \
* section13 \
* section14 \
* section15 \
* callback
* err
* response
* responseCode


#### iasAce.getZoneInformationResponse

`javascript
iasAce.getZoneInformationResponse(args, callback);
`
* args
* zoneId \
* zoneType \
* ieeeAddress \
* zoneLabel \
* callback
* err
* response
* responseCode


#### iasAce.zoneStatusChanged

`javascript
iasAce.zoneStatusChanged(args, callback);
`
* args
* zoneId \
* zoneStatus \
* audibleNotification \
* zoneLabel \
* callback
* err
* response
* responseCode


#### iasAce.panelStatusChanged

`javascript
iasAce.panelStatusChanged(args, callback);
`
* args
* panelStatus \
* secondsRemaining \
* audibleNotification \
* alarmStatus \
* callback
* err
* response
* responseCode


#### iasAce.getPanelStatusResponse

`javascript
iasAce.getPanelStatusResponse(args, callback);
`
* args
* panelStatus \
* secondsRemaining \
* audibleNotification \
* alarmStatus \
* callback
* err
* response
* responseCode


#### iasAce.setBypassedZoneList

`javascript
iasAce.setBypassedZoneList(args, callback);
`
* args
* numberOfZones \
* zoneIds \
* callback
* err
* response
* responseCode


#### iasAce.bypassResponse

`javascript
iasAce.bypassResponse(args, callback);
`
* args
* numberOfZones \
* bypassResult \
* callback
* err
* response
* responseCode


#### iasAce.getZoneStatusResponse

`javascript
iasAce.getZoneStatusResponse(args, callback);
`
* args
* zoneStatusComplete \
* numberOfZones \
* zoneStatusResult \
* callback
* err
* response
* responseCode


#### iasAce.getZoneStatus

`javascript
iasAce.getZoneStatus(args, callback);
`
* args
* startingZoneId \
* maxNumberOfZoneIds \
* zoneStatusMaskFlag \
* zoneStatusMask \
* callback
* err
* response
* responseCode

---

$3

`javascript
var iasWdCluster = zcl.clusters.IasWd({
ip: ,
endpoint:
});
`
#### iasWd.bind

`javascript
iasWdCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### iasWd.read

`javascript
iasWdCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* maxDuration \ \(server)
* responseCode


#### iasWd.startWarning

`javascript
iasWd.startWarning(args, callback);
`
* args
* warningInfo \
* warningDuration \
* strobeDutyCycle \
* strobeLevel \
* callback
* err
* response
* responseCode


#### iasWd.squawk

`javascript
iasWd.squawk(args, callback);
`
* args
* squawkInfo \
* callback
* err
* response
* responseCode

---

$3

`javascript
var iasZoneCluster = zcl.clusters.IasZone({
ip: ,
endpoint:
});
`
#### iasZone.bind

`javascript
iasZoneCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### iasZone.read

`javascript
iasZoneCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* zoneState \ \(server)
* zoneType \ \(server)
* zoneStatus \ \(server)
* iasCieAddress \ \(server)
* zoneId \ \(server)
* numberOfZoneSensitivityLevelsSupported \ \(server)
* currentZoneSensitivityLevel \ \(server)
* responseCode


#### iasZone.zoneStatusChangeNotification

`javascript
iasZone.zoneStatusChangeNotification(args, callback);
`
* args
* zoneStatus \
* extendedStatus \
* zoneId \
* delay \
* callback
* err
* response
* responseCode


#### iasZone.zoneEnrollRequest

`javascript
iasZone.zoneEnrollRequest(args, callback);
`
* args
* zoneType \
* manufacturerCode \
* callback
* err
* response
* responseCode


#### iasZone.initiateNormalOperationModeResponse

`javascript
iasZone.initiateNormalOperationModeResponse(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### iasZone.initiateTestModeResponse

`javascript
iasZone.initiateTestModeResponse(args, callback);
`
* args - None
* callback
* err
* response
* responseCode

---

$3

`javascript
var identifyCluster = zcl.clusters.Identify({
ip: ,
endpoint:
});
`
#### identify.bind

`javascript
identifyCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### identify.read

`javascript
identifyCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* identifyTime \ \(server)
* commissionState \ \(server)
* responseCode


#### identify.identifyQueryResponse

`javascript
identify.identifyQueryResponse(args, callback);
`
* args
* timeout \
* callback
* err
* response
* responseCode


#### identify.identifyQuery

`javascript
identify.identifyQuery(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### identify.ezModeInvoke

`javascript
identify.ezModeInvoke(args, callback);
`
* args
* action \
* callback
* err
* response
* responseCode


#### identify.updateCommissionState

`javascript
identify.updateCommissionState(args, callback);
`
* args
* action \
* commissionStateMask \
* callback
* err
* response
* responseCode

---

$3

`javascript
var illuminanceLevelSensingCluster = zcl.clusters.IlluminanceLevelSensing({
ip: ,
endpoint:
});
`
#### illuminanceLevelSensing.bind

`javascript
illuminanceLevelSensingCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### illuminanceLevelSensing.read

`javascript
illuminanceLevelSensingCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* levelStatus \ \(server)
* lightSensorType \ \(server)
* illuminanceLevelTarget \ \(server)
* responseCode

---

$3

`javascript
var illuminanceMeasurementCluster = zcl.clusters.IlluminanceMeasurement({
ip: ,
endpoint:
});
`
#### illuminanceMeasurement.bind

`javascript
illuminanceMeasurementCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### illuminanceMeasurement.read

`javascript
illuminanceMeasurementCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* measuredValue \ \(server)
* minMeasuredValue \ \(server)
* maxMeasuredValue \ \(server)
* tolerance \ \(server)
* lightSensorType \ \(server)
* responseCode

---

$3

`javascript
var levelControlCluster = zcl.clusters.LevelControl({
ip: ,
endpoint:
});
`
#### levelControl.bind

`javascript
levelControlCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### levelControl.read

`javascript
levelControlCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* currentLevel \ \(server)
* remainingTime \ \(server)
* options \ \(server)
* onOffTransitionTime \ \(server)
* onLevel \ \(server)
* onTransitionTime \ \(server)
* offTransitionTime \ \(server)
* defaultMoveRate \ \(server)
* startUpCurrentLevel \ \(server)
* responseCode


#### levelControl.moveToLevel

`javascript
levelControl.moveToLevel(args, callback);
`
* args
* level \
* transitionTime \
* callback
* err
* response
* responseCode


#### levelControl.move

`javascript
levelControl.move(args, callback);
`
* args
* moveMode \
* rate \
* callback
* err
* response
* responseCode


#### levelControl.step

`javascript
levelControl.step(args, callback);
`
* args
* stepMode \
* stepSize \
* transitionTime \
* callback
* err
* response
* responseCode


#### levelControl.stop

`javascript
levelControl.stop(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### levelControl.moveToLevelWithOnOff

`javascript
levelControl.moveToLevelWithOnOff(args, callback);
`
* args
* level \
* transitionTime \
* callback
* err
* response
* responseCode


#### levelControl.moveWithOnOff

`javascript
levelControl.moveWithOnOff(args, callback);
`
* args
* moveMode \
* rate \
* callback
* err
* response
* responseCode


#### levelControl.stepWithOnOff

`javascript
levelControl.stepWithOnOff(args, callback);
`
* args
* stepMode \
* stepSize \
* transitionTime \
* callback
* err
* response
* responseCode


#### levelControl.stopWithOnOff

`javascript
levelControl.stopWithOnOff(args, callback);
`
* args - None
* callback
* err
* response
* responseCode

---

$3

`javascript
var meterIdentificationCluster = zcl.clusters.MeterIdentification({
ip: ,
endpoint:
});
`
#### meterIdentification.bind

`javascript
meterIdentificationCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### meterIdentification.read

`javascript
meterIdentificationCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* companyName \ \(server)
* meterTypeId \ \(server)
* dataQualityId \ \(server)
* customerName \ \(server)
* model \ \(server)
* partNumber \ \(server)
* productRevision \ \(server)
* softwareRevision \ \(server)
* utilityName \ \(server)
* pod \ \(server)
* availablePower \ \(server)
* powerThreshold \ \(server)
* responseCode

---

$3

`javascript
var occupancySensingCluster = zcl.clusters.OccupancySensing({
ip: ,
endpoint:
});
`
#### occupancySensing.bind

`javascript
occupancySensingCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### occupancySensing.read

`javascript
occupancySensingCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* occupancy \ \(server)
* occupancySensorType \ \(server)
* pirOccupiedToUnoccupiedDelay \ \(server)
* pirUnoccupiedToOccupiedDelay \ \(server)
* pirUnoccupiedToOccupiedThreshold \ \(server)
* ultrasonicOccupiedToUnoccupiedDelay \ \(server)
* ultrasonicUnoccupiedToOccupiedDelay \ \(server)
* ultrasonicUnoccupiedToOccupiedThreshold \ \(server)
* responseCode

---

$3

`javascript
var onOffCluster = zcl.clusters.OnOff({
ip: ,
endpoint:
});
`
#### onOff.bind

`javascript
onOffCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### onOff.read

`javascript
onOffCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* onOff \ \(server)
* startUpOnOff \ \(server)
* responseCode


#### onOff.off

`javascript
onOff.off(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### onOff.on

`javascript
onOff.on(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### onOff.toggle

`javascript
onOff.toggle(args, callback);
`
* args - None
* callback
* err
* response
* responseCode

---

$3

`javascript
var onOffSwitchConfigurationCluster = zcl.clusters.OnOffSwitchConfiguration({
ip: ,
endpoint:
});
`
#### onOffSwitchConfiguration.bind

`javascript
onOffSwitchConfigurationCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### onOffSwitchConfiguration.read

`javascript
onOffSwitchConfigurationCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* switchType \ \(server)
* switchActions \ \(server)
* responseCode

---

$3

`javascript
var overTheAirBootloadingCluster = zcl.clusters.OverTheAirBootloading({
ip: ,
endpoint:
});
`
#### overTheAirBootloading.bind

`javascript
overTheAirBootloadingCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### overTheAirBootloading.read

`javascript
overTheAirBootloadingCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* otaUpgradeServerId \ \(client)
* offsetAddressIntoTheFile \ \(client)
* otaCurrentFileVersion \ \(client)
* otaCurrentZigBeeStackVersion \ \(client)
* otaDownloadedFileVersion \ \(client)
* otaDownloadedZigBeeStackVersion \ \(client)
* otaUpgradeStatus \ \(client)
* manufacturerId \ \(client)
* imageTypeId \ \(client)
* minimumBlockRequestPeriod \ \(client)
* imageStamp \ \(client)
* upgradeActivationPolicy \ \(client)
* upgradeTimeoutPolicy \ \(client)
* responseCode


#### overTheAirBootloading.imageNotify

`javascript
overTheAirBootloading.imageNotify(args, callback);
`
* args
* payloadType \
* queryJitter \
* manufacturerId \
* imageType \
* newFileVersion \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.queryNextImageRequest

`javascript
overTheAirBootloading.queryNextImageRequest(args, callback);
`
* args
* fieldControl \
* manufacturerId \
* imageType \
* currentFileVersion \
* hardwareVersion \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.queryNextImageResponse

`javascript
overTheAirBootloading.queryNextImageResponse(args, callback);
`
* args
* status \
* manufacturerId \
* imageType \
* fileVersion \
* imageSize \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.imageBlockRequest

`javascript
overTheAirBootloading.imageBlockRequest(args, callback);
`
* args
* fieldControl \
* manufacturerId \
* imageType \
* fileVersion \
* fileOffset \
* maxDataSize \
* requestNodeAddress \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.imagePageRequest

`javascript
overTheAirBootloading.imagePageRequest(args, callback);
`
* args
* fieldControl \
* manufacturerId \
* imageType \
* fileVersion \
* fileOffset \
* maxDataSize \
* pageSize \
* responseSpacing \
* requestNodeAddress \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.imageBlockResponse

`javascript
overTheAirBootloading.imageBlockResponse(args, callback);
`
* args
* status \
* manufacturerId \
* imageType \
* fileVersion \
* fileOffset \
* dataSize \
* imageData \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.upgradeEndRequest

`javascript
overTheAirBootloading.upgradeEndRequest(args, callback);
`
* args
* status \
* manufacturerId \
* imageType \
* fileVersion \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.upgradeEndResponse

`javascript
overTheAirBootloading.upgradeEndResponse(args, callback);
`
* args
* manufacturerId \
* imageType \
* fileVersion \
* currentTime \
* upgradeTime \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.querySpecificFileRequest

`javascript
overTheAirBootloading.querySpecificFileRequest(args, callback);
`
* args
* requestNodeAddress \
* manufacturerId \
* imageType \
* fileVersion \
* currentZigbeeStackVersion \
* callback
* err
* response
* responseCode


#### overTheAirBootloading.querySpecificFileResponse

`javascript
overTheAirBootloading.querySpecificFileResponse(args, callback);
`
* args
* status \
* manufacturerId \
* imageType \
* fileVersion \
* imageSize \
* callback
* err
* response
* responseCode

---

$3

`javascript
var pollControlCluster = zcl.clusters.PollControl({
ip: ,
endpoint:
});
`
#### pollControl.bind

`javascript
pollControlCluster.bind(args, callback);
`
* args
* uid
* ip
* port
* endpoint
* callback
* err
* response
* responseCode

#### pollControl.read

`javascript
pollControlCluster.read(args, callback);
`
* args - None
* callback
* err
* response
* checkInInterval \ \(server)
* longPollInterval \ \(server)
* shortPollInterval \ \(server)
* fastPollTimeout \ \(server)
* checkInIntervalMin \ \(server)
* longPollIntervalMin \ \(server)
* fastPollTimeoutMax \ \(server)
* responseCode


#### pollControl.checkInResponse

`javascript
pollControl.checkInResponse(args, callback);
`
* args
* startFastPolling \
* fastPollTimeout \
* callback
* err
* response
* responseCode


#### pollControl.fastPollStop

`javascript
pollControl.fastPollStop(args, callback);
`
* args - None
* callback
* err
* response
* responseCode


#### pollControl.setLongPollInterval

`javascript
pollControl.setLongPollInterval(args, callback);
``
* args
* newLongPollIn