o2g-node-sdk 1.0.0

package/dist/types/pbxmngt/pbx-attr-map.d.ts

@@ -0,0 +1,91 @@
+import { O2GPbxComplexAttribute } from "../../internal/types/pbxmngt/o2gpbxmngt-types";
+import { PbxAttribute } from "./pbx-attribute";
+/**
+ * PbxAttributeMap represents a sequence of named attributes.
+ */
+export declare class PbxAttributeMap {
+    private _attributes;
+    /**
+     * @internal
+     */
+    constructor();
+    /**
+     * Returns the names of the attributes in this sequence.
+     */
+    get names(): string[];
+    /**
+     * Returns the Attribute with the specified name.
+     * @example
+     * ```typescript
+     *     let skillSequence = ...
+     *     let attr = skillSequence.getAttribute("Skill_nb");
+     * ```
+     *
+     * @param name The attribute name
+     */
+    getAttribute(name: string): PbxAttribute | undefined;
+    /**
+     * Adds the specified attribute to this sequence. It's possible to chain the
+     * add operations to create a complete sequence.
+     *
+     * @example
+     * ```typescript
+     *        let attr = PbxAttributeMap.create()
+     *                      .add(PbxAttribute.createBoolean("Elem1", true))
+     *                      .add(PbxAttribute.createInteger("Elem2", 23));
+     * ```
+     *
+     * @param value the attribute to add to this sequence
+     * @return the sequence object.
+     */
+    add(value: PbxAttribute): PbxAttributeMap;
+    /**
+     * Create a new empty PbxAttributeMap. Use this method to create a new sequence
+     * of attribute. For example:
+     *
+     * @example
+     * ```typescript
+     *     Sequence {
+     *         Param1 := Integer,
+     *         Param2 := Boolean
+     *     }
+     * ```
+     * Can be created with the following operations
+     * ```typescript
+     *     let sequence = PbxAttributeMap.create()
+     *                      .add(PbxAttribute.createInteger("Param1", 1))
+     *                      .add(PbxAttribute.createBoolean("Param2", true));
+     * ```
+     */
+    static create(): PbxAttributeMap;
+    /**
+     * Create a new PbxAttributeMap with the specified attributes.
+     * Use this method to create a new sequence of attributes. For example:
+     *
+     * @example
+     * ```typescript
+     *     Sequence {
+     *         Param1 := Integer,
+     *         Param2 := Boolean
+     *     }
+     * ```
+     * Can be created with the following:
+     * ```typescript
+     *     let sequence = PbxAttributeMap.createWith([
+     *         PbxAttribute.createInteger("Param1", 1),
+     *         PbxAttribute.createBoolean("Param2", true)
+     *     ]);
+     * ```
+     *
+     * @param attributes the array of attributes
+     */
+    static createWith(attributes: PbxAttribute[]): PbxAttributeMap;
+    /**
+     * @ignore
+     */
+    static build(o2gPbxComplexAttribute: O2GPbxComplexAttribute): PbxAttributeMap;
+    /**
+     * @ignore
+     */
+    static from(attributeMaps: PbxAttributeMap, attrName: string): O2GPbxComplexAttribute;
+}

package/dist/types/pbxmngt/pbx-attribute.d.ts

