@cendarsoss/pusher-js 8.4.11

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "module": "es6",
+    "declaration": true,
+    "declarationDir": "types",
+    "target": "ES6",
+    "removeComments": true,
+    "moduleResolution": "node",
+    "baseUrl": "src",
+    "paths": {
+      "runtime": ["runtimes/web/index.ts"],
+      "*": ["*", "runtimes/*"]
+    },
+    "lib": ["ScriptHost", "DOM", "ES5"]
+  },
+  "exclude": ["node_modules"]
+}

package/types/spec/javascripts/helpers/node/mock-dom-dependencies.d.ts

@@ -0,0 +1 @@
+export declare var Dependencies: {};

package/types/spec/javascripts/helpers/pusher_integration_class.d.ts

@@ -0,0 +1,4 @@
+import Pusher from '../../../src/core/pusher';
+export default class PusherIntegration extends Pusher {
+    static Integration: any;
+}

package/types/src/core/auth/auth_transports.d.ts

@@ -0,0 +1,9 @@
+import AbstractRuntime from '../../runtimes/interface';
+import { AuthRequestType, InternalAuthOptions } from './options';
+interface AuthTransport {
+    (context: AbstractRuntime, query: string, authOptions: InternalAuthOptions, authRequestType: AuthRequestType, callback: Function): void;
+}
+interface AuthTransports {
+    [index: string]: AuthTransport;
+}
+export { AuthTransport, AuthTransports };

package/types/src/core/auth/channel_authorizer.d.ts

@@ -0,0 +1,3 @@
+import { InternalAuthOptions, ChannelAuthorizationHandler } from './options';
+declare const ChannelAuthorizer: (authOptions: InternalAuthOptions) => ChannelAuthorizationHandler;
+export default ChannelAuthorizer;

package/types/src/core/auth/deprecated_channel_authorizer.d.ts

@@ -0,0 +1,18 @@
+import Channel from '../channels/channel';
+import { ChannelAuthorizationCallback, ChannelAuthorizationHandler, InternalAuthOptions } from './options';
+export interface DeprecatedChannelAuthorizer {
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+}
+export interface ChannelAuthorizerGenerator {
+    (channel: Channel, options: DeprecatedAuthorizerOptions): DeprecatedChannelAuthorizer;
+}
+export interface DeprecatedAuthOptions {
+    params?: any;
+    headers?: any;
+}
+export interface DeprecatedAuthorizerOptions {
+    authTransport: 'ajax' | 'jsonp';
+    authEndpoint: string;
+    auth?: DeprecatedAuthOptions;
+}
+export declare const ChannelAuthorizerProxy: (pusher: any, authOptions: InternalAuthOptions, channelAuthorizerGenerator: ChannelAuthorizerGenerator) => ChannelAuthorizationHandler;

package/types/src/core/auth/options.d.ts

@@ -0,0 +1,48 @@
+export declare enum AuthRequestType {
+    UserAuthentication = "user-authentication",
+    ChannelAuthorization = "channel-authorization"
+}
+export interface ChannelAuthorizationData {
+    auth: string;
+    channel_data?: string;
+    shared_secret?: string;
+}
+export type ChannelAuthorizationCallback = (error: Error | null, authData: ChannelAuthorizationData | null) => void;
+export interface ChannelAuthorizationRequestParams {
+    socketId: string;
+    channelName: string;
+}
+export interface ChannelAuthorizationHandler {
+    (params: ChannelAuthorizationRequestParams, callback: ChannelAuthorizationCallback): void;
+}
+export interface UserAuthenticationData {
+    auth: string;
+    user_data: string;
+}
+export type UserAuthenticationCallback = (error: Error | null, authData: UserAuthenticationData | null) => void;
+export interface UserAuthenticationRequestParams {
+    socketId: string;
+}
+export interface UserAuthenticationHandler {
+    (params: UserAuthenticationRequestParams, callback: UserAuthenticationCallback): void;
+}
+export type AuthTransportCallback = ChannelAuthorizationCallback | UserAuthenticationCallback;
+export interface AuthOptionsT<AuthHandler> {
+    transport: 'ajax' | 'jsonp';
+    endpoint: string;
+    params?: any;
+    headers?: any;
+    paramsProvider?: () => any;
+    headersProvider?: () => any;
+    customHandler?: AuthHandler;
+}
+export declare type UserAuthenticationOptions = AuthOptionsT<UserAuthenticationHandler>;
+export declare type ChannelAuthorizationOptions = AuthOptionsT<ChannelAuthorizationHandler>;
+export interface InternalAuthOptions {
+    transport: 'ajax' | 'jsonp';
+    endpoint: string;
+    params?: any;
+    headers?: any;
+    paramsProvider?: () => any;
+    headersProvider?: () => any;
+}

