@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/app/authorization/impl/AuthorizationEventbusImpl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationEventbusImpl = void 0;
+const Authorization_1 = require("../Authorization");
+const AuthorizationType_1 = require("../AuthorizationType");
+class AuthorizationEventbusImpl extends Authorization_1.Authorization {
+    constructor(address) {
+        super(AuthorizationType_1.AuthorizationType.EVENTBUS);
+        this.address = address;
+    }
+}
+exports.AuthorizationEventbusImpl = AuthorizationEventbusImpl;

package/dist/xiot/core/spec/typedef/app/authorization/impl/AuthorizationHttpImpl.d.ts

@@ -0,0 +1,5 @@
+import { Authorization } from '../Authorization';
+export declare class AuthorizationHttpImpl extends Authorization {
+    url: string;
+    constructor(url: string);
+}

package/dist/xiot/core/spec/typedef/app/authorization/impl/AuthorizationHttpImpl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationHttpImpl = void 0;
+const Authorization_1 = require("../Authorization");
+const AuthorizationType_1 = require("../AuthorizationType");
+class AuthorizationHttpImpl extends Authorization_1.Authorization {
+    constructor(url) {
+        super(AuthorizationType_1.AuthorizationType.HTTP);
+        this.url = url;
+    }
+}
+exports.AuthorizationHttpImpl = AuthorizationHttpImpl;

package/dist/xiot/core/spec/typedef/app/authorization/impl/AuthorizationJwtImpl.d.ts

@@ -0,0 +1,6 @@
+import { Authorization } from '../Authorization';
+import { Jwt } from '../../../jwt/Jwt';
+export declare class AuthorizationJwtImpl extends Authorization {
+    jwt: Jwt;
+    constructor(jwt: Jwt);
+}

package/dist/xiot/core/spec/typedef/app/authorization/impl/AuthorizationJwtImpl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationJwtImpl = void 0;
+const Authorization_1 = require("../Authorization");
+const AuthorizationType_1 = require("../AuthorizationType");
+class AuthorizationJwtImpl extends Authorization_1.Authorization {
+    constructor(jwt) {
+        super(AuthorizationType_1.AuthorizationType.JWT);
+        this.jwt = jwt;
+    }
+}
+exports.AuthorizationJwtImpl = AuthorizationJwtImpl;

package/dist/xiot/core/spec/typedef/app/event/EventReceiver.d.ts

@@ -0,0 +1,5 @@
+import { EventReceiverType } from './EventReceiverType';
+export declare class EventReceiver {
+    type: EventReceiverType;
+    constructor(type: EventReceiverType);
+}

package/dist/xiot/core/spec/typedef/app/event/EventReceiver.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiver = void 0;
+class EventReceiver {
+    constructor(type) {
+        this.type = type;
+    }
+}
+exports.EventReceiver = EventReceiver;

package/dist/xiot/core/spec/typedef/app/event/EventReceiverType.d.ts

@@ -0,0 +1,8 @@
+export declare enum EventReceiverType {
+    UNDEFINED = "undefined",
+    EVENTBUS = "eventbus",
+    HTTP = "http",
+    KAFKA = "kafka"
+}
+export declare function EventReceiverTypeToString(type: EventReceiverType): string;
+export declare function EventReceiverTypeFromString(type: string): EventReceiverType;

package/dist/xiot/core/spec/typedef/app/event/EventReceiverType.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiverType = void 0;
+exports.EventReceiverTypeToString = EventReceiverTypeToString;
+exports.EventReceiverTypeFromString = EventReceiverTypeFromString;
+var EventReceiverType;
+(function (EventReceiverType) {
+    EventReceiverType["UNDEFINED"] = "undefined";
+    EventReceiverType["EVENTBUS"] = "eventbus";
+    EventReceiverType["HTTP"] = "http";
+    EventReceiverType["KAFKA"] = "kafka";
+})(EventReceiverType || (exports.EventReceiverType = EventReceiverType = {}));
+function EventReceiverTypeToString(type) {
+    return type.toString();
+}
+function EventReceiverTypeFromString(type) {
+    const keys = Object.keys(EventReceiverType);
+    for (const key of keys) {
+        const s = EventReceiverTypeToString(EventReceiverType[key]);
+        if (s === type) {
+            return EventReceiverType[key];
+        }
+    }
+    return EventReceiverType.UNDEFINED;
+}

package/dist/xiot/core/spec/typedef/app/event/impl/EventReceiverEventbusImpl.d.ts

@@ -0,0 +1,5 @@
+import { EventReceiver } from '../EventReceiver';
+export declare class EventReceiverEventbusImpl extends EventReceiver {
+    address: string;
+    constructor(address: string);
+}