@@ -0,0 +1,87 @@
+import { PbxAttributeMap } from "./pbx-attr-map";
+import { O2GPbxAttribute } from "../../internal/types/pbxmngt/o2gpbxmngt-types";
+/**
+ * PbxAttribute class represents an attribute in a {@link PbxObject} object. A PbxAttribute
+ * can be of the following type:
+ * <p><b><u>Integer</u></b>: An Integer value is equivalent to an int value.
+ * <p><b><u>Boolean</u></b>: An Boolean value is equivalent to an boolean value.
+ * <p><b><u>Enumerated</u></b>: An enumerated value can have a limited set of possible
+ * values. PbxAttribute treats enumerated value as string value.
+ * <p><b><u>OctetString, ByteString</u></b>: An OctetString or a ByteString are equivalent to a string value.
+ * <p><b><u>Sequence</u></b>: A Sequence is a structured data whose attribute member have
+ * a specific name and type: For exemple
+ * @example
+ * ```typescript
+ *     Skill := Sequence {
+ *         Skill_Nb := Integer,
+ *         Skill_Level := Integer,
+ *         Skill_Activate := Boolean
+ *     }
+ * ```
+ *
+ * <p><b><u>Set</u></b>: A Set value is a list of attributes of the same type. It can be
+ * a list of simple value like:
+ *
+ * @example
+ * ```typescript
+ *     SimpleSet := Set {
+ *         Item := OctetString
+ *     }
+ * ```
+ *
+ * or a list of sequences:
+ *
+ * @example
+ * ```typescript
+ *     SkillSet := Set {
+ *         Item := Sequence {
+ *             Skill_Nb := Integer,
+ *             Skill_Level := Integer,
+ *             Skill_Activate := Boolean
+ *         }
+ *     }
+ * ```
+ */
+export declare class PbxAttribute {
+    private _name;
+    private _values;
+    private _attributeMaps;
+    private _sequenceMap;
+    /**
+     * @internal
+     */
+    constructor(name: string);
+    /**
+     * Returns this attribute's name.
+     */
+    get name(): string;
+    /**
+     * @ignore
+     */
+    static build(attr: O2GPbxAttribute): PbxAttribute;
+    /**
+     * @ignore
+     */
+    static addSequenceAttribute(pbxAttribute: PbxAttribute, name: string, attr: O2GPbxAttribute): void;
+    static createSetOfStrings(attrName: string, values: string[]): PbxAttribute;
+    static createString(attrName: string, value: string): PbxAttribute;
+    static createBoolean(attrName: string, value: boolean): PbxAttribute;
+    static createInteger(attrName: string, value: number): PbxAttribute;
+    static createSequence(attrName: string, sequence: PbxAttributeMap): PbxAttribute;
+    static createSequenceSet(attrName: string, setOfSequences: PbxAttributeMap[]): PbxAttribute;
+    getAt(index: number): PbxAttributeMap;
+    asAttributeMap(): PbxAttributeMap | null;
+    asListOfMaps(): PbxAttributeMap[] | null;
+    private _assertUnique;
+    asBoolean(): boolean;
+    setBoolean(value: boolean): void;
+    asInteger(): number;
+    setInteger(value: number): void;
+    asString(): string;
+    setString(value: string): void;
+    asEnum(): string;
+    /**
+     * @ignore
+     */
+    static from(attr: PbxAttribute): O2GPbxAttribute[];
+}

package/dist/types/pbxmngt/pbx-object.d.ts

@@ -0,0 +1,45 @@
+import { PbxAttribute } from "./pbx-attribute";
+import { O2GPbxObject } from "../../internal/types/pbxmngt/o2gpbxmngt-types";
+/**
+ * PbxObject represents an object of the OmniPCX Enterprise object model.
+ * <p>
+ * A PbxObject object is referenced by it's object instance definition,
+ * a hierarchical path from the root object, and a unique instance id.<br>
+ * For exemple:
+ * <ul>
+ * <li>"Subscriber" : A Subscriber object.</li>
+ * <li>"Application_Configuration/1/ACD2/1/ACD2_Operator/1/ACD2_Operator_data" :
+ * A CCD operator data object.</li>
+ * </ul>
+ */
+export declare class PbxObject {
+    private _objectName;
+    private _id;
+    private _objectNames;
+    private _attributes;
+    /**
+     * @internal
+     */
+    private constructor();
+    /**
+     * Returns the collection of sub-object names.
+     */
+    get objectNames(): string[];
+    /**
+     * Returns this object's name.
+     */
+    get name(): string;
+    /**
+     * Returns this object's instance ID.
+     */
+    get id(): string;
+    /**
+     * Returns the attribute with the specified name.
+     * @param attrName The attribute name.
+     */
+    getAttribute(attrName: string): PbxAttribute | undefined;
+    /**
+     * @ignore
+     */
+    static build(o2GPbxObject: O2GPbxObject): PbxObject;
+}

package/dist/types/pbxmngt/pbxmngt-events.d.ts