package/types/src/core/auth/user_authenticator.d.ts

@@ -0,0 +1,3 @@
+import { InternalAuthOptions, UserAuthenticationHandler } from './options';
+declare const UserAuthenticator: (authOptions: InternalAuthOptions) => UserAuthenticationHandler;
+export default UserAuthenticator;

package/types/src/core/base64.d.ts

@@ -0,0 +1 @@
+export default function encode(s: any): string;

package/types/src/core/channels/channel.d.ts

@@ -0,0 +1,25 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import Pusher from '../pusher';
+import { PusherEvent } from '../connection/protocol/message-types';
+import { ChannelAuthorizationCallback } from '../auth/options';
+import { FilterNode } from './filter';
+export default class Channel extends EventsDispatcher {
+    name: string;
+    pusher: Pusher;
+    subscribed: boolean;
+    subscriptionPending: boolean;
+    subscriptionCancelled: boolean;
+    subscriptionCount: null;
+    tagsFilter: FilterNode | null;
+    constructor(name: string, pusher: Pusher);
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+    trigger(event: string, data: any): boolean;
+    disconnect(): void;
+    handleEvent(event: PusherEvent): void;
+    handleSubscriptionSucceededEvent(event: PusherEvent): void;
+    handleSubscriptionCountEvent(event: PusherEvent): void;
+    subscribe(): void;
+    unsubscribe(): void;
+    cancelSubscription(): void;
+    reinstateSubscription(): void;
+}

package/types/src/core/channels/channel_table.d.ts

@@ -0,0 +1,5 @@
+import Channel from './channel';
+interface ChannelTable {
+    [index: string]: Channel;
+}
+export default ChannelTable;

package/types/src/core/channels/channels.d.ts

@@ -0,0 +1,12 @@
+import Channel from './channel';
+import ChannelTable from './channel_table';
+import Pusher from '../pusher';
+export default class Channels {
+    channels: ChannelTable;
+    constructor();
+    add(name: string, pusher: Pusher): Channel;
+    all(): Channel[];
+    find(name: string): Channel;
+    remove(name: string): Channel;
+    disconnect(): void;
+}

package/types/src/core/channels/encrypted_channel.d.ts

@@ -0,0 +1,15 @@
+import PrivateChannel from './private_channel';
+import Pusher from '../pusher';
+import { PusherEvent } from '../connection/protocol/message-types';
+import { ChannelAuthorizationCallback } from '../auth/options';
+import * as nacl from 'tweetnacl';
+export default class EncryptedChannel extends PrivateChannel {
+    key: Uint8Array;
+    nacl: nacl;
+    constructor(name: string, pusher: Pusher, nacl: nacl);
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+    trigger(event: string, data: any): boolean;
+    handleEvent(event: PusherEvent): void;
+    private handleEncryptedEvent;
+    getDataToEmit(bytes: Uint8Array): string;
+}

package/types/src/core/channels/filter.d.ts

