mini_program_gizwits_sdk 3.6.0 → 3.6.2

package/dist/src/services/devices.d.ts

@@ -1,20 +1,4 @@
-import { IServiceResult } from '../openApiRequest';
-import { IRandomCodesResult } from '../sdk';
-export interface IOpenApiDevice {
-    product_key: string;
-    did: string;
-    mac: string;
-    passcode: string;
-    is_online: boolean;
-    host: string;
-    port: string;
-    port_s: string;
-    ws_port: number;
-    wss_port: number;
-    dev_alias: string;
-    remark: string;
-    type: 'normal' | 'center_control' | 'sub_dev';
-}
+import { IDevice, IOpenApiDevice, IRandomCodesResult, IServiceResult } from '../types';
 export declare const getBindingList: () => Promise<IServiceResult<IDevice[]>>;
 export interface IBindMacParams {
     mac: string;

package/dist/src/services/login.d.ts

@@ -1,8 +1,4 @@
-export interface ILoginRes {
-    expire_at: number;
-    token: string;
-    uid: string;
-}
+import { ILoginRes } from "../types";
 export declare function AnonymousLogin({ uid }: {
     uid: string;
-}): Promise<import("../openApiRequest").IServiceResult<ILoginRes>>;
+}): Promise<import("../types").IServiceResult<ILoginRes>>;

package/dist/src/services/monitor.d.ts

@@ -1,3 +1,4 @@
+import { IDevice } from '../types';
 type EventType = "BleDeviceConnectStart" | "BleDeviceConnectEnd" | "BleDeviceConnectBind" | "BleDeviceConnectLogin" | "BleDeviceConnectFinish";
 type FailureType = Omit<EventType, 'BleDeviceConnectStart' | 'BleDeviceConnectFinish'>;
 interface IProps {
@@ -7,5 +8,5 @@ interface IProps {
     success: boolean;
     failureType?: FailureType;
 }
-export declare function reportEvent({ device, eventID, eventType, success, failureType }: IProps): Promise<import("../openApiRequest").IServiceResult<any>>;
+export declare function reportEvent({ device, eventID, eventType, success, failureType }: IProps): Promise<import("../types").IServiceResult<any>>;
 export {};

package/dist/src/services/monitor.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportEvent = void 0;
+const package_json_1 = require("../../package.json");
+const globalData_1 = require("../globalData");
+const openApiRequest_1 = __importDefault(require("../openApiRequest"));
+class BaseInfo {
+    constructor() {
+        wx.getSystemInfoAsync({
+            success: (res) => {
+                this.app = {
+                    wxSdkVersion: res.SDKVersion,
+                    gizwitsSdkVersion: package_json_1.version,
+                    appID: 'unknown',
+                    bluetoothEnabled: res.bluetoothEnabled,
+                    locationEnabled: res.locationEnabled,
+                    wifiEnabled: res.wifiEnabled,
+                };
+                this.mobile = {
+                    brand: res.brand,
+                    model: res.model,
+                    pixelRatio: res.pixelRatio,
+                    systemVersion: res.system,
+                    platform: res.platform,
+                };
+            },
+        });
+    }
+    updateAppId(appId) {
+        this.app.appID = appId;
+    }
+}
+const baseInfo = new BaseInfo();
+function reportEvent({ device, eventID, eventType, success, failureType }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        baseInfo.updateAppId((0, globalData_1.getGlobalData)('appID') || 'unknown');
+        const path = `/v2/products/${device.productKey}/devices/bluetooth-connect-data`;
+        const curDate = new Date();
+        const eventData = {
+            origin: "MINI-WX",
+            mobileInfo: baseInfo.mobile,
+            userInfo: null,
+            appInfo: baseInfo.app,
+            eventID,
+            eventType,
+            monitorTarget: {
+                device,
+                success,
+                failureType,
+            },
+            time: curDate,
+            timeStamp: Math.floor(curDate.getTime() / 1000),
+        };
+        return (0, openApiRequest_1.default)(path, {
+            data: eventData,
+            method: 'POST',
+        }, true);
+    });
+}
+exports.reportEvent = reportEvent;

package/dist/src/services/ota.d.ts

