Tests for typescript

.jscsrc

@@ -1,4 +1,5 @@
 {
+    "excludeFiles": [".git", "node_modules", "lib/**/*.d.ts", "index.d.ts"],
     "disallowSpacesInNamedFunctionExpression": {
         "beforeOpeningRoundBrace": true
     },

.jshintignore

@@ -1 +1,3 @@
 spec/integration/**
+lib/**/*.d.ts
+index.d.ts

examples/typescript/example.ts

@@ -0,0 +1,132 @@
+import * as _ from 'lodash';
+import twilio = require('../../');
+import {MessageListInstanceCreateOptions} from '../../lib/rest/api/v2010/account/message';
+
+const accountSid: string = process.env.TWILIO_ACCOUNT_SID || '';
+const token: string = process.env.TWILIO_AUTH_TOKEN || '';
+
+const client = twilio(accountSid, token);
+
+let i: number = 0;
+client.calls.each({
+  pageSize: 7,
+  callback: (call, done) => {
+    console.log(call.sid);
+    i++;
+    if (i === 10) {
+      done();
+    }
+  },
+  done: (err: Error) => {
+    console.log('je suis fini');
+    console.log(err);
+  }
+});
+
+client.calls.each({}, call => {
+  console.log(call.sid);
+});
+
+const from = process.env.FROM_NUMBER || '';
+const to = process.env.TO_NUMBER || '';
+
+const msgData: MessageListInstanceCreateOptions = {
+  from,
+  to,
+  body: 'create using callback'
+};
+
+// Send message using callback
+client.messages.create(msgData, (err, result) => {
+  console.log('Created message using callback');
+  console.log(result.sid);
+});
+
+// Send message using promise
+const promise = client.messages.create({
+  from: from,
+  to: to,
+  body: 'create using promises'
+});
+promise.then(message => {
+  console.log('Created message using promises');
+  console.log(message.sid);
+});
+
+// Create sip trunk
+client.trunking.v1.trunks.create(
+  {
+    friendlyName: 'sip trunking'
+  },
+  (err, result) => {
+    console.log('Created trunk with friendly name');
+    console.log(result.sid);
+    console.log(result.friendlyName);
+  }
+);
+
+const promiseTrunk = client.trunking.v1.trunks.create({
+  friendlyName: 'promise trunking'
+});
+promiseTrunk.then(trunk => {
+  console.log('Created trunk with friendly name and promises');
+  console.log(trunk.sid);
+  console.log(trunk.friendlyName);
+});
+
+const trunkSid = 'TK7e37e59861c14bb80dde245cfaad5522';
+
+// Fetch trunk sid using callback
+client.trunking.v1.trunks(trunkSid).fetch((err, result) => {
+  console.log('Fetch trunk using callback');
+  console.log(result.sid);
+});
+
+// Fetch trunk using promise
+const promiseTrunk2 = client.trunking.v1.trunks(trunkSid).fetch();
+promiseTrunk2.then(trunk => {
+  console.log('Fetch trunk using promise');
+  console.log(trunk.sid);
+});
+
+// Update trunk using callback
+client.trunking.v1.trunks(trunkSid).update(
+  {
+    friendlyName: 'callback trunk'
+  },
+  (err, result) => {
+    console.log('Updated using callbacks');
+    console.log(result.sid);
+    console.log(result.friendlyName);
+  }
+);
+
+// Update trunk using promise
+const promiseTrunk3 = client.trunking.v1.trunks(trunkSid).update({
+  friendlyName: 'promise trunk'
+});
+promiseTrunk3.then(trunk => {
+  console.log('Updated trunk with friendly name and promises');
+  console.log(trunk.sid);
+  console.log(trunk.friendlyName);
+});
+
+// List messages using callbacks
+client.messages.list({}, (err, messages) => {
+  console.log('Listing messages using callbacks');
+  _.each(messages, message => {
+    console.log(message.sid);
+  });
+});
+
+// List messages using promises
+const promiseMessage = client.messages.list();
+promiseMessage.then(messages => {
+  console.log('Listing messages using promises');
+  _.each(messages, function(message) {
+    console.log(message.sid);
+  });
+});
+
+const twiml = new twilio.twiml.VoiceResponse();
+twiml.dial({}, '+12345678901');

index.d.ts

@@ -0,0 +1,43 @@
+import * as VoiceResponse from './lib/twiml/VoiceResponse';
+import * as MessagingResponse from './lib/twiml/MessagingResponse';
+import * as FaxResponse from './lib/twiml/FaxResponse';
+import * as webhookTools from './lib/webhooks/webhooks';
+import * as util from './lib/jwt/taskrouter/util';
+
+import TwilioClient = require('./lib/rest/Twilio');
+import AccessToken = require('./lib/jwt/AccessToken');
+import ClientCapability = require('./lib/jwt/ClientCapability');
+import TaskRouterCapability = require('./lib/jwt/taskrouter/TaskRouterCapability');
+
+interface TwimlConstructor<T> {
+  new (): T;
+}
+
+declare function twilio(
+  accountSid?: string,
+  authToken?: string,
+  opts?: TwilioClient.TwilioClientOptions
+): TwilioClient;
+
+declare namespace twilio {
+  export interface TwimlInterface {
+    VoiceResponse: typeof VoiceResponse;
+    FaxResponse: typeof FaxResponse;
+    MessagingResponse: typeof MessagingResponse;
+  }
+  export interface JwtInterface {
+    AccessToken: typeof AccessToken;
+    ClientCapability: typeof ClientCapability;
+    taskrouter: {
+      TaskRouterCapability: typeof TaskRouterCapability;
+      util: typeof util;
+    };
+  }
+  export const jwt: JwtInterface;
+  export const twiml: TwimlInterface;
+  export const validateRequest: typeof webhookTools.validateRequest;
+  export const validateExpressRequest: typeof webhookTools.validateExpressRequest;
+  export const webhook: typeof webhookTools.webhook;
+}
+
+export = twilio;

lib/base/Domain.d.ts

@@ -0,0 +1,23 @@
+import TwilioClient = require('../rest/Twilio');
+
+declare class Domain {
+  constructor(twilio: TwilioClient, baseUrl: string);
+
+  /**
+   * Turn a uri into an absolute url
+   *
+   * @param  uri uri to transform
+   * @return absolute url
+   */
+  absoluteUrl(uri: string): string;
+
+  /**
+   * Make request to this domain
+   *
+   * @param opts request options
+   * @return request promise
+   */
+  request(opts?: TwilioClient.RequestOptions): Promise<any>;
+}
+
+export = Domain;

lib/base/Page.d.ts

@@ -0,0 +1,107 @@
+import Version = require('./Version');
+import Response = require('../http/response');
+
+interface Solution {
+
+}
+
+/**
+ * Base page object to maintain request state.
+ */
+declare class Page<TVersion extends Version, TPayload extends Page.TwilioResponsePayload, TResource, TInstance> {
+  /**
+   * Base page object to maintain request state.
+   *
+   * @param version - A twilio version instance
+   * @param response - The http response
+   * @param solution - path solution
+   */
+  constructor(version: TVersion, response: Response<string>, solution: Solution);
+
+  /**
+   * Get the url of the previous page of records
+   *
+   * @return url of the previous page
+   */
+  getPreviousPageUrl(): string;
+  /**w
+   * Get the url of the next page of records
+   *
+   * @return url of the next page
+   */
+  getNextPageUrl(): string;
+  /**
+   * Load a list of records
+   *
+   * @param  resources json payload of records
+   * @return list of resources
+   */
+  loadInstance(resources: TResource[]): TInstance[];
+  /**
+   * Fetch the next page of records
+   *
+   * @return promise that resolves to next page of results
+   */
+  nextPage(): Promise<Page<TVersion, TPayload, TResource, TInstance>>;
+  /**
+   * Fetch the previous page of records
+   *
+   * @return promise that resolves to previous page of results
+   */
+  previousPage(): Promise<Page<TVersion, TPayload, TResource, TInstance>>;
+  /**
+   * Parse json response from API
+   * @throws If non 200 status code is returned
+   *
+   * @param  response API response
+   * @return json parsed response
+   */
+  processResponse(response: Response<string>): TPayload;
+  /**
+   * Load a page of records
+   * @throws {Error} If records cannot be deserialized
+   *
+   * @param  payload json payload
+   * @return the page of records
+   */
+  loadPage(payload: TPayload): TResource[];
+
+  /**
+   * @constant META_KEYS
+   * @description meta keys returned in a list request
+   */
+  static META_KEYS: [
+    'end',
+    'first_page_uri',
+    'last_page_uri',
+    'next_page_uri',
+    'num_pages',
+    'page',
+    'page_size',
+    'previous_page_uri',
+    'start',
+    'total',
+    'uri'
+  ];
+}
+
+declare namespace Page {
+  export interface TwilioResponsePayload {
+    // DEPRECTATED: end: any;
+    first_page_uri: string;
+    // DEPRECTATED: last_page_uri: string;
+    next_page_uri: string;
+    // DEPRECTATED: num_pages: number;
+    page: number;
+    page_size: number;
+    previous_page_uri: string;
+    // DEPRECTATED: start: number;
+    // DEPRECTATED: total: number;
+    uri: string;
+    meta?: {
+      key?: string;
+    }
+  }
+}
+
+export = Page;

lib/base/RequestClient.d.ts

@@ -0,0 +1,62 @@
+import { HttpMethod } from '../interfaces';
+import Response = require('../http/response');
+
+declare class RequestClient {
+  constructor();
+  /**
+   * Make an HTTP request
+   * @param opts The request options
+   */
+  request<TData>(opts: RequestClient.RequestOptions<TData>): Promise<Response<TData>>;
+}
+
+declare namespace RequestClient {
+  export interface RequestOptions<TData = any, TParams = object> {
+    /**
+     * The HTTP method
+     */
+    method: HttpMethod;
+    /**
+     * The request URI
+     */
+    uri: string;
+    /**
+     * The username used for auth
+     */
+    username?: string;
+    /**
+     * The password used for auth
+     */
+    password?: string;
+    /**
+     * The request headers
+     */
+    headers?: Headers;
+    /**
+     * The object of params added as query string to the request
+     */
+    params?: TParams;
+    /**
+     * The form data that should be submitted
+     */
+    data?: TData;
+    /**
+     * The request timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Should the client follow redirects
+     */
+    allowRedirects?: boolean;
+    /**
+     * Set to true to use the forever-agent
+     */
+    forever?: boolean;
+  }
+
+  export interface Headers {
+    [header: string]: string;
+  }
+}
+
+export = RequestClient;

lib/base/RestException.d.ts

@@ -0,0 +1,9 @@
+declare class RestException extends Error {
+  status: number;
+  message: string;
+  code: number;
+  moreInfo: string;
+  detail: string;
+}
+
+export = RestException;