package/dist/xiot/core/spec/typedef/app/event/impl/EventReceiverEventbusImpl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiverEventbusImpl = void 0;
+const EventReceiverType_1 = require("../EventReceiverType");
+const EventReceiver_1 = require("../EventReceiver");
+class EventReceiverEventbusImpl extends EventReceiver_1.EventReceiver {
+    constructor(address) {
+        super(EventReceiverType_1.EventReceiverType.EVENTBUS);
+        this.address = address;
+    }
+}
+exports.EventReceiverEventbusImpl = EventReceiverEventbusImpl;

package/dist/xiot/core/spec/typedef/app/event/impl/EventReceiverHttpImpl.d.ts

@@ -0,0 +1,5 @@
+import { EventReceiver } from '../EventReceiver';
+export declare class EventReceiverHttpImpl extends EventReceiver {
+    url: string;
+    constructor(url: string);
+}

package/dist/xiot/core/spec/typedef/app/event/impl/EventReceiverHttpImpl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiverHttpImpl = void 0;
+const EventReceiver_1 = require("../EventReceiver");
+const EventReceiverType_1 = require("../EventReceiverType");
+class EventReceiverHttpImpl extends EventReceiver_1.EventReceiver {
+    constructor(url) {
+        super(EventReceiverType_1.EventReceiverType.HTTP);
+        this.url = url;
+    }
+}
+exports.EventReceiverHttpImpl = EventReceiverHttpImpl;

package/dist/xiot/core/spec/typedef/app/event/impl/EventReceiverKafkaImpl.d.ts

@@ -0,0 +1,6 @@
+import { EventReceiver } from '../EventReceiver';
+export declare class EventReceiverKafkaImpl extends EventReceiver {
+    topic: string;
+    bootstrapServers: string;
+    constructor(topic: string, bootstrapServers: string);
+}

package/dist/xiot/core/spec/typedef/app/event/impl/EventReceiverKafkaImpl.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventReceiverKafkaImpl = void 0;
+const EventReceiver_1 = require("../EventReceiver");
+const EventReceiverType_1 = require("../EventReceiverType");
+class EventReceiverKafkaImpl extends EventReceiver_1.EventReceiver {
+    constructor(topic, bootstrapServers) {
+        super(EventReceiverType_1.EventReceiverType.KAFKA);
+        this.topic = topic;
+        this.bootstrapServers = bootstrapServers;
+    }
+}
+exports.EventReceiverKafkaImpl = EventReceiverKafkaImpl;

package/dist/xiot/core/spec/typedef/constant/Spec.d.ts

@@ -0,0 +1,48 @@
+export declare class Spec {
+    static IID: string;
+    static SIID: string;
+    static PIID: string;
+    static TYPE: string;
+    static DESCRIPTION: string;
+    static SERVICES: string;
+    static PROPERTIES: string;
+    static ACTIONS: string;
+    static EVENTS: string;
+    static ACCESS: string;
+    static FORMAT: string;
+    static VALUE_LIST: string;
+    static VALUE_RANGE: string;
+    static IN: string;
+    static OUT: string;
+    static ARGUMENTS: string;
+    static VALUE: string;
+    static UNIT: string;
+    static PROPERTY: string;
+    static REPEAT: string;
+    static VALUES: string;
+    static MEMBERS: string;
+    static DEFAULT_VALUE: string;
+    static REQUIRED_SERVICES: string;
+    static OPTIONAL_SERVICES: string;
+    static REQUIRED_ACTIONS: string;
+    static OPTIONAL_ACTIONS: string;
+    static REQUIRED_EVENTS: string;
+    static OPTIONAL_EVENTS: string;
+    static REQUIRED_PROPERTIES: string;
+    static OPTIONAL_PROPERTIES: string;
+    static PID: string;
+    static AID: string;
+    static OID: string;
+    static EID: string;
+    static STATUS: string;
+    static NAME: string;
+    static NAMESPACE: string;
+    static ZH_CN: string;
+    static ZH_TW: string;
+    static EN_US: string;
+    static X_REQUIRED: string;
+    static X_PROPERTY_ADDABLE: string;
+    static X_ACTION_ADDABLE: string;
+    static X_EVENT_ADDABLE: string;
+    static X_SOURCE: string;
+}