@@ -1,11 +1,7 @@
-import { IOTAType } from "../sdk";
-export interface OTARes {
-    download_url: string;
-    soft_ver: string;
-}
+import { IOTAType, OTARes } from "../types";
 export declare function checkUpdate({ did, type, hardVersion, softVersion }: {
     did: string;
     type: IOTAType;
     hardVersion: string;
     softVersion: string;
-}): Promise<import("../openApiRequest").IServiceResult<OTARes>>;
+}): Promise<import("../types").IServiceResult<OTARes>>;

package/dist/src/services/uploadP0.d.ts

@@ -1,3 +1,4 @@
+import { IDevice } from "../types";
 export interface IUploadRes {
 }
 interface IData {
@@ -9,5 +10,5 @@ interface IProps {
     data: IData[];
     productSecret: string;
 }
-export declare function uploadP0({ device, data, productSecret }: IProps): Promise<import("../openApiRequest").IServiceResult<IUploadRes>>;
+export declare function uploadP0({ device, data, productSecret }: IProps): Promise<import("../types").IServiceResult<IUploadRes>>;
 export {};

package/dist/src/types/index.d.ts

@@ -0,0 +1,360 @@
+import { TCPHandler } from "../handler/lan";
+import DiscoverUDP from "../protocol/DiscoverUDP";
+import { wrapErrorInfo } from "../utils";
+export type TUtf8 = {
+    toBytes: (data: any) => any;
+};
+export type TUtils = {
+    utf8: TUtf8;
+};
+export interface ecb {
+    new (data: any): any;
+}
+export type TModeOfOperation = {
+    ecb: ecb;
+};
+export interface IError {
+    errorCode: number;
+    errorMessage?: string;
+}
+export interface ICommonObj {
+    [key: string]: any;
+}
+export interface IDeviceStatusChangedProps {
+    did: string;
+    attrs: ICommonObj;
+}
+export interface IDeviceRawStatusChangedProps {
+    did: string;
+    raw: Uint8Array;
+}
+export interface IOnDeviceStatusChanged {
+    (data: IDeviceStatusChangedProps | IDeviceRawStatusChangedProps): void;
+}
+export interface IOnSocketStatusChanged {
+    (dids: string[], enabled: boolean): void;
+}
+export interface IEmptyFn {
+    (): void;
+}
+export interface IDevice {
+    mac: string;
+    productKey: string;
+    did: string;
+    bleWorkStatus?: number;
+    name: string;
+    isBind: boolean;
+    rootDeviceId?: string;
+    bleDeviceID?: string;
+    remark?: string;
+    passcode?: string;
+    connectType: TConnectType;
+    isOnline: boolean;
+    isLanOnline: boolean;
+    isBleOnline: boolean;
+    host?: string;
+    wss_port?: number;
+    ctime?: number;
+}
+export type TConnectType = 'BLE' | 'BLE_BROADCAST' | 'LAN' | 'WAN' | 'NONE';
+export interface IBluetoothAdapterStateResult {
+    discovering: boolean;
+    available: boolean;
+}
+export interface IWechatResult {
+    errMsg: string;
+    errCode: number;
+}
+export interface IWXDevicesResult {
+    success: true;
+    bleDevices: WechatMiniprogram.BlueToothDevice[];
+}
+export interface SyncCallBackParams {
+    event: TSyncEvnet;
+    currentNum?: number;
+    totalNum?: number;
+    message?: string;
+}
+export type TSyncEvnet = 'SYNC_START' | 'SYNC_END' | 'SYNC_FAIL' | 'SYNC_CANCEL' | 'SYNC_PROGRESS';
+export type SyncCallBack = (data: SyncCallBackParams) => void;
+export type IOTAType = 'MCU' | 'MODULE';
+export interface ISDKResult<T> {
+    data?: T;
+    err?: IError;
+    message?: string;
+    success: boolean;
+}
+export interface ISetCommonDeviceOnboardingDeployProps {
+    ssid: string;
+    bssid?: string;
+    password: string;
+    timeout: number;
+    isBind?: boolean;
+    mode?: 0 | 3 | 5;
+    softAPSSIDPrefix?: string;
+}
+export interface ISetDeviceOnboardingDeployProps extends ISetCommonDeviceOnboardingDeployProps {
+    softAPSSIDPrefix: string;
+    eventCallBack: (event: ConfigEventData) => void;
+}
+export interface IRandomCodesResult {
+    random_code: string;
+    product_key: string;
+    mac: string;
+    did: string;
+    user_id: string;
+    timestamp: number;
+    type: string;
+    wifi_soft_ver: string;
+    lan_proto_ver: string;
+}
+export interface IBindRemoteDeviceParams {
+    productKey: string;
+    mac: string;
+    beOwner?: boolean;
+    alias?: string;
+}
+export interface IDeviceStatusNoti {
+    device: IDevice;
+    connectType: TConnectType;
+}
+export interface IDeviceAttrsNoti {
+    device: IDevice;
+    data: object;
+}
+export interface TListenerType {
+    GizDeviceListNotifications: TDeviceListNotifications;
+    GizDeviceStatusNotifications: TDeviceStatusNotifications;
+    GizDeviceAttrsNotifications: TDeviceAttrsNotifications;
+    onScanListChange: OnScanListChange;
+    onBleHandleError: OnBleHandleError;
+}
+export type TDeviceListNotifications = (devices: IDevice[]) => void;
+export type TDeviceStatusNotifications = (data: IDeviceStatusNoti) => void;
+export type TDeviceAttrsNotifications = (data: IDeviceAttrsNoti) => void;
+export type OnScanListChange = (devices: IDevice[]) => void;
+export type OnBleHandleError = (error: IError) => void;
+export interface IDeviceSafetyRegisterParams {
+    mac: string;
+    productKey: string;
+}
+export interface IDeviceSafetyParams extends IDeviceSafetyRegisterParams {
+    isReset: boolean;
+}
+export interface IResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+export interface ICloudServiceInfo {
+    openAPIInfo: string;
+}
+export type TimeoutHandle = ReturnType<typeof setTimeout> | null;
+export type IntervalHandle = ReturnType<typeof setInterval> | null;
+export interface IProductInfo {
+    productKey: string;
+    productSecret: string;
+}
+export interface GizwitsSdkOption {
+    appID: string;
+    appSecret: string;
+    productInfo: IProductInfo[];
+    cloudServiceInfo?: ICloudServiceInfo;
+    token?: string;
+    uid?: string;
+    offlineThreshold?: number;
+}
+export interface IRejectCallback {
+    (result: IResult<unknown>): void;
+}
+export type TConfigEvent = 'GIZ_CONFIG_START' | 'GIZ_DISCOVER_SUCCESS' | 'GIZ_CONNECT_SUCCESS' | 'GIZ_CONFIG_SEND_SUCCESS' | 'GIZ_CONFIG_RECV_SUCCESS' | 'GIZ_CONFIG_SUCCESS';
+export interface ConfigEventData {
+    event: TConfigEvent;
+    deviceID?: string;
+}
+export interface IOpenApiDevice {
+    product_key: string;
+    did: string;
+    mac: string;
+    passcode: string;
+    is_online: boolean;
+    host: string;
+    port: string;
+    port_s: string;
+    ws_port: number;
+    wss_port: number;
+    dev_alias: string;
+    remark: string;
+    type: 'normal' | 'center_control' | 'sub_dev';
+}
+export interface IDeviceRes {
+    devices: IOpenApiDevice[];
+}
+export interface IErrorCode {
+    [key: string]: IError;
+}
+export interface IWechatApiResult<T> {
+    data: T;
+    errMsg: string;
+    statusCode: number;
+}
+export interface IServiceResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+export interface IGetRandomCodes {
+    SSID: string;
+    password: string;
+    pks: string[];
+}
+export interface IGetRandomCode {
+    SSID: string;
+    password: string;
+    pk: string;
+}
+export interface IProductConfigData {
+    [key: string]: IDataPointConfig;
+}
+export interface IDataPointConfig {
+    name: string;
+    protocolType: 'var_len' | 'standard';
+    entities: IDataPointEntitie[];
+}
+export interface IDataPointEntitie {
+    display_name: string;
+    attrs: IDataPointAttr[];
+}
+export interface IDataPointPosition {
+    byte_offset: number;
+    unit: 'bit' | 'byte';
+    len: number;
+    bit_offset: number;
+}
+export type TDataType = 'bool' | 'uint8' | 'uint16' | 'uint32' | 'binary' | 'enum' | 'number';
+export interface IUnitSpec {
+    addition: number;
+    max: number;
+    ratio: number;
+    min: number;
+}
+export type TDataOptionType = 'status_writable' | 'status_readonly' | 'alert' | 'fault' | 'ALL';
+export interface IDataPointAttr {
+    display_name: string;
+    uint_spec: IUnitSpec;
+    name: string;
+    data_type: TDataType;
+    position: IDataPointPosition;
+    type: TDataOptionType;
+    id: number;
+    enum: string[];
+    desc: string;
+}
+export type GizBleDeviceListotifications = (devices: IDevice[]) => void;
+export type GizBleDeviceDataNotifications = (curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult, hexString: string) => void;
+export type GizBleErrorNotifications = (err: {
+    errCode: number;
+    errMsg: string;
+}) => void;
+export type TBleDataListener<T> = (_curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult, hexString: string) => T | null | undefined;
+export interface CheckOTAParams {
+    device: IDevice;
+    type: IOTAType;
+}
+export type OTAEventCode = 'GizOTAEventPretreatment' | 'GizOTAEventDownload' | 'GizOTAEventTransmit' | 'GizOTAEventReboot' | 'GizOTAEventFinish';
+export interface OTAEvent {
+    code: OTAEventCode;
+}
+export interface OTAProgressEvent {
+    firmwareSize: number;
+    packageMaxLen: number;
+    currentNumber: number;
+    currentProgress: number;
+}
+export type OTAProgressEventCallback = (event: OTAProgressEvent) => void;
+export type OTAEventCallback = (event: OTAEvent) => void;
+export interface StartUpgradeParams extends CheckOTAParams {
+    onProgress: OTAProgressEventCallback;
+    onEvent: OTAEventCallback;
+    productKey: string;
+}
+export interface TBleHandleEvent {
+    GizBleDeviceData: GizBleDeviceDataNotifications;
+    GizBleDeviceList: GizBleDeviceListotifications;
+    GizBleError: GizBleErrorNotifications;
+}
+export interface GizwitsWxBlueToothDevice extends WechatMiniprogram.BlueToothDevice {
+    communicationType: 'BLE_BROADCAST' | 'BLE';
+}
+export interface BleHandleParams {
+    serviceUUIDSuffix: string;
+    characteristicUUIDSuffix: string;
+}
+export interface IStartScanResult {
+    scanList: IDevice[];
+    err?: ReturnType<typeof wrapErrorInfo>;
+}
+export interface IDeviceReq<T> {
+    success: boolean;
+    data: T;
+}
+export type OnScanDevice = (scanList: IDevice[]) => void;
+export interface BleConnectDevice {
+    deviceId?: string;
+    serviceId?: string;
+    characteristicId?: string;
+    errMsg?: string;
+}
+export interface BleConstructorParams {
+    pks: string[];
+    bleHandleParams?: BleHandleParams;
+    offlineThreshold?: number;
+}
+export interface LanConnectDevice {
+    mac: string;
+    productKey: string;
+    socketHandle: TCPHandler;
+}
+export interface ILanDevice extends IDevice {
+    expandData: DiscoverUDP;
+    ip: string;
+}
+export type GizLanDeviceListNotifications = (devices: IDevice[]) => void;
+export type GizLanDeviceDataNotifications = (mac: string, data: string) => void;
+export interface TLanHandleEvent {
+    GizLanDeviceList: GizLanDeviceListNotifications;
+    GizLanDeviceData: GizLanDeviceDataNotifications;
+}
+export interface IBLEService {
+    uuid: string;
+    isPrimary: boolean;
+}
+export interface IBLECharacteristic {
+    uuid: string;
+    properties: {
+        read: boolean;
+        write: boolean;
+        notify: boolean;
+        indicate: boolean;
+    };
+}
+export interface ILoginRes {
+    expire_at: number;
+    token: string;
+    uid: string;
+}
+export interface OTARes {
+    download_url: string;
+    soft_ver: string;
+}
+export interface configDeviceParams {
+    ssid: string;
+    password: string;
+    softAPSSIDPrefix: string;
+}
+export interface configBLEDeviceParams {
+    ssid: string;
+    password: string;
+    softAPSSIDPrefix?: string;
+    timeout: number;
+}

package/dist/src/utils.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="crypto-js" />
 import { lib } from "crypto-js/core";
-import { IProductInfo } from './sdk';
-import { GizwitsWxBlueToothDevice } from './handler/ble';
+import { IDevice, IError, IWXDevicesResult, TConnectType, IProductInfo, GizwitsWxBlueToothDevice } from "./types";
 export declare function ab2hex(buffer: ArrayBuffer): any;
 export declare function compareWXSDKVersion(v1: string, v2: string): 0 | 1 | -1;
 export declare const isError: (err: unknown) => err is IError;
@@ -10,10 +9,6 @@ export declare const wrapErrorInfo: (errorMessage: string) => {
     errorMessage: string;
 };
 export declare const unionBy: <T>(array: T[], key: string) => T[];
-interface IWXDevicesResult {
-    success: true;
-    bleDevices: WechatMiniprogram.BlueToothDevice[];
-}
 export declare function isWXDevicesResult(res: unknown): res is IWXDevicesResult;
 export declare function str2Buf(arr: string): ArrayBuffer;
 export declare const numberArray2Uint8Array: (numArr: number[]) => Uint8Array;

package/dist/src/wechatApi.d.ts

@@ -1,11 +1,4 @@
-interface IBluetoothAdapterStateResult {
-    discovering: boolean;
-    available: boolean;
-}
-export interface IWechatResult {
-    errMsg: string;
-    errCode: number;
-}
+import { IBluetoothAdapterStateResult, IWechatResult, IBLEService, IBLECharacteristic } from "./types";
 export declare function retryConnect(deviceId: string, timeout?: number): Promise<IWechatResult | {
     success: boolean;
 }>;
@@ -15,20 +8,7 @@ export declare function getBluetoothAdapterState(): Promise<IBluetoothAdapterSta
 export declare function startBluetoothDevicesDiscovery(allowDuplicatesKey?: boolean): Promise<IWechatResult>;
 export declare function getBluetoothDevices(): Promise<WechatMiniprogram.BlueToothDevice[]>;
 export declare function createBLEConnection(deviceId: string, timeout: number): Promise<IWechatResult>;
-interface IBLEService {
-    uuid: string;
-    isPrimary: boolean;
-}
 export declare function getBLEDeviceServices(deviceId: string): Promise<IBLEService[]>;
-interface IBLECharacteristic {
-    uuid: string;
-    properties: {
-        read: boolean;
-        write: boolean;
-        notify: boolean;
-        indicate: boolean;
-    };
-}
 export declare function getBLEDeviceCharacteristics(deviceId: string, serviceId: string): Promise<IBLECharacteristic[]>;
 export declare function notifyBLECharacteristicValueChange(deviceId: string, serviceId: string, characteristicId: string, state?: boolean): Promise<IWechatResult>;
 export declare function writeBLECharacteristicValue(deviceId: string, serviceId: string, characteristicId: string, value: ArrayBuffer): Promise<IWechatResult>;
@@ -37,4 +17,3 @@ export declare function downloadFile({ url }: {
     url: any;
 }): Promise<unknown>;
 export declare function setMtu(mtu: number, deviceId: string): Promise<unknown>;
-export {};

package/dist/src/wifiConfig/ConfigBase.d.ts

@@ -1,12 +1,5 @@
-import { IRandomCodesResult, IResult, TimeoutHandle } from "../sdk";
-interface IRejectCallback {
-    (result: IResult<unknown>): void;
-}
-export type TConfigEvent = 'GIZ_CONFIG_START' | 'GIZ_DISCOVER_SUCCESS' | 'GIZ_CONNECT_SUCCESS' | 'GIZ_CONFIG_SEND_SUCCESS' | 'GIZ_CONFIG_RECV_SUCCESS' | 'GIZ_CONFIG_SUCCESS';
-export interface ConfigEventData {
-    event: TConfigEvent;
-    deviceID?: string;
-}
+import { IRandomCodesResult, IRejectCallback, IResult, TimeoutHandle } from "../types";
+import { ConfigEventData, IDevice } from "../types";
 declare class ConfigBase {
     ssid: string;
     bssid: string;

package/dist/src/wifiConfig/ap.d.ts

@@ -1,15 +1,5 @@
-import { IRandomCodesResult, IResult } from "../sdk";
+import { IDevice, IRandomCodesResult, IResult, configDeviceParams, ISetDeviceOnboardingDeployProps } from "../types";
 import ConfigBase from "./ConfigBase";
-interface configDeviceParams {
-    ssid: string;
-    password: string;
-    softAPSSIDPrefix: string;
-}
-interface ISetDeviceOnboardingDeployProps {
-    timeout: number;
-    isBind: boolean;
-    softAPSSIDPrefix: string;
-}
 declare class ApConfig extends ConfigBase {
     disableSendUDP: boolean;
     private sendMessageInterval;

package/dist/src/wifiConfig/ble.d.ts

@@ -1,6 +1,6 @@
-import { IRandomCodesResult, IResult } from "../sdk";
 import { BleHandle } from "../handler/ble";
-import ConfigBase, { ConfigEventData } from "./ConfigBase";
+import ConfigBase from "./ConfigBase";
+import { IDevice, IError, ConfigEventData, IRandomCodesResult, IResult, configBLEDeviceParams } from "../types";
 type EnableAndGetBluetoothDevicesRes = Promise<{
     success: false;
     err: IError;
@@ -16,12 +16,6 @@ interface IArgs {
     bleHandle: BleHandle;
     eventCallBack: (event: ConfigEventData) => void;
 }
-interface configBLEDeviceParams {
-    ssid: string;
-    password: string;
-    softAPSSIDPrefix?: string;
-    timeout: number;
-}
 interface ISetDeviceOnboardingDeployProps {
     timeout: number;
     isBind: boolean;

package/dist/src/wifiConfig/nfc/index.d.ts

@@ -1,5 +1,5 @@
-import { IRandomCodesResult, IResult } from "../../sdk";
 import ConfigBase from "../ConfigBase";
+import { IDevice, IResult } from '../../types';
 interface configDeviceParams {
     ssid: string;
     password: string;
@@ -16,7 +16,7 @@ declare class NFCConfig extends ConfigBase {
     address: string;
     constructor(ssid: string, bssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], address: string);
     destroy: () => void;
-    configDevice: ({ ssid, password, bssid, address }: configDeviceParams) => Promise<IResult<IRandomCodesResult[]>>;
+    configDevice: ({ ssid, password, bssid, address }: configDeviceParams) => Promise<IResult<import("../../types").IRandomCodesResult[]>>;
     setDeviceOnboardingDeploy: ({ timeout, isBind, }: ISetDeviceOnboardingDeployProps) => Promise<IResult<IDevice[]>>;
 }
 export default NFCConfig;

package/global.d.ts

@@ -6,23 +6,7 @@ declare namespace md5 {
 
 declare function md5(data: any): any;
 
-type TUtf8 = {
-  toBytes: (data: any) => any
-}
-
-type TUtils = {
-  utf8: TUtf8;
-}
-
-interface ecb {
-  new(data: any): any;
-}
-
-type TModeOfOperation = {
-  ecb: ecb;
-}
-
 declare namespace aesjs {
-  const utils: TUtils;
-  const ModeOfOperation: TModeOfOperation;
-}
+  const utils: any;
+  const ModeOfOperation: any;
+}

package/index.ts

@@ -3,5 +3,7 @@ import gizwitsSdk from './src/sdk';
 import errorCode from './src/errorCode';
 import { BleHandle } from './src/handler/ble';
 
+import * as types from './src/types';
 export { errorCode, BleHandle };
+export { types }
 export default gizwitsSdk;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.6.0",
-  "description": "更新文档",
+  "version": "3.6.2",
+  "description": "更新类型",
   "main": "./dist/index.js",
   "scripts": {
     "test": "node_modules/mocha/bin/_mocha -r ts-node/register tests/**/*.spec.ts -file ./tests/setup-wx.js -timeout 60s",