compass.js/build/Compass.d.ts

Compass Javascript Library =============

declare module "compass.js"
{
	export { Connection } from "./Connection";
	export { CallEndReason, Side, OtherSide, CallState, CallPointState, CallPointType, Call, CallPoint, User, UserCallPoint, DialplanCallPoint, ExternalCallPoint, QueueCallPoint, ListenInCallPoint, Queue, QueueMember, Company, Model, ReceiveCalls, UserStatus, WrapupState } from "./Model";
	export { compassLogger, rootLogger } from "./Logging";
	export { Event, EventType } from "./Events";
	export { RestApi } from "./RestApi";

	/// <reference types="jquery" />
	import Builder = Strophe.Builder;
	import { Strophe as Strophe } from "strophe.js";
	import "strophejs-plugin-pubsub";
	const COMPASS_NS = "http://iperity.com/compass";
	export class Connection {
	    logXmpp: boolean;
	    readonly model: Model;
	    rest: RestApi;
	    statusCallback: (status: Strophe.Status, msg: string) => void;
	    stropheConnection: Strophe.Connection;
	    jid: string;
	    readonly basedom: string;
	    private _server;
	    private _domain;
	    private _xmppHandler;
	    private _autoReconnectHandler;
	    private _closed;
	    constructor(basedom: string);
	    connect(jid: any, password: any): Promise<void>;
	    sendIQ(iq: Element | Builder): Promise<JQuery>;
	    close(): void;
	    disconnect(): void;
	    private _internalConnect;
	    private _onConnected;
	    private _onSubscribed;
	    private _getCompany;
	    private _getObjectsOfType;
	    private _sendInitialPresence;
	    private _setInvisible;
	    private _setupConnection;
	    private _subscribeToPubsub;
	    private _onReceivePubsub;
	    private _callback;
	}

	export enum EventType {
	    Added = "Added",
	    Removed = "Removed",
	    Changed = "Changed",
	    CallAdded = "CallAdded",
	    CallRemoved = "CallRemoved",
	    QueueAdded = "QueueAdded",
	    QueueRemoved = "QueueRemoved",
	    UserAdded = "UserAdded",
	    UserRemoved = "UserRemoved",
	    Paused = "Paused",
	    Unpaused = "Unpaused",
	    PropertyChanged = "PropertyChanged",
	    Invalidated = "Invalidated"
	}
	export class Event {
	    emitter: CompassObject;
	    eventType: EventType;
	    data: any;
	    constructor(emitter: CompassObject, eventType: EventType, data?: any);
	}

	import * as loglevel from 'loglevel';
	export const rootLogger: loglevel.RootLogger;
	export const compassLogger: loglevel.Logger;