@@ -0,0 +1,33 @@
+export interface FilterNode {
+    op?: string;
+    key?: string;
+    cmp?: string;
+    val?: string;
+    vals?: string[];
+    nodes?: FilterNode[];
+}
+export declare const Filter: {
+    eq: (key: string, val: string) => FilterNode;
+    neq: (key: string, val: string) => FilterNode;
+    in: (key: string, vals: string[]) => FilterNode;
+    nin: (key: string, vals: string[]) => FilterNode;
+    exists: (key: string) => FilterNode;
+    notExists: (key: string) => FilterNode;
+    startsWith: (key: string, val: string) => FilterNode;
+    endsWith: (key: string, val: string) => FilterNode;
+    contains: (key: string, val: string) => FilterNode;
+    gt: (key: string, val: string) => FilterNode;
+    gte: (key: string, val: string) => FilterNode;
+    lt: (key: string, val: string) => FilterNode;
+    lte: (key: string, val: string) => FilterNode;
+    and: (...nodes: FilterNode[]) => FilterNode;
+    or: (...nodes: FilterNode[]) => FilterNode;
+    not: (node: FilterNode) => FilterNode;
+};
+export declare function validateFilter(filter: FilterNode): string | null;
+export declare const FilterExamples: {
+    eventType: (type: string) => FilterNode;
+    eventTypes: (types: string[]) => FilterNode;
+    range: (key: string, min: string, max: string) => FilterNode;
+    importantEvents: (xGThreshold: string) => FilterNode;
+};

package/types/src/core/channels/members.d.ts

@@ -0,0 +1,14 @@
+export default class Members {
+    members: any;
+    count: number;
+    myID: any;
+    me: any;
+    constructor();
+    get(id: string): any;
+    each(callback: Function): void;
+    setMyID(id: string): void;
+    onSubscription(subscriptionData: any): void;
+    addMember(memberData: any): any;
+    removeMember(memberData: any): any;
+    reset(): void;
+}

package/types/src/core/channels/metadata.d.ts

@@ -0,0 +1,4 @@
+interface Metadata {
+    user_id?: string;
+}
+export default Metadata;

package/types/src/core/channels/presence_channel.d.ts

@@ -0,0 +1,13 @@
+import PrivateChannel from './private_channel';
+import Members from './members';
+import Pusher from '../pusher';
+import { PusherEvent } from '../connection/protocol/message-types';
+export default class PresenceChannel extends PrivateChannel {
+    members: Members;
+    constructor(name: string, pusher: Pusher);
+    authorize(socketId: string, callback: Function): void;
+    handleEvent(event: PusherEvent): void;
+    handleInternalEvent(event: PusherEvent): void;
+    handleSubscriptionSucceededEvent(event: PusherEvent): void;
+    disconnect(): void;
+}

package/types/src/core/channels/private_channel.d.ts

@@ -0,0 +1,5 @@
+import Channel from './channel';
+import { ChannelAuthorizationCallback } from '../auth/options';
+export default class PrivateChannel extends Channel {
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+}

package/types/src/core/config.d.ts

@@ -0,0 +1,31 @@
+import { Options } from './options';
+import { ChannelAuthorizationHandler, UserAuthenticationHandler } from './auth/options';
+import * as nacl from 'tweetnacl';
+export type AuthTransport = 'ajax' | 'jsonp';
+export type Transport = 'ws' | 'wss' | 'xhr_streaming' | 'xhr_polling' | 'sockjs';
+export interface Config {
+    activityTimeout: number;
+    enableStats: boolean;
+    httpHost: string;
+    httpPath: string;
+    httpPort: number;
+    httpsPort: number;
+    pongTimeout: number;
+    statsHost: string;
+    unavailableTimeout: number;
+    useTLS: boolean;
+    wsHost: string;
+    wsPath: string;
+    wsPort: number;
+    wssPort: number;
+    userAuthenticator: UserAuthenticationHandler;
+    channelAuthorizer: ChannelAuthorizationHandler;
+    forceTLS?: boolean;
+    cluster?: string;
+    disabledTransports?: Transport[];
+    enabledTransports?: Transport[];
+    ignoreNullOrigin?: boolean;
+    nacl?: nacl;
+    timelineParams?: any;
+}
+export declare function getConfig(opts: Options, pusher: any): Config;

package/types/src/core/connection/callbacks.d.ts

@@ -0,0 +1,18 @@
+import HandshakePayload from './handshake/handshake_payload';
+import Action from './protocol/action';
+export interface ErrorCallbacks {
+    tls_only: (result: Action | HandshakePayload) => void;
+    refused: (result: Action | HandshakePayload) => void;
+    backoff: (result: Action | HandshakePayload) => void;
+    retry: (result: Action | HandshakePayload) => void;
+}
+export interface HandshakeCallbacks {
+    connected: (handshake: HandshakePayload) => void;
+}
+export interface ConnectionCallbacks {
+    message: (message: any) => void;
+    ping: () => void;
+    activity: () => void;
+    error: (error: any) => void;
+    closed: () => void;
+}