package/dist/xiot/core/spec/typedef/constant/Spec.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spec = void 0;
+class Spec {
+}
+exports.Spec = Spec;
+Spec.IID = 'iid';
+Spec.SIID = 'siid';
+Spec.PIID = 'piid';
+Spec.TYPE = 'type';
+Spec.DESCRIPTION = 'description';
+Spec.SERVICES = 'services';
+Spec.PROPERTIES = 'properties';
+Spec.ACTIONS = 'actions';
+Spec.EVENTS = 'events';
+Spec.ACCESS = 'access';
+Spec.FORMAT = 'format';
+Spec.VALUE_LIST = 'value-list';
+Spec.VALUE_RANGE = 'value-range';
+Spec.IN = 'in';
+Spec.OUT = 'out';
+Spec.ARGUMENTS = 'arguments';
+Spec.VALUE = 'value';
+Spec.UNIT = 'unit';
+Spec.PROPERTY = 'property';
+Spec.REPEAT = 'repeat';
+Spec.VALUES = 'values';
+Spec.MEMBERS = 'members';
+Spec.DEFAULT_VALUE = 'default-value';
+Spec.REQUIRED_SERVICES = 'required-services';
+Spec.OPTIONAL_SERVICES = 'optional-services';
+Spec.REQUIRED_ACTIONS = 'required-actions';
+Spec.OPTIONAL_ACTIONS = 'optional-actions';
+Spec.REQUIRED_EVENTS = 'required-events';
+Spec.OPTIONAL_EVENTS = 'optional-events';
+Spec.REQUIRED_PROPERTIES = 'required-properties';
+Spec.OPTIONAL_PROPERTIES = 'optional-properties';
+Spec.PID = 'pid';
+Spec.AID = 'aid';
+Spec.OID = 'oid';
+Spec.EID = 'eid';
+Spec.STATUS = 'status';
+Spec.NAME = 'name';
+Spec.NAMESPACE = 'namespace';
+Spec.ZH_CN = 'zh-CN';
+Spec.ZH_TW = 'zh-TW';
+Spec.EN_US = 'en-US';
+Spec.X_REQUIRED = 'x-required';
+Spec.X_PROPERTY_ADDABLE = 'x-property-addable';
+Spec.X_ACTION_ADDABLE = 'x-action-addable';
+Spec.X_EVENT_ADDABLE = 'x-event-addable';
+Spec.X_SOURCE = 'source';

package/dist/xiot/core/spec/typedef/definition/ActionDefinition.d.ts

@@ -0,0 +1,9 @@
+import { ActionType } from './urn/ActionType';
+import { ArgumentDefinition } from './ArgumentDefinition';
+export declare class ActionDefinition {
+    type: ActionType;
+    description: Map<string, string>;
+    in: ArgumentDefinition[];
+    out: ArgumentDefinition[];
+    constructor(type: ActionType, description: Map<string, string>, argumentsIn: ArgumentDefinition[], argumentsOut: ArgumentDefinition[]);
+}

package/dist/xiot/core/spec/typedef/definition/ActionDefinition.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionDefinition = void 0;
+class ActionDefinition {
+    constructor(type, description, argumentsIn, argumentsOut) {
+        this.description = new Map();
+        this.in = [];
+        this.out = [];
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+        if (argumentsIn != null) {
+            this.in = argumentsIn;
+        }
+        if (argumentsOut != null) {
+            this.out = argumentsOut;
+        }
+    }
+}
+exports.ActionDefinition = ActionDefinition;

package/dist/xiot/core/spec/typedef/definition/ArgumentDefinition.d.ts

@@ -0,0 +1,7 @@
+import { PropertyType } from './urn/PropertyType';
+export declare class ArgumentDefinition {
+    type: PropertyType;
+    minRepeat: number;
+    maxRepeat: number;
+    constructor(type: PropertyType);
+}

package/dist/xiot/core/spec/typedef/definition/ArgumentDefinition.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentDefinition = void 0;
+class ArgumentDefinition {
+    constructor(type) {
+        this.minRepeat = 1;
+        this.maxRepeat = 1;
+        this.type = type;
+    }
+}
+exports.ArgumentDefinition = ArgumentDefinition;

package/dist/xiot/core/spec/typedef/definition/CategoryDefinition.d.ts

@@ -0,0 +1,5 @@
+export declare class CategoryDefinition {
+    name: string;
+    description: Map<string, string>;
+    constructor(name: string, description: Map<string, string>);
+}

package/dist/xiot/core/spec/typedef/definition/CategoryDefinition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryDefinition = void 0;
+class CategoryDefinition {
+    constructor(name, description) {
+        this.name = '';
+        this.description = new Map();
+        this.name = name;
+        this.description = description;
+    }
+}
+exports.CategoryDefinition = CategoryDefinition;