	/// <reference types="jquery" />
	import { Observable } from "rxjs";
	export enum CallState {
	    connecting = "CONNECTING",
	    ringing = "RINGING",
	    answered = "ANSWERED",
	    on_hold = "ON_HOLD",
	    disconnected = "DISCONNECTED"
	}
	export enum CallPointState {
	    connecting = "CONNECTING",
	    ringing = "RINGING",
	    answered = "ANSWERED",
	    inactive = "INACTIVE",
	    disconnected = "DISCONNECTED"
	}
	export enum CallEndReason {
	    sourceHangup = "SOURCE_HANGUP",
	    destinationHangup = "DESTINATION_HANGUP",
	    destinationBusy = "DESTINATION_BUSY",
	    unknown = "unknown"
	}
	export enum Side {
	    source = 0,
	    destination = 1
	}
	export class UserStatus {
	    receiveCalls: ReceiveCalls;
	    displayStatus: string;
	    wrapupState: WrapupState | null;
	    constructor(receiveCalls: ReceiveCalls, displayStatus: string, wrapupState: WrapupState | null);
	}
	export enum ReceiveCalls {
	    all = "ALL",
	    none = "NONE",
	    onlyDirect = "ONLY_DIRECT"
	}
	export class WrapupState {
	    callId: string;
	    endTime: number | null;
	    constructor(callId: string, endTime: number | null);
	}
	export function OtherSide(side: Side): Side;
	export abstract class CompassObject {
	    domain: Model;
	    id: string;
	    xmlElement: JQuery;
	    constructor(id: string, xmlElement: JQuery, domain: Model);
	    toString(): string;
	}
	export class Company extends CompassObject {
	    name: string;
	}
	export class Call extends CompassObject {
	    state: CallState;
	    source: CallPoint;
	    destination: CallPoint;
	    parentCall: Call;
	    getEndpoint(side: Side): CallPoint;
	}
	export enum CallPointType {
	    unknown = "Unknown",
	    user = "User",
	    dialplan = "Dialplan",
	    external = "External",
	    resource = "Resource",
	    queue = "Queue",
	    listenIn = "ListenIn"
	}
	export enum ResourceType {
	    conference = "conference",
	    extension = "extension",
	    forward = "forward",
	    ivr = "ivr",
	    musiconhold = "musiconhold",
	    nameprefix = "nameprefix",
	    phone = "phone",
	    voicemail = "voicemail",
	    dpswitch = "dpswitch",
	    externalNumber = "externalNumber",
	    input = "input"
	}
	export class CallPoint extends CompassObject {
	    type: CallPointType;
	    state: CallPointState;
	    timeCreated: number;
	    timeStarted: number;
	    constructor(id: string, xmlElement: JQuery, domain: Model);
	    getDuration(): number;
	    getAnsweredDuration(): number;
	}
	export class ExternalCallPoint extends CallPoint {
	    number: string;
	    name: string;
	}
	export class DialplanCallPoint extends CallPoint {
	    exten: string;
	    description: string;
	}
	export class UserCallPoint extends CallPoint {
	    userId: string;
	    userName: string;
	    identityId: string;
	    getUser(): User;
	}
	export class ResourceCallPoint extends CallPoint {
	    resourceType: string;
	    resourceId: string;
	    name: string;
	}
	export class ListenInCallPoint extends CallPoint {
	    listenedToCallId: string;
	    getListenedToCall(): Call;
	}
	export class QueueCallPoint extends CallPoint {
	    queueId: string;
	    queueName: string;
	    getQueue(): Queue;
	}
	export enum Language {
	    nl = "nl",
	    en = "en"
	}
	export class User extends CompassObject {
	    name: string;
	    loggedIn: boolean;
	    extensions: string[];
	    jid: string;
	    username: string;
	    phoneId: number;
	    language: Language;
	    contact: string;
	    status: UserStatus;
	    getQueues(): Queue[];
	    getPausedQueues(): Queue[];
	    getCalls(): Call[];
	}
	export class QueueMember {
	    userId: string;
	    queueId: string;
	    priority: number;
	    pausedSince: number;
	    domain: Model;
	    constructor(userId: string, queueId: string, priority: string, pausedSince: string, domain: Model);
	    setPriority(priority: string): void;
	    setPausedSince(pausedSince: string): void;
	    isPaused(): boolean;
	    getUser(): User;
	    getQueue(): Queue;
	}
	export class Queue extends CompassObject {
	    name: string;
	    queueMembers: QueueMember[];
	    getUsers(): User[];
	    getPausedUsers(): User[];
	    isUserInQueue(userId: string): boolean;
	    isUserPausedInQueue(userId: string): boolean;
	    getQueueMember(userId: string): QueueMember;
	    getCalls(): Call[];
	}
	export class Model {
	    company: Company;
	    calls: {
	        [id: string]: Call;
	    };
	    users: {
	        [id: string]: User;
	    };
	    queues: {
	        [id: string]: Queue;
	    };
	    callsObservable: Observable<Event>;
	    usersObservable: Observable<Event>;
	    queuesObservable: Observable<Event>;
	    constructor();
	    notifyConnected(): void;
	    getUserForJid(jid: string): User;
	    notify(e: Event): void;
	    clear(): void;
	    private usersSubject;
	    private callsSubject;
	    private queuesSubject;
	}