@@ -0,0 +1,59 @@
+import { O2GEvent } from "../../internal/events/o2g-event";
+/**
+ * Represent an OmniPCX Enterprise object definition.
+ */
+export type PbxObjectDefinition = {
+    objectName: string;
+    objectId: string;
+};
+/**
+ * Notification sent when a PBX object instance is created. Only Object Subscriber is concerned by this event.
+ */
+export type OnPbxObjectInstanceCreated = O2GEvent<'OnPbxObjectInstanceCreated', {
+    /**
+     * The created object definition.
+     */
+    object: PbxObjectDefinition;
+    /**
+     * The object father of the created object.
+     */
+    father: PbxObjectDefinition;
+    /**
+     * The OmniPCX Enterprise node id that send this event.
+     */
+    nodeId: number;
+}>;
+/**
+ * Notification sent when a PBX object instance is deleted. Only Object Subscriber is concerned by this event.
+ */
+export type OnPbxObjectInstanceDeleted = O2GEvent<'OnPbxObjectInstanceDeleted', {
+    /**
+     * The deleted object definition.
+     */
+    object: PbxObjectDefinition;
+    /**
+     * The object father of the deleted object.
+     */
+    father: PbxObjectDefinition;
+    /**
+     * The OmniPCX Enterprise node id that send this event.
+     */
+    nodeId: number;
+}>;
+/**
+ * Notification sent when a PBX object instance is modified. Only Object Subscriber is concerned by this event.
+ */
+export type OnPbxObjectInstanceModified = O2GEvent<'OnPbxObjectInstanceModified', {
+    /**
+     * The modified object definition.
+     */
+    object: PbxObjectDefinition;
+    /**
+     * The object father of the modified object.
+     */
+    father: PbxObjectDefinition;
+    /**
+     * The OmniPCX Enterprise node id that send this event.
+     */
+    nodeId: number;
+}>;

package/dist/types/pbxmngt/pbxmngt-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pbx represents basic information of a Pbx (OmniPCX Enterprise).
+ * In an OmniPcx Enterprise sub-network, each OXE node is identifier by a unique node id.
+ */
+export type Pbx = {
+    /**
+     * The OmniPcx Enterprise node id.
+     */
+    nodeId: number;
+    /**
+     * The OmniPCX Enterprise node Fqdn.
+     */
+    fqdn: string;
+};

package/dist/types/phoneset/device-key.d.ts

@@ -0,0 +1,27 @@
+/**
+ * DeviceKey class represents the base class for key on an OmniPCX Enterprise device.
+ */
+export declare class DeviceKey {
+    protected _position: number;
+    protected _number: string;
+    protected _mnemonic: string | null;
+    /**
+     * Constructs a new DeviceKey with the specified position, number, and optional mnemonic.
+     * @param position The key position on the device.
+     * @param number The phone number associated with this key.
+     * @param mnemonic The mnemonic associated with this key (optional).
+     */
+    constructor(position: number, number: string, mnemonic?: string | null);
+    /**
+     * Returns the key position.
+     */
+    get position(): number;
+    /**
+     * Returns the key-associated number.
+     */
+    get number(): string;
+    /**
+     * Returns the key mnemonic, or null if not set.
+     */
+    get mnemonic(): string | null;
+}

package/dist/types/phoneset/phoneset-types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DynamicState represents the dynamic state of a device. This state provide information on the associate, and the locked and campon state.
+ */
+export type DynamicState = {
+    /**
+     * Whether the device is locked.
+     */
+    lock: boolean;
+    /**
+     * Whether the camp on is activated.
+     */
+    campon: boolean;
+    /**
+     * The associated phone number.
+     */
+    associate: string;
+};

package/dist/types/phoneset/pin-control.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The type of access of a PIN code.
+ */
+export declare enum PinControl {
+    /**
+     * PIN code can be used from any set according to categories.
+     */
+    ByCategory = "PIN_Category",
+    /**
+     * PIN code is restricted to the users set.
+     */
+    RestrictedToOwner = "PIN_Restricted_To_Owner_Set",
+    /**
+     * PIN code can be used on any set in the system.
+     */
+    UniversalAccess = "PIN_Universal_Access",
+    /**
+     * PIN code is limited to specific group.
+     */
+    ByGroup = "PIN_By_Group"
+}