package/types/src/core/connection/connection.d.ts

@@ -0,0 +1,16 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import TransportConnection from '../transports/transport_connection';
+import Socket from '../socket';
+export default class Connection extends EventsDispatcher implements Socket {
+    id: string;
+    transport: TransportConnection;
+    activityTimeout: number;
+    constructor(id: string, transport: TransportConnection);
+    handlesActivityChecks(): boolean;
+    send(data: any): boolean;
+    send_event(name: string, data: any, channel?: string): boolean;
+    ping(): void;
+    close(): void;
+    private bindListeners;
+    private handleCloseEvent;
+}

package/types/src/core/connection/connection_manager.d.ts

@@ -0,0 +1,50 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import { OneOffTimer as Timer } from '../utils/timers';
+import Connection from './connection';
+import Strategy from '../strategies/strategy';
+import StrategyRunner from '../strategies/strategy_runner';
+import Timeline from '../timeline/timeline';
+import ConnectionManagerOptions from './connection_manager_options';
+import { ErrorCallbacks, HandshakeCallbacks, ConnectionCallbacks } from './callbacks';
+export default class ConnectionManager extends EventsDispatcher {
+    key: string;
+    options: ConnectionManagerOptions;
+    state: string;
+    connection: Connection;
+    usingTLS: boolean;
+    timeline: Timeline;
+    socket_id: string;
+    unavailableTimer: Timer;
+    activityTimer: Timer;
+    retryTimer: Timer;
+    activityTimeout: number;
+    strategy: Strategy;
+    runner: StrategyRunner;
+    errorCallbacks: ErrorCallbacks;
+    handshakeCallbacks: HandshakeCallbacks;
+    connectionCallbacks: ConnectionCallbacks;
+    constructor(key: string, options: ConnectionManagerOptions);
+    connect(): void;
+    send(data: any): boolean;
+    send_event(name: string, data: any, channel?: string): boolean;
+    disconnect(): void;
+    isUsingTLS(): boolean;
+    private startConnecting;
+    private abortConnecting;
+    private disconnectInternally;
+    private updateStrategy;
+    private retryIn;
+    private clearRetryTimer;
+    private setUnavailableTimer;
+    private clearUnavailableTimer;
+    private sendActivityCheck;
+    private resetActivityCheck;
+    private stopActivityCheck;
+    private buildConnectionCallbacks;
+    private buildHandshakeCallbacks;
+    private buildErrorCallbacks;
+    private setConnection;
+    private abandonConnection;
+    private updateState;
+    private shouldRetry;
+}

package/types/src/core/connection/connection_manager_options.d.ts

@@ -0,0 +1,11 @@
+import Timeline from '../timeline/timeline';
+import Strategy from '../strategies/strategy';
+interface ConnectionManagerOptions {
+    timeline: Timeline;
+    getStrategy: (StrategyOptions: any) => Strategy;
+    unavailableTimeout: number;
+    pongTimeout: number;
+    activityTimeout: number;
+    useTLS: boolean;
+}
+export default ConnectionManagerOptions;

package/types/src/core/connection/handshake/handshake_payload.d.ts

@@ -0,0 +1,8 @@
+import TransportConnection from '../../transports/transport_connection';
+import Action from '../protocol/action';
+import Connection from '../connection';
+interface HandshakePayload extends Action {
+    transport: TransportConnection;
+    connection?: Connection;
+}
+export default HandshakePayload;

package/types/src/core/connection/handshake/index.d.ts

@@ -0,0 +1,12 @@
+import TransportConnection from '../../transports/transport_connection';
+export default class Handshake {
+    transport: TransportConnection;
+    callback: (HandshakePayload: any) => void;
+    onMessage: Function;
+    onClosed: Function;
+    constructor(transport: TransportConnection, callback: (HandshakePayload: any) => void);
+    close(): void;
+    private bindListeners;
+    private unbindListeners;
+    private finish;
+}

package/types/src/core/connection/protocol/action.d.ts

@@ -0,0 +1,7 @@
+interface Action {
+    action: string;
+    id?: string;
+    activityTimeout?: number;
+    error?: any;
+}
+export default Action;