package/dist/xiot/core/spec/typedef/definition/DeviceDefinition.d.ts

@@ -0,0 +1,7 @@
+import { DeviceType } from './urn/DeviceType';
+export declare class DeviceDefinition {
+    category: string;
+    type: DeviceType;
+    description: Map<string, string>;
+    constructor(category: string, type: DeviceType, description: Map<string, string>);
+}

package/dist/xiot/core/spec/typedef/definition/DeviceDefinition.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceDefinition = void 0;
+class DeviceDefinition {
+    constructor(category, type, description) {
+        this.description = new Map();
+        this.category = category;
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+    }
+}
+exports.DeviceDefinition = DeviceDefinition;

package/dist/xiot/core/spec/typedef/definition/EventDefinition.d.ts

@@ -0,0 +1,8 @@
+import { EventType } from './urn/EventType';
+import { ArgumentDefinition } from './ArgumentDefinition';
+export declare class EventDefinition {
+    type: EventType;
+    description: Map<string, string>;
+    arguments: ArgumentDefinition[];
+    constructor(type: EventType, description: Map<string, string>, a: ArgumentDefinition[]);
+}

package/dist/xiot/core/spec/typedef/definition/EventDefinition.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDefinition = void 0;
+class EventDefinition {
+    constructor(type, description, a) {
+        this.description = new Map();
+        this.arguments = [];
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+        if (a != null) {
+            this.arguments = a;
+        }
+    }
+}
+exports.EventDefinition = EventDefinition;

package/dist/xiot/core/spec/typedef/definition/FormatDefinition.d.ts

@@ -0,0 +1,6 @@
+import { FormatType } from './urn/FormatType';
+export declare class FormatDefinition {
+    type: FormatType;
+    description: Map<string, string>;
+    constructor(type: FormatType, description: Map<string, string>);
+}

package/dist/xiot/core/spec/typedef/definition/FormatDefinition.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatDefinition = void 0;
+class FormatDefinition {
+    constructor(type, description) {
+        this.description = new Map();
+        this.type = type;
+        this.description = description;
+    }
+}
+exports.FormatDefinition = FormatDefinition;

package/dist/xiot/core/spec/typedef/definition/NamespaceDefinition.d.ts

@@ -0,0 +1,5 @@
+export declare class NamespaceDefinition {
+    namespace: string;
+    description: Map<string, string>;
+    constructor(namespace: string, description: Map<string, string>);
+}

package/dist/xiot/core/spec/typedef/definition/NamespaceDefinition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceDefinition = void 0;
+class NamespaceDefinition {
+    constructor(namespace, description) {
+        this.namespace = '';
+        this.description = new Map();
+        this.namespace = namespace;
+        this.description = description;
+    }
+}
+exports.NamespaceDefinition = NamespaceDefinition;

package/dist/xiot/core/spec/typedef/definition/PropertyDefinition.d.ts

@@ -0,0 +1,24 @@
+import { PropertyType } from './urn/PropertyType';
+import { DataFormat } from './property/data/DataFormat';
+import { Access } from './property/Access';
+import { ConstraintValue } from './property/ConstraintValue';
+import { ValueRange } from "./property/ValueRange";
+import { ValueList } from "./property/ValueList";
+export declare class PropertyDefinition {
+    type: PropertyType;
+    description: Map<string, string>;
+    format: DataFormat;
+    access: Access;
+    constraintValue: ConstraintValue | null;
+    unit: string | null;
+    members: Array<PropertyType>;
+    constructor(type: PropertyType, description: Map<string, string>);
+    hasConstraintValue(): boolean;
+    hasValueRange(): boolean;
+    hasValueList(): boolean;
+    valueRange(): ValueRange | null;
+    valueList(): ValueList | null;
+    formatBoolean(): boolean;
+    formatString(): boolean;
+    formatNumber(): boolean;
+}