package/dist/types/phoneset/pin.d.ts

@@ -0,0 +1,50 @@
+import { O2GPinCode } from "../../internal/types/phoneset/phoneset-types";
+import { PinControl } from "./pin-control";
+/**
+ * Pin class represents a PIN (Personal Identification Number)
+ * <p>
+ * This service allows the user to announce that the call he is making is a personal (external) call and not a business call.
+ * Using pulse metering tickets, the company is then able to invoice this call again as a personal call.
+ * <p>
+ * This service can be applied to local users (employees) or visitors (in this case, the created user set is a virtual set without a physical address).
+ * <p>
+ * To use this service, users must dial the personal prefix followed by the PIN No. and then the secret code followed by the external number.
+ * <p>
+ * The Personal Identification Number is private and secret; only the administrator and, in certain cases, the pulse metering administrator may know it.
+ */
+export declare class Pin {
+    private _number;
+    private _withSecretCode;
+    private _control;
+    private _group;
+    /**
+     * @internal
+     */
+    private constructor();
+    /**
+     * Returns the PIN number.
+     */
+    get number(): string;
+    /**
+     * Returns whether the PIN code requires validation via the user's secret code.
+     */
+    get withSecretCode(): boolean;
+    /**
+     * Returns the access control associated with this PIN code.
+     */
+    get control(): PinControl;
+    /**
+     * Returns the PIN group associated with this PIN code.
+     */
+    get group(): number;
+    /**
+     * Builds a Pin object from an O2GPinCode object.
+     * @internal
+     */
+    static build(pin: O2GPinCode): Pin;
+    /**
+     * Converts a Pin instance into an O2GPinCode object.
+     * @internal
+     */
+    static from(pin: Pin): O2GPinCode;
+}

package/dist/types/phoneset/programmable-key.d.ts

@@ -0,0 +1,23 @@
+import { DeviceKey } from "./device-key";
+/**
+ * ProgrammableKey class represents a programmable key on an OmniPCX Enterprise device.
+ */
+export declare class ProgrammableKey extends DeviceKey {
+    private _locked;
+    /**
+     * Construct a new ProgrammableKey with the specified parameters.
+     * @param position the key position
+     * @param number the associated number
+     * @param mnemonic the key mnemonic
+     * @param locked 'true' if the key is locked, 'false' otherwise
+     */
+    constructor(position: number, number: string, mnemonic?: string | null, locked?: boolean);
+    /**
+     * Return whether this key is locked.
+     */
+    get locked(): boolean;
+    /**
+     * @ignore
+     */
+    static build(pkey: any): ProgrammableKey;
+}

package/dist/types/phoneset/softkey.d.ts

@@ -0,0 +1,17 @@
+import { DeviceKey } from "./device-key";
+/**
+ * SoftKey class represents a software key on an OmniPcx Enterprise device.
+ */
+export declare class SoftKey extends DeviceKey {
+    /**
+     * Construct a new SoftKey with the specified parameters.
+     * @param position the key position
+     * @param number the associated number
+     * @param mnemonic the key mnemonic
+     */
+    constructor(position: number, number: string, mnemonic?: string | null);
+    /**
+     * @ignore
+     */
+    static build(pkey: any): SoftKey;
+}

package/dist/types/routing/destination.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Destination represents a forward or an overflow destination.
+ * @see {@link Forward}
+ * @see {@link Overflow}
+ */
+export declare enum Destination {
+    /**
+     * The destination is the user voice mail.
+     */
+    VOICEMAIL = "VOICEMAIL",
+    /**
+     * The destination is another phone number. This destination can be used only to configure a forward.
+     */
+    NUMBER = "NUMBER",
+    /**
+     * None destination.
+     */
+    NONE = "NONE"
+}

package/dist/types/routing/forward.d.ts