package/types/src/core/connection/protocol/message-types.d.ts

@@ -0,0 +1,10 @@
+interface PusherEvent {
+    event: string;
+    channel?: string;
+    data?: any;
+    user_id?: string;
+    rawMessage?: string;
+    sequence?: number;
+    conflation_key?: string;
+}
+export { PusherEvent };

package/types/src/core/connection/protocol/protocol.d.ts

@@ -0,0 +1,10 @@
+import Action from './action';
+import { PusherEvent } from './message-types';
+declare const Protocol: {
+    decodeMessage: (messageEvent: MessageEvent) => PusherEvent;
+    encodeMessage: (event: PusherEvent) => string;
+    processHandshake: (messageEvent: MessageEvent) => Action;
+    getCloseAction: (closeEvent: any) => string;
+    getCloseError: (closeEvent: any) => any;
+};
+export default Protocol;

package/types/src/core/defaults.d.ts

@@ -0,0 +1,26 @@
+import { ChannelAuthorizationOptions, UserAuthenticationOptions } from './auth/options';
+import { AuthTransport } from './config';
+export interface DefaultConfig {
+    VERSION: string;
+    PROTOCOL: number;
+    wsPort: number;
+    wssPort: number;
+    wsPath: string;
+    httpHost: string;
+    httpPort: number;
+    httpsPort: number;
+    httpPath: string;
+    stats_host: string;
+    authEndpoint: string;
+    authTransport: AuthTransport;
+    activityTimeout: number;
+    pongTimeout: number;
+    unavailableTimeout: number;
+    userAuthentication: UserAuthenticationOptions;
+    channelAuthorization: ChannelAuthorizationOptions;
+    cdn_http?: string;
+    cdn_https?: string;
+    dependency_suffix?: string;
+}
+declare var Defaults: DefaultConfig;
+export default Defaults;

package/types/src/core/delta/channel_state.d.ts

@@ -0,0 +1,23 @@
+import { CachedMessage, CacheSyncData, ChannelDeltaStats } from './types';
+export default class ChannelState {
+    channelName: string;
+    conflationKey: string | null;
+    maxMessagesPerKey: number;
+    conflationCaches: Map<string, CachedMessage[]>;
+    baseMessage: string | null;
+    baseSequence: number | null;
+    lastSequence: number | null;
+    deltaCount: number;
+    fullMessageCount: number;
+    constructor(channelName: string);
+    initializeFromCacheSync(data: CacheSyncData): void;
+    setBase(message: string, sequence: number): void;
+    getBaseMessage(conflationKeyValue?: string, baseIndex?: number): string | null;
+    updateConflationCache(conflationKeyValue: string | undefined, message: string, sequence: number): void;
+    hasBase(): boolean;
+    isValidSequence(sequence: number): boolean;
+    updateSequence(sequence: number): void;
+    recordDelta(): void;
+    recordFullMessage(): void;
+    getStats(): ChannelDeltaStats;
+}

package/types/src/core/delta/decoders.d.ts

@@ -0,0 +1,12 @@
+declare function base64ToBytes(base64: string): Uint8Array;
+declare function bytesToString(bytes: Uint8Array | number[]): string;
+declare function stringToBytes(str: string): Uint8Array;
+export declare class FossilDeltaDecoder {
+    static isAvailable(): boolean;
+    static apply(base: string | Uint8Array, delta: string | Uint8Array): string;
+}
+export declare class Xdelta3Decoder {
+    static isAvailable(): boolean;
+    static apply(base: string | Uint8Array, delta: string | Uint8Array): string;
+}
+export { base64ToBytes, bytesToString, stringToBytes };

package/types/src/core/delta/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DeltaCompressionManager } from './manager';
+export { default as ChannelState } from './channel_state';
+export { FossilDeltaDecoder, Xdelta3Decoder } from './decoders';
+export * from './types';

package/types/src/core/delta/manager.d.ts