package/dist/xiot/core/spec/typedef/definition/PropertyDefinition.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyDefinition = void 0;
+const DataFormat_1 = require("./property/data/DataFormat");
+const Access_1 = require("./property/Access");
+const ValueRange_1 = require("./property/ValueRange");
+const ValueList_1 = require("./property/ValueList");
+class PropertyDefinition {
+    constructor(type, description) {
+        this.description = new Map();
+        this.format = DataFormat_1.DataFormat.BOOL;
+        this.access = new Access_1.Access();
+        this.constraintValue = null;
+        this.unit = null;
+        this.members = [];
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+    }
+    hasConstraintValue() {
+        return this.constraintValue != null;
+    }
+    hasValueRange() {
+        return this.constraintValue instanceof ValueRange_1.ValueRange;
+    }
+    hasValueList() {
+        return this.constraintValue instanceof ValueList_1.ValueList;
+    }
+    valueRange() {
+        if (this.constraintValue instanceof ValueRange_1.ValueRange) {
+            return this.constraintValue;
+        }
+        return null;
+    }
+    valueList() {
+        if (this.constraintValue instanceof ValueList_1.ValueList) {
+            return this.constraintValue;
+        }
+        return null;
+    }
+    formatBoolean() {
+        return this.format == DataFormat_1.DataFormat.BOOL;
+    }
+    formatString() {
+        switch (this.format) {
+            case DataFormat_1.DataFormat.STRING:
+            case DataFormat_1.DataFormat.HEX:
+            case DataFormat_1.DataFormat.TLV8:
+                return true;
+            default:
+                return false;
+        }
+    }
+    formatNumber() {
+        switch (this.format) {
+            case DataFormat_1.DataFormat.FLOAT:
+            case DataFormat_1.DataFormat.UINT8:
+            case DataFormat_1.DataFormat.UINT16:
+            case DataFormat_1.DataFormat.UINT32:
+            case DataFormat_1.DataFormat.INT8:
+            case DataFormat_1.DataFormat.INT16:
+            case DataFormat_1.DataFormat.INT32:
+            case DataFormat_1.DataFormat.INT64:
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+exports.PropertyDefinition = PropertyDefinition;

package/dist/xiot/core/spec/typedef/definition/ServiceDefinition.d.ts

@@ -0,0 +1,15 @@
+import { ServiceType } from './urn/ServiceType';
+import { PropertyType } from './urn/PropertyType';
+import { ActionType } from './urn/ActionType';
+import { EventType } from './urn/EventType';
+export declare class ServiceDefinition {
+    type: ServiceType;
+    description: Map<string, string>;
+    requiredProperties: PropertyType[];
+    optionalProperties: PropertyType[];
+    requiredActions: ActionType[];
+    optionalActions: ActionType[];
+    requiredEvents: EventType[];
+    optionalEvents: EventType[];
+    constructor(type: ServiceType, description: Map<string, string>, requiredProperties: PropertyType[], optionalProperties: PropertyType[], requiredActions: ActionType[], optionalActions: ActionType[], requiredEvents: EventType[], optionalEvents: EventType[]);
+}

package/dist/xiot/core/spec/typedef/definition/ServiceDefinition.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDefinition = void 0;
+class ServiceDefinition {
+    constructor(type, description, requiredProperties, optionalProperties, requiredActions, optionalActions, requiredEvents, optionalEvents) {
+        this.description = new Map();
+        this.requiredProperties = [];
+        this.optionalProperties = [];
+        this.requiredActions = [];
+        this.optionalActions = [];
+        this.requiredEvents = [];
+        this.optionalEvents = [];
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+        if (requiredProperties != null) {
+            this.requiredProperties = requiredProperties;
+        }
+        if (optionalProperties != null) {
+            this.optionalProperties = optionalProperties;
+        }
+        if (requiredActions != null) {
+            this.requiredActions = requiredActions;
+        }
+        if (optionalActions != null) {
+            this.optionalActions = optionalActions;
+        }
+        if (requiredEvents != null) {
+            this.requiredEvents = requiredEvents;
+        }
+        if (optionalEvents != null) {
+            this.optionalEvents = optionalEvents;
+        }
+    }
+}
+exports.ServiceDefinition = ServiceDefinition;

package/dist/xiot/core/spec/typedef/definition/UnitDefinition.d.ts

@@ -0,0 +1,6 @@
+import { UnitType } from './urn/UnitType';
+export declare class UnitDefinition {
+    type: UnitType;
+    description: Map<string, string>;
+    constructor(type: UnitType, description: Map<string, string>);
+}

package/dist/xiot/core/spec/typedef/definition/UnitDefinition.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitDefinition = void 0;
+class UnitDefinition {
+    constructor(type, description) {
+        this.description = new Map();
+        this.type = type;
+        this.description = description;
+    }
+}
+exports.UnitDefinition = UnitDefinition;

package/dist/xiot/core/spec/typedef/definition/property/Access.d.ts

@@ -0,0 +1,11 @@
+export declare class Access {
+    isReadable: boolean;
+    isWritable: boolean;
+    isNotifiable: boolean;
+    static of(readable: boolean, writable: boolean, notifiable: boolean): Access;
+    static create(access: Array<string>): Access;
+    toList(): Array<string>;
+    toString(): string;
+    toZhCNList(): string[];
+    toListOptions(): any[];
+}