@@ -0,0 +1,51 @@
+import { ForwardRoute } from "../../internal/types/routing/forward-route";
+import { Destination } from "./destination";
+/**
+ * ForwardCondition represents the possible condition a user can associate to a forward.
+ */
+export declare enum ForwardCondition {
+    /**
+     * Incoming calls are immediately forwarded on the target.
+     */
+    IMMEDIATE = "IMMEDIATE",
+    /**
+     * Incoming calls are forwarded on the target if the user is busy.
+     */
+    BUSY = "BUSY",
+    /**
+     * Incoming calls are forwarded on the target if the user does not answer the call.
+     */
+    NO_ANSWER = "NO_ANSWER",
+    /**
+     * Incoming calls are forwarded on the target if the user is busy or if the user does not answer the call.
+     */
+    BUSY_OR_NO_ANSWER = "BUSY_OR_NO_ANSWER"
+}
+/**
+ * Forward represents a forward the user has activated.
+ */
+export declare class Forward {
+    private _destination;
+    private _number;
+    private _condition;
+    /**
+     * @internal
+     */
+    private constructor();
+    /**
+     * Returns this forward destination.
+     */
+    get destination(): Destination;
+    /**
+     * Returns the number destination of this forward.
+     */
+    get number(): string | null;
+    /**
+     * Returns this forward associated condition.
+     */
+    get condition(): ForwardCondition | null;
+    /**
+     * @ignore
+     */
+    static build(forwardRoute?: ForwardRoute | null): Forward;
+}

package/dist/types/routing/overflow.d.ts

@@ -0,0 +1,42 @@
+import OverflowRoute from "../../internal/types/routing/overflow-route";
+import { Destination } from "./destination";
+/**
+ * OverflowCondition represents the possible condition a user can associate to an overflow.
+ */
+export declare enum OverflowCondition {
+    /**
+     * Incoming calls are forwarded on the target if the user is busy.
+     */
+    BUSY = "BUSY",
+    /**
+     * Incoming calls are forwarded on the target if the user does not answer the call.
+     */
+    NO_ANSWER = "NO_ANSWER",
+    /**
+     * Incoming calls are forwarded on the target if the user is busy or if the user does not answer the call.
+     */
+    BUSY_OR_NO_ANSWER = "BUSY_OR_NO_ANSWER"
+}
+/**
+ * Overflow represents an overflow the user has activated.
+ */
+export declare class Overflow {
+    private _destination;
+    private _condition;
+    /**
+     * @internal
+     */
+    private constructor();
+    /**
+     * Returns this overflow destination.
+     */
+    get destination(): Destination;
+    /**
+     * Returns this overflow associated condition.
+     */
+    get condition(): OverflowCondition | null;
+    /**
+     * @ignore
+     */
+    static build(overflowRoute?: OverflowRoute | null): Overflow;
+}

package/dist/types/routing/routing-capability.d.ts

@@ -0,0 +1,31 @@
+import { O2GRoutingCapabilities } from "../../internal/types/routing/o2grouting-types";
+/**
+ * RoutingCapabilities represents the routing capability of a user.
+ */
+export declare class RoutingCapabilities {
+    private _presentationRoute;
+    private _forwardRoute;
+    private _overflowRoute;
+    private _dnd;
+    /**
+     * @internal
+     */
+    constructor();
+    get canManageRemoteExtension(): boolean;
+    /**
+     * Returns whether this user can manage forward.
+     */
+    get canManageForward(): boolean;
+    /**
+     * Returns whether this user can manage overflow.
+     */
+    get canManageOverflow(): boolean;
+    /**
+     * Returns whether this user can manage do not disturb.
+     */
+    get canManageDnd(): boolean;
+    /**
+     * @ignore
+     */
+    static build(capabilities: O2GRoutingCapabilities): RoutingCapabilities;
+}

package/dist/types/routing/routing-events.d.ts

@@ -0,0 +1,15 @@
+import { O2GEvent } from "../../internal/events/o2g-event";
+import { RoutingState } from "./routing-state";
+/**
+ * This notification indicate that routing state is changed.
+ */
+export type OnRoutingStateChanged = O2GEvent<'OnRoutingStateChanged', {
+    /**
+     * Login name of the user (identifier which can be used for filtering).
+     */
+    loginName: string;
+    /**
+     * Current routing state.
+     */
+    routingState: RoutingState;
+}>;