@@ -0,0 +1,27 @@
+import { PusherEvent } from '../connection/protocol/message-types';
+import { DeltaOptions, DeltaStats, DeltaMessage, DeltaAlgorithm, CacheSyncData } from './types';
+export default class DeltaCompressionManager {
+    private options;
+    private enabled;
+    private channelStates;
+    private stats;
+    private availableAlgorithms;
+    private sendEventCallback;
+    constructor(options: DeltaOptions, sendEventCallback: (event: string, data: any) => boolean);
+    private detectAvailableAlgorithms;
+    enable(): void;
+    disable(): void;
+    handleEnabled(data: any): void;
+    handleCacheSync(channel: string, data: CacheSyncData): void;
+    handleDeltaMessage(channel: string, deltaData: DeltaMessage): PusherEvent | null;
+    handleFullMessage(channel: string, rawMessage: string, sequence?: number, conflationKey?: string): void;
+    private requestResync;
+    private updateStats;
+    getStats(): DeltaStats;
+    resetStats(): void;
+    clearChannelState(channel?: string): void;
+    isEnabled(): boolean;
+    getAvailableAlgorithms(): DeltaAlgorithm[];
+    private log;
+    private error;
+}

package/types/src/core/delta/types.d.ts

@@ -0,0 +1,50 @@
+export type DeltaAlgorithm = 'fossil' | 'xdelta3';
+export interface DeltaOptions {
+    enabled?: boolean;
+    algorithms?: DeltaAlgorithm[];
+    debug?: boolean;
+    onStats?: (stats: DeltaStats) => void;
+    onError?: (error: any) => void;
+}
+export interface DeltaStats {
+    totalMessages: number;
+    deltaMessages: number;
+    fullMessages: number;
+    totalBytesWithoutCompression: number;
+    totalBytesWithCompression: number;
+    bandwidthSaved: number;
+    bandwidthSavedPercent: number;
+    errors: number;
+    channelCount: number;
+    channels: ChannelDeltaStats[];
+}
+export interface ChannelDeltaStats {
+    channelName: string;
+    conflationKey: string | null;
+    conflationGroupCount: number;
+    deltaCount: number;
+    fullMessageCount: number;
+    totalMessages: number;
+}
+export interface DeltaMessage {
+    event: string;
+    delta: string;
+    seq: number;
+    algorithm?: DeltaAlgorithm;
+    conflation_key?: string;
+    base_index?: number;
+}
+export interface CacheSyncData {
+    conflation_key?: string;
+    max_messages_per_key?: number;
+    states?: {
+        [key: string]: Array<{
+            content: string;
+            seq: number;
+        }>;
+    };
+}
+export interface CachedMessage {
+    content: string;
+    sequence: number;
+}

package/types/src/core/errors.d.ts

@@ -0,0 +1,28 @@
+export declare class BadEventName extends Error {
+    constructor(msg?: string);
+}
+export declare class BadChannelName extends Error {
+    constructor(msg?: string);
+}
+export declare class RequestTimedOut extends Error {
+    constructor(msg?: string);
+}
+export declare class TransportPriorityTooLow extends Error {
+    constructor(msg?: string);
+}
+export declare class TransportClosed extends Error {
+    constructor(msg?: string);
+}
+export declare class UnsupportedFeature extends Error {
+    constructor(msg?: string);
+}
+export declare class UnsupportedTransport extends Error {
+    constructor(msg?: string);
+}
+export declare class UnsupportedStrategy extends Error {
+    constructor(msg?: string);
+}
+export declare class HTTPAuthError extends Error {
+    status: number;
+    constructor(status: number, msg?: string);
+}

package/types/src/core/events/callback.d.ts

@@ -0,0 +1,5 @@
+interface Callback {
+    fn: Function;
+    context: any;
+}
+export default Callback;

package/types/src/core/events/callback_registry.d.ts

@@ -0,0 +1,11 @@
+import Callback from './callback';
+import CallbackTable from './callback_table';
+export default class CallbackRegistry {
+    _callbacks: CallbackTable;
+    constructor();
+    get(name: string): Callback[];
+    add(name: string, callback: Function, context: any): void;
+    remove(name?: string, callback?: Function, context?: any): void;
+    private removeCallback;
+    private removeAllCallbacks;
+}

package/types/src/core/events/callback_table.d.ts

@@ -0,0 +1,5 @@
+import Callback from './callback';
+interface CallbackTable {
+    [index: string]: Callback[];
+}
+export default CallbackTable;