	/// <reference types="jquery" />
	interface IParser {
	    parse(elem: JQuery, parserContext: ParserContext): CompassObject;
	}
	class ParserContext {
	    constructor(parser: ParserRegistry, model: Model);
	    parser: ParserRegistry;
	    model: Model;
	}
	export enum ObjectType {
	    Company = 0,
	    User = 1,
	    Queue = 2,
	    Call = 3,
	    CallPoint = 4
	}
	export class ParserRegistry {
	    private readonly _parserContext;
	    constructor(model: Model);
	    parse(elem: JQuery, type: ObjectType): CompassObject;
	    private static readonly _parsers;
	    static registerParser(parser: IParser, type: ObjectType): void;
	}
	export function parseNumberOrNull(val: string): number;
	export function parseBoolean(val: string): boolean;
	export function parseWrapupState(elem: JQuery): WrapupState;

	export class RestApi {
	    authHeader: string;
	    baseUrl: string;
	    private readonly _username;
	    private readonly _basedom;
	    private _user;
	    private _apiVersion?;
	    private _myCompanyUrlPromise;
	    private _myFirstIdentityPromise;
	    constructor(basedom: string, username: string, password: string);
	    get(url: string, data?: any): Promise<any>;
	    post(url: string, data?: any): Promise<any>;
	    patch(url: string, data: any): Promise<any>;
	    delete(url: string): Promise<any>;
	    doRequest(url: string, method: string, data: any): Promise<any>;
	    private doRequestInternal;
	    getApiVersion(): Promise<number>;
	    private determineApiVersion;
	    getMyUser(): Promise<any>;
	    getMyFirstIdentity(): Promise<any>;
	    getMyCompany(): Promise<any>;
	    getUrlForObject(type: string, id: number): string;
	}

	function randomstring(length?: number): string;
	function b64EncodeUnicode(str: string): string;

	/// <reference types="jquery" />
	export class XmppHandler {
	    protected _handler: XmppNotificationHandler;
	    protected parser: ParserRegistry;
	    model: Model;
	    constructor(model: Model);
	    setCompanyFromXmpp(elem: JQuery): void;
	    setUsersFromXmpp(users: JQuery): void;
	    setCallsFromXmpp(callsElem: JQuery): void;
	    setQueuesFromXmpp(queues: JQuery): void;
	    handleNotification(not: JQuery): void;
	    setCompany(company: Company): void;
	    addUser(user: User, sendNotification?: boolean): void;
	    removeUser(userId: string, sendNotification?: boolean): void;
	    userUpdateStatus(user: User, newStatus: UserStatus): void;
	    addCall(call: Call, sendNotification?: boolean): void;
	    removeCall(callId: string, reason: CallEndReason, sendNotification?: boolean): void;
	    addQueue(queue: Queue, sendNotification?: boolean): void;
	    removeQueue(queueId: string, sendNotification?: boolean): void;
	    deleteFromArray(arr: any, element: any): boolean;
	    sendEventsCallAdded(call: Call, data?: any): void;
	    sendEventsCallRemoved(call: Call, data?: any): void;
	    sendEventsOnCallAndEndpoint(call: Call, added: boolean, data?: any): void;
	    protected sendEventsForCallPoint(call: Call, callPoint: CallPoint, added: boolean): void;
	    sendEventsCallUpdated(call: Call, origCallpoint: CallPoint, newCallpoint: CallPoint): void;
	}
	class XmppNotificationHandler {
	    protected _xmppHandler: XmppHandler;
	    protected _parser: ParserRegistry;
	    constructor(model: XmppHandler, parser: ParserRegistry);
	    handleNotification(not: JQuery): void;
	    protected handleCallNotification(not: JQuery): void;
	    protected handleCallStartNotification(not: JQuery): void;
	    protected handleCallEndNotification(not: JQuery): void;
	    protected handleCallUpdateNotification(not: JQuery): void;
	    protected handleCallStepResultNotification(not: JQuery): void;
	    protected handleUserNotification(not: JQuery): void;
	    protected handleQueueMemberNotification(not: JQuery): void;
	    protected handleQueueNotification(not: JQuery): void;
	    protected handlePropertiesChanged<T extends CompassObject>(obj: T, elements: JQuery, translateToModel: ((obj: T, p: string, v: string) => void)): void;
	    protected handleUserPropertyUpdate(user: User, propertyName: string, newValue: string): void;
	    protected handleQueuePropertyUpdate(queue: Queue, propertyName: string, newValue: string): void;
	    protected getNotificationTypeUpToLevel(type: string, level: number): string;
	}

}