diff --git a/autobahn/autobahn-tests.ts b/autobahn/autobahn-tests.ts
new file mode 100644
index 000000000000000..ee9c41b3e885d8d
--- /dev/null
+++ b/autobahn/autobahn-tests.ts
@@ -0,0 +1,47 @@
+///
+
+class MyClass {
+ add2Count: number = 0;
+ session: autobahn.Session;
+
+ constructor(session: autobahn.Session) {
+ this.session = session;
+ }
+
+ add2(args: Array): number {
+ this.add2Count++;
+ return args[0] + args[1];
+ }
+
+ onEvent(args: Array): void {
+ console.log("Event:", args[0]);
+ }
+}
+
+function test_client() {
+ var options: autobahn.IConnectionOptions =
+ { url: 'ws://127.0.0.1:8080/ws', realm: 'realm1' };
+
+ var connection = new autobahn.Connection(options);
+
+ connection.onopen = session => {
+ var myInstance = new MyClass(session);
+
+ // 1) subscribe to a topic
+ session.subscribe('com.myapp.hello', myInstance.onEvent);
+
+ // 2) publish an event
+ session.publish('com.myapp.hello', ['Hello, world!']);
+
+ // 3) register a procedure for remoting
+ session.register('com.myapp.add2', myInstance.add2);
+
+ // 4) call a remote procedure
+ session.call('com.myapp.add2', [2, 3]).then(
+ res => {
+ console.log("Result:", res);
+ });
+ };
+
+ connection.open();
+}
\ No newline at end of file
diff --git a/autobahn/autobahn.d.ts b/autobahn/autobahn.d.ts
new file mode 100644
index 000000000000000..d34bcaa9ef12e8d
--- /dev/null
+++ b/autobahn/autobahn.d.ts
@@ -0,0 +1,187 @@
+// Type definitions for AutobahnJS v0.9.6
+// Project: http://autobahn.ws/js/
+// Definitions by: Elad Zelingher
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///
+declare module autobahn {
+
+ export class Session {
+ id: number;
+ realm: string;
+ isOpen: boolean;
+ features: any;
+ caller_disclose_me: boolean;
+ publisher_disclose_me: boolean;
+ subscriptions: ISubscription[][];
+ registrations: IRegistration[];
+
+ constructor(transport: ITransport, defer: DeferFactory, challenge: OnChallengeHandler);
+
+ join(realm: string, authmethods: string[], authid: string): void;
+
+ leave(reason: string, message: string): void;
+
+ call(procedure: string, args?: any[], kwargs?: any, options?: ICallOptions): When.Promise;
+
+ publish(topic: string, args?: any[], kwargs?: any, options?: IPublishOptions): When.Promise;
+
+ subscribe(topic: string, handler: SubscribeHandler, options?: ISubscribeOptions): When.Promise;
+
+ register(procedure: string, endpoint: RegisterEndpoint, options?: IRegisterOptions): When.Promise;
+
+ unsubscribe(subscription: ISubscription): When.Promise;
+
+ unregister(registration: IRegistration): When.Promise;
+
+ prefix(prefix: string, uri: string): void;
+
+ resolve(curie: string): string;
+
+ onjoin: (roleFeatures: any) => void;
+ onleave: (reason: string, details: any) => void;
+ }
+
+ interface IInvocation {
+ caller?: number;
+ progress?: boolean;
+ procedure: string;
+ }
+
+ interface IEvent {
+ publication: number;
+ publisher?: number;
+ topic: string;
+ }
+
+ interface IResult {
+ args: any[];
+ kwargs: any;
+ }
+
+ interface IError {
+ error: string;
+ args: any[];
+ kwargs: any;
+ }
+
+ type SubscribeHandler = (args?: any[], kwargs?: any, details?: IEvent) => void;
+
+ interface ISubscription {
+ topic: string;
+ handler: SubscribeHandler;
+ options: ISubscribeOptions;
+ session: Session;
+ id: number;
+ active: boolean;
+ unsubscribe(): When.Promise;
+ }
+
+ type RegisterEndpoint = (args?: any[], kwargs?: any, details?: IInvocation) => void;
+
+ interface IRegistration {
+ procedure: string;
+ endpoint: RegisterEndpoint;
+ options: IRegisterOptions;
+ session: Session;
+ id: number;
+ active: boolean;
+ unregister(): When.Promise;
+ }
+
+ interface IPublication {
+ id: number;
+ }
+
+ interface ICallOptions {
+ }
+
+ interface IPublishOptions {
+ }
+
+ interface ISubscribeOptions {
+ }
+
+ interface IRegisterOptions {
+ }
+
+ export class Connection {
+ constructor(options?: IConnectionOptions);
+
+ open(): void;
+
+ close(reason: string, message: string): void;
+
+ onopen: (session: Session, details: any) => void;
+ onclose: (reason: string, details: any) => boolean;
+ }
+
+ interface ITransportDefinition {
+ url?: string;
+ protocols?: string[];
+ type: string;
+ }
+
+ type DeferFactory = () => any;
+
+ type OnChallengeHandler = (session: Session, method: string, extra: any) => When.Promise;
+
+ interface IConnectionOptions {
+ use_es6_promises?: boolean;
+ // use explicit deferred factory, e.g. jQuery.Deferred or Q.defer
+ use_deferred?: DeferFactory;
+ transports?: ITransportDefinition[];
+ retry_if_unreachable?: boolean;
+ max_retries?: number;
+ initial_retry_delay?: number;
+ max_retry_delay?: number;
+ retry_delay_growth?: number;
+ retry_delay_jitter?: number;
+ url?: string;
+ protocols?: string[];
+ onchallenge?: (session: Session, method: string, extra: any) => OnChallengeHandler;
+ realm?: string;
+ authmethods?: string[];
+ authid?: string;
+ }
+
+ interface ICloseEventDetails {
+ wasClean: boolean;
+ reason: string;
+ code: number;
+ }
+
+ interface ITransport {
+ onopen: () => void;
+ onmessage: (message: any[]) => void;
+ onclose: (details: ICloseEventDetails) => void;
+
+ send(message: any[]): void;
+ close(errorCode: number, reason?: string): void;
+ }
+
+ interface ITransportFactory {
+ //constructor(options: any);
+ type: string;
+ create() : ITransport;
+ }
+
+ interface ITransports {
+ register(name: string, factory: any): void;
+ isRegistered(name: string): boolean;
+ get(name: string): ITransportFactory;
+ list(): ITransportFactory[];
+ }
+
+ interface ILog {
+ debug(... args : any[]) : void;
+ }
+
+ interface IUtil {
+ assert(condition : boolean, message : string): void;
+ }
+
+ var util: IUtil;
+ var log: ILog;
+ var transports: ITransports;
+}
\ No newline at end of file