sumomo 0.5.2 → 0.6.0

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/s3/presigned_post.d.ts

@@ -0,0 +1,61 @@
+export class PresignedPost {
+    /**
+     * The URL that should be used as the action of the form.
+     */
+    url: string;
+
+    /**
+     * The fields that must be included as hidden inputs on the form.
+     */
+    fields: PresignedPost.Fields;
+}
+
+export namespace PresignedPost {
+    export interface Params {
+        /**
+         * The S3 bucket to which the form should upload an attached file.
+         */
+        Bucket?: string;
+
+        /**
+         * An array of conditions that must be met for the form upload to be
+         * accepted by S3.
+         */
+        Conditions?: Array<{[key: string]: any}|[string, any, any]>;
+
+        /**
+         * The number of seconds for which the POST form's signed policy should be
+         * valid. Defaults to 3600 (one hour).
+         */
+        Expires?: number;
+
+        /**
+         * A hash of form fields to include in the presigned POST form. All fields
+         * (except 'key') will be included as exact match conditions in the
+         * presigned policy.
+         */
+        Fields?: {[key: string]: any};
+    }
+
+    export interface Fields {
+        /**
+         * A base64-encoded policy detailing what constitutes an acceptable POST
+         * upload. Composed of the conditions and expiration provided to
+         * s3.createPresignedPost
+         */
+        Policy: string;
+
+        /**
+         * A hex-encoded HMAC of the POST policy, signed with the credentials
+         * provided to the S3 client.
+         */
+            'X-Amz-Signature': string;
+
+        /**
+         * Additional keys that must be included in the form to be submitted. This
+         * will include signature metadata as well as any fields provided to
+         * s3.createPresignedPost
+         */
+        [key: string]: string;
+    }
+}

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/sequential_executor.js

@@ -0,0 +1,231 @@
+var AWS = require('./core');
+
+/**
+ * @api private
+ * @!method on(eventName, callback)
+ *   Registers an event listener callback for the event given by `eventName`.
+ *   Parameters passed to the callback function depend on the individual event
+ *   being triggered. See the event documentation for those parameters.
+ *
+ *   @param eventName [String] the event name to register the listener for
+ *   @param callback [Function] the listener callback function
+ *   @return [AWS.SequentialExecutor] the same object for chaining
+ */
+AWS.SequentialExecutor = AWS.util.inherit({
+
+  constructor: function SequentialExecutor() {
+    this._events = {};
+  },
+
+  /**
+   * @api private
+   */
+  listeners: function listeners(eventName) {
+    return this._events[eventName] ? this._events[eventName].slice(0) : [];
+  },
+
+  on: function on(eventName, listener) {
+    if (this._events[eventName]) {
+      this._events[eventName].push(listener);
+    } else {
+      this._events[eventName] = [listener];
+    }
+    return this;
+  },
+
+  /**
+   * @api private
+   */
+  onAsync: function onAsync(eventName, listener) {
+    listener._isAsync = true;
+    return this.on(eventName, listener);
+  },
+
+  removeListener: function removeListener(eventName, listener) {
+    var listeners = this._events[eventName];
+    if (listeners) {
+      var length = listeners.length;
+      var position = -1;
+      for (var i = 0; i < length; ++i) {
+        if (listeners[i] === listener) {
+          position = i;
+        }
+      }
+      if (position > -1) {
+        listeners.splice(position, 1);
+      }
+    }
+    return this;
+  },
+
+  removeAllListeners: function removeAllListeners(eventName) {
+    if (eventName) {
+      delete this._events[eventName];
+    } else {
+      this._events = {};
+    }
+    return this;
+  },
+
+  /**
+   * @api private
+   */
+  emit: function emit(eventName, eventArgs, doneCallback) {
+    if (!doneCallback) doneCallback = function() { };
+    var listeners = this.listeners(eventName);
+    var count = listeners.length;
+    this.callListeners(listeners, eventArgs, doneCallback);
+    return count > 0;
+  },
+
+  /**
+   * @api private
+   */
+  callListeners: function callListeners(listeners, args, doneCallback, prevError) {
+    var self = this;
+    var error = prevError || null;
+
+    function callNextListener(err) {
+      if (err) {
+        error = AWS.util.error(error || new Error(), err);
+        if (self._haltHandlersOnError) {
+          return doneCallback.call(self, error);
+        }
+      }
+      self.callListeners(listeners, args, doneCallback, error);
+    }
+
+    while (listeners.length > 0) {
+      var listener = listeners.shift();
+      if (listener._isAsync) { // asynchronous listener
+        listener.apply(self, args.concat([callNextListener]));
+        return; // stop here, callNextListener will continue
+      } else { // synchronous listener
+        try {
+          listener.apply(self, args);
+        } catch (err) {
+          error = AWS.util.error(error || new Error(), err);
+        }
+        if (error && self._haltHandlersOnError) {
+          doneCallback.call(self, error);
+          return;
+        }
+      }
+    }
+    doneCallback.call(self, error);
+  },
+
+  /**
+   * Adds or copies a set of listeners from another list of
+   * listeners or SequentialExecutor object.
+   *
+   * @param listeners [map<String,Array<Function>>, AWS.SequentialExecutor]
+   *   a list of events and callbacks, or an event emitter object
+   *   containing listeners to add to this emitter object.
+   * @return [AWS.SequentialExecutor] the emitter object, for chaining.
+   * @example Adding listeners from a map of listeners
+   *   emitter.addListeners({
+   *     event1: [function() { ... }, function() { ... }],
+   *     event2: [function() { ... }]
+   *   });
+   *   emitter.emit('event1'); // emitter has event1
+   *   emitter.emit('event2'); // emitter has event2
+   * @example Adding listeners from another emitter object
+   *   var emitter1 = new AWS.SequentialExecutor();
+   *   emitter1.on('event1', function() { ... });
+   *   emitter1.on('event2', function() { ... });
+   *   var emitter2 = new AWS.SequentialExecutor();
+   *   emitter2.addListeners(emitter1);
+   *   emitter2.emit('event1'); // emitter2 has event1
+   *   emitter2.emit('event2'); // emitter2 has event2
+   */
+  addListeners: function addListeners(listeners) {
+    var self = this;
+
+    // extract listeners if parameter is an SequentialExecutor object
+    if (listeners._events) listeners = listeners._events;
+
+    AWS.util.each(listeners, function(event, callbacks) {
+      if (typeof callbacks === 'function') callbacks = [callbacks];
+      AWS.util.arrayEach(callbacks, function(callback) {
+        self.on(event, callback);
+      });
+    });
+
+    return self;
+  },
+
+  /**
+   * Registers an event with {on} and saves the callback handle function
+   * as a property on the emitter object using a given `name`.
+   *
+   * @param name [String] the property name to set on this object containing
+   *   the callback function handle so that the listener can be removed in
+   *   the future.
+   * @param (see on)
+   * @return (see on)
+   * @example Adding a named listener DATA_CALLBACK
+   *   var listener = function() { doSomething(); };
+   *   emitter.addNamedListener('DATA_CALLBACK', 'data', listener);
+   *
+   *   // the following prints: true
+   *   console.log(emitter.DATA_CALLBACK == listener);
+   */
+  addNamedListener: function addNamedListener(name, eventName, callback) {
+    this[name] = callback;
+    this.addListener(eventName, callback);
+    return this;
+  },
+
+  /**
+   * @api private
+   */
+  addNamedAsyncListener: function addNamedAsyncListener(name, eventName, callback) {
+    callback._isAsync = true;
+    return this.addNamedListener(name, eventName, callback);
+  },
+
+  /**
+   * Helper method to add a set of named listeners using
+   * {addNamedListener}. The callback contains a parameter
+   * with a handle to the `addNamedListener` method.
+   *
+   * @callback callback function(add)
+   *   The callback function is called immediately in order to provide
+   *   the `add` function to the block. This simplifies the addition of
+   *   a large group of named listeners.
+   *   @param add [Function] the {addNamedListener} function to call
+   *     when registering listeners.
+   * @example Adding a set of named listeners
+   *   emitter.addNamedListeners(function(add) {
+   *     add('DATA_CALLBACK', 'data', function() { ... });
+   *     add('OTHER', 'otherEvent', function() { ... });
+   *     add('LAST', 'lastEvent', function() { ... });
+   *   });
+   *
+   *   // these properties are now set:
+   *   emitter.DATA_CALLBACK;
+   *   emitter.OTHER;
+   *   emitter.LAST;
+   */
+  addNamedListeners: function addNamedListeners(callback) {
+    var self = this;
+    callback(
+      function() {
+        self.addNamedListener.apply(self, arguments);
+      },
+      function() {
+        self.addNamedAsyncListener.apply(self, arguments);
+      }
+    );
+    return this;
+  }
+});
+
+/**
+ * {on} is the prefered method.
+ * @api private
+ */
+AWS.SequentialExecutor.prototype.addListener = AWS.SequentialExecutor.prototype.on;
+
+module.exports = AWS.SequentialExecutor;

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/service.d.ts

@@ -0,0 +1,83 @@
+import {Request} from './request';
+import {AWSError} from './error';
+import {ConfigurationOptions, ConfigBase} from './config';
+import {Endpoint} from './endpoint';
+
+interface WaiterConfiguration {
+    /**
+     * The number of seconds to wait between requests
+     */
+    delay?: number;
+
+    /**
+     * The maximum number of requests to send while waiting
+     */
+    maxAttempts?: number;
+}
+
+export class Service {
+    /**
+     * Creates a new service object with a configuration object.
+     */
+    constructor(config?: ServiceConfigurationOptions);
+
+    /**
+     * Defines a new Service class using a service identifier and list of versions including an optional set of features (functions) to apply to the class prototype.
+     * 
+     * @param {string} serviceIdentifier - the identifier for the service.
+     * @param {string[]} versions - a list of versions that work with this service.
+     * @param {Object} features - an object to attach to the prototype.
+     */
+    defineService(serviceIdentifier: string, versions: string[], features?: any): typeof Service;
+    /**
+     * Calls an operation on a service with the given input parameters.
+     * 
+     * @param {string} operation - the name of the operation to call on the service.
+     * @param {map} params - a map of input options for the operation. 
+     */
+    makeRequest(operation: string, params?: {[key: string]: any}, callback?: (err: AWSError, data: any) => void): Request<any, AWSError>;
+    /**
+     * Calls an operation on a service with the given input parameters, without any authentication data.
+     * 
+     * @param {string} operation - the name of the operation to call on the service.
+     * @param {map} params - a map of input options for the operation. 
+     */
+    makeUnauthenticatedRequest(operation: string, params?: {[key: string]: any}, callback?: (err: AWSError, data: any) => void): Request<any, AWSError>;
+    /**
+     * Override this method to setup any custom request listeners for each new request to the service.
+     */
+    setupRequestListeners(): void;
+    /**
+     * Waits for a given state.
+     */
+    waitFor(state: string, params?: {[key: string]: any, $waiter?: WaiterConfiguration}, callback?: (err: AWSError, data: any) => void): Request<any, AWSError>;
+    waitFor(state: string, callback?: (err: AWSError, data: any) => void): Request<any, AWSError>;
+
+    /**
+     * The list of API versions supported by this service.
+     */
+    apiVersions: string[];
+
+    config: ConfigBase & ServiceConfigurationOptions;
+
+    /**
+     * An Endpoint object representing the endpoint URL for service requests.
+     */
+    endpoint: Endpoint;
+}
+
+export interface ServiceConfigurationOptions extends ConfigurationOptions {
+    /**
+     * The endpoint URI to send requests to. The default endpoint is built from the configured region. 
+     * The endpoint should be a string like 'https://{service}.{region}.amazonaws.com'.
+     */
+    endpoint?: string;
+    /**
+     * An optional map of parameters to bind to every request sent by this service object. 
+     * For more information on bound parameters, see "Working with Services" in the Getting Started Guide.
+     */
+    params?: {
+        [key: string]: any;
+    }
+}
+

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/service.js

@@ -0,0 +1,575 @@
+var AWS = require('./core');
+var Api = require('./model/api');
+var regionConfig = require('./region_config');
+var inherit = AWS.util.inherit;
+var clientCount = 0;
+
+/**
+ * The service class representing an AWS service.
+ *
+ * @abstract
+ *
+ * @!attribute apiVersions
+ *   @return [Array<String>] the list of API versions supported by this service.
+ *   @readonly
+ */
+AWS.Service = inherit({
+  /**
+   * Create a new service object with a configuration object
+   *
+   * @param config [map] a map of configuration options
+   */
+  constructor: function Service(config) {
+    if (!this.loadServiceClass) {
+      throw AWS.util.error(new Error(),
+        'Service must be constructed with `new\' operator');
+    }
+    var ServiceClass = this.loadServiceClass(config || {});
+    if (ServiceClass) {
+      var originalConfig = AWS.util.copy(config);
+      var svc = new ServiceClass(config);
+      Object.defineProperty(svc, '_originalConfig', {
+        get: function() { return originalConfig; },
+        enumerable: false,
+        configurable: true
+      });
+      svc._clientId = ++clientCount;
+      return svc;
+    }
+    this.initialize(config);
+  },
+
+  /**
+   * @api private
+   */
+  initialize: function initialize(config) {
+    var svcConfig = AWS.config[this.serviceIdentifier];
+
+    this.config = new AWS.Config(AWS.config);
+    if (svcConfig) this.config.update(svcConfig, true);
+    if (config) this.config.update(config, true);
+
+    this.validateService();
+    if (!this.config.endpoint) regionConfig(this);
+
+    this.config.endpoint = this.endpointFromTemplate(this.config.endpoint);
+    this.setEndpoint(this.config.endpoint);
+  },
+
+  /**
+   * @api private
+   */
+  validateService: function validateService() {
+  },
+
+  /**
+   * @api private
+   */
+  loadServiceClass: function loadServiceClass(serviceConfig) {
+    var config = serviceConfig;
+    if (!AWS.util.isEmpty(this.api)) {
+      return null;
+    } else if (config.apiConfig) {
+      return AWS.Service.defineServiceApi(this.constructor, config.apiConfig);
+    } else if (!this.constructor.services) {
+      return null;
+    } else {
+      config = new AWS.Config(AWS.config);
+      config.update(serviceConfig, true);
+      var version = config.apiVersions[this.constructor.serviceIdentifier];
+      version = version || config.apiVersion;
+      return this.getLatestServiceClass(version);
+    }
+  },
+
+  /**
+   * @api private
+   */
+  getLatestServiceClass: function getLatestServiceClass(version) {
+    version = this.getLatestServiceVersion(version);
+    if (this.constructor.services[version] === null) {
+      AWS.Service.defineServiceApi(this.constructor, version);
+    }
+
+    return this.constructor.services[version];
+  },
+
+  /**
+   * @api private
+   */
+  getLatestServiceVersion: function getLatestServiceVersion(version) {
+    if (!this.constructor.services || this.constructor.services.length === 0) {
+      throw new Error('No services defined on ' +
+                      this.constructor.serviceIdentifier);
+    }
+
+    if (!version) {
+      version = 'latest';
+    } else if (AWS.util.isType(version, Date)) {
+      version = AWS.util.date.iso8601(version).split('T')[0];
+    }
+
+    if (Object.hasOwnProperty(this.constructor.services, version)) {
+      return version;
+    }
+
+    var keys = Object.keys(this.constructor.services).sort();
+    var selectedVersion = null;
+    for (var i = keys.length - 1; i >= 0; i--) {
+      // versions that end in "*" are not available on disk and can be
+      // skipped, so do not choose these as selectedVersions
+      if (keys[i][keys[i].length - 1] !== '*') {
+        selectedVersion = keys[i];
+      }
+      if (keys[i].substr(0, 10) <= version) {
+        return selectedVersion;
+      }
+    }
+
+    throw new Error('Could not find ' + this.constructor.serviceIdentifier +
+                    ' API to satisfy version constraint `' + version + '\'');
+  },
+
+  /**
+   * @api private
+   */
+  api: {},
+
+  /**
+   * @api private
+   */
+  defaultRetryCount: 3,
+
+  /**
+   * @api private
+   */
+  customizeRequests: function customizeRequests(callback) {
+    if (!callback) {
+      this.customRequestHandler = null;
+    } else if (typeof callback === 'function') {
+      this.customRequestHandler = callback;
+    } else {
+      throw new Error('Invalid callback type \'' + typeof callback + '\' provided in customizeRequests');
+    }
+  },
+
+  /**
+   * Calls an operation on a service with the given input parameters.
+   *
+   * @param operation [String] the name of the operation to call on the service.
+   * @param params [map] a map of input options for the operation
+   * @callback callback function(err, data)
+   *   If a callback is supplied, it is called when a response is returned
+   *   from the service.
+   *   @param err [Error] the error object returned from the request.
+   *     Set to `null` if the request is successful.
+   *   @param data [Object] the de-serialized data returned from
+   *     the request. Set to `null` if a request error occurs.
+   */
+  makeRequest: function makeRequest(operation, params, callback) {
+    if (typeof params === 'function') {
+      callback = params;
+      params = null;
+    }
+
+    params = params || {};
+    if (this.config.params) { // copy only toplevel bound params
+      var rules = this.api.operations[operation];
+      if (rules) {
+        params = AWS.util.copy(params);
+        AWS.util.each(this.config.params, function(key, value) {
+          if (rules.input.members[key]) {
+            if (params[key] === undefined || params[key] === null) {
+              params[key] = value;
+            }
+          }
+        });
+      }
+    }
+
+    var request = new AWS.Request(this, operation, params);
+    this.addAllRequestListeners(request);
+
+    if (callback) request.send(callback);
+    return request;
+  },
+
+  /**
+   * Calls an operation on a service with the given input parameters, without
+   * any authentication data. This method is useful for "public" API operations.
+   *
+   * @param operation [String] the name of the operation to call on the service.
+   * @param params [map] a map of input options for the operation
+   * @callback callback function(err, data)
+   *   If a callback is supplied, it is called when a response is returned
+   *   from the service.
+   *   @param err [Error] the error object returned from the request.
+   *     Set to `null` if the request is successful.
+   *   @param data [Object] the de-serialized data returned from
+   *     the request. Set to `null` if a request error occurs.
+   */
+  makeUnauthenticatedRequest: function makeUnauthenticatedRequest(operation, params, callback) {
+    if (typeof params === 'function') {
+      callback = params;
+      params = {};
+    }
+
+    var request = this.makeRequest(operation, params).toUnauthenticated();
+    return callback ? request.send(callback) : request;
+  },
+
+  /**
+   * Waits for a given state
+   *
+   * @param state [String] the state on the service to wait for
+   * @param params [map] a map of parameters to pass with each request
+   * @option params $waiter [map] a map of configuration options for the waiter
+   * @option params $waiter.delay [Number] The number of seconds to wait between
+   *                                       requests
+   * @option params $waiter.maxAttempts [Number] The maximum number of requests
+   *                                             to send while waiting
+   * @callback callback function(err, data)
+   *   If a callback is supplied, it is called when a response is returned
+   *   from the service.
+   *   @param err [Error] the error object returned from the request.
+   *     Set to `null` if the request is successful.
+   *   @param data [Object] the de-serialized data returned from
+   *     the request. Set to `null` if a request error occurs.
+   */
+  waitFor: function waitFor(state, params, callback) {
+    var waiter = new AWS.ResourceWaiter(this, state);
+    return waiter.wait(params, callback);
+  },
+
+  /**
+   * @api private
+   */
+  addAllRequestListeners: function addAllRequestListeners(request) {
+    var list = [AWS.events, AWS.EventListeners.Core, this.serviceInterface(),
+                AWS.EventListeners.CorePost];
+    for (var i = 0; i < list.length; i++) {
+      if (list[i]) request.addListeners(list[i]);
+    }
+
+    // disable parameter validation
+    if (!this.config.paramValidation) {
+      request.removeListener('validate',
+        AWS.EventListeners.Core.VALIDATE_PARAMETERS);
+    }
+
+    if (this.config.logger) { // add logging events
+      request.addListeners(AWS.EventListeners.Logger);
+    }
+
+    this.setupRequestListeners(request);
+    // call prototype's customRequestHandler
+    if (typeof this.constructor.prototype.customRequestHandler === 'function') {
+      this.constructor.prototype.customRequestHandler(request);
+    }
+    // call instance's customRequestHandler
+    if (Object.prototype.hasOwnProperty.call(this, 'customRequestHandler') && typeof this.customRequestHandler === 'function') {
+      this.customRequestHandler(request);
+    }
+  },
+
+  /**
+   * Override this method to setup any custom request listeners for each
+   * new request to the service.
+   *
+   * @abstract
+   */
+  setupRequestListeners: function setupRequestListeners() {
+  },
+
+  /**
+   * Gets the signer class for a given request
+   * @api private
+   */
+  getSignerClass: function getSignerClass(request) {
+    var version;
+    // get operation authtype if present
+    var operation = null;
+    var authtype = '';
+    if (request) {
+      var operations = request.service.api.operations || {};
+      operation = operations[request.operation] || null;
+      authtype = operation ? operation.authtype : '';
+    }
+    if (this.config.signatureVersion) {
+      version = this.config.signatureVersion;
+    } else if (authtype === 'v4' || authtype === 'v4-unsigned-body') {
+      version = 'v4';
+    } else {
+      version = this.api.signatureVersion;
+    }
+    return AWS.Signers.RequestSigner.getVersion(version);
+  },
+
+  /**
+   * @api private
+   */
+  serviceInterface: function serviceInterface() {
+    switch (this.api.protocol) {
+      case 'ec2': return AWS.EventListeners.Query;
+      case 'query': return AWS.EventListeners.Query;
+      case 'json': return AWS.EventListeners.Json;
+      case 'rest-json': return AWS.EventListeners.RestJson;
+      case 'rest-xml': return AWS.EventListeners.RestXml;
+    }
+    if (this.api.protocol) {
+      throw new Error('Invalid service `protocol\' ' +
+        this.api.protocol + ' in API config');
+    }
+  },
+
+  /**
+   * @api private
+   */
+  successfulResponse: function successfulResponse(resp) {
+    return resp.httpResponse.statusCode < 300;
+  },
+
+  /**
+   * How many times a failed request should be retried before giving up.
+   * the defaultRetryCount can be overriden by service classes.
+   *
+   * @api private
+   */
+  numRetries: function numRetries() {
+    if (this.config.maxRetries !== undefined) {
+      return this.config.maxRetries;
+    } else {
+      return this.defaultRetryCount;
+    }
+  },
+
+  /**
+   * @api private
+   */
+  retryDelays: function retryDelays(retryCount) {
+    return AWS.util.calculateRetryDelay(retryCount, this.config.retryDelayOptions);
+  },
+
+  /**
+   * @api private
+   */
+  retryableError: function retryableError(error) {
+    if (this.networkingError(error)) return true;
+    if (this.expiredCredentialsError(error)) return true;
+    if (this.throttledError(error)) return true;
+    if (error.statusCode >= 500) return true;
+    return false;
+  },
+
+  /**
+   * @api private
+   */
+  networkingError: function networkingError(error) {
+    return error.code === 'NetworkingError';
+  },
+
+  /**
+   * @api private
+   */
+  expiredCredentialsError: function expiredCredentialsError(error) {
+    // TODO : this only handles *one* of the expired credential codes
+    return (error.code === 'ExpiredTokenException');
+  },
+
+  /**
+   * @api private
+   */
+  clockSkewError: function clockSkewError(error) {
+    switch (error.code) {
+      case 'RequestTimeTooSkewed':
+      case 'RequestExpired':
+      case 'InvalidSignatureException':
+      case 'SignatureDoesNotMatch':
+      case 'AuthFailure':
+      case 'RequestInTheFuture':
+        return true;
+      default: return false;
+    }
+  },
+
+  /**
+   * @api private
+   */
+  throttledError: function throttledError(error) {
+    // this logic varies between services
+    switch (error.code) {
+      case 'ProvisionedThroughputExceededException':
+      case 'Throttling':
+      case 'ThrottlingException':
+      case 'RequestLimitExceeded':
+      case 'RequestThrottled':
+        return true;
+      default:
+        return false;
+    }
+  },
+
+  /**
+   * @api private
+   */
+  endpointFromTemplate: function endpointFromTemplate(endpoint) {
+    if (typeof endpoint !== 'string') return endpoint;
+
+    var e = endpoint;
+    e = e.replace(/\{service\}/g, this.api.endpointPrefix);
+    e = e.replace(/\{region\}/g, this.config.region);
+    e = e.replace(/\{scheme\}/g, this.config.sslEnabled ? 'https' : 'http');
+    return e;
+  },
+
+  /**
+   * @api private
+   */
+  setEndpoint: function setEndpoint(endpoint) {
+    this.endpoint = new AWS.Endpoint(endpoint, this.config);
+  },
+
+  /**
+   * @api private
+   */
+  paginationConfig: function paginationConfig(operation, throwException) {
+    var paginator = this.api.operations[operation].paginator;
+    if (!paginator) {
+      if (throwException) {
+        var e = new Error();
+        throw AWS.util.error(e, 'No pagination configuration for ' + operation);
+      }
+      return null;
+    }
+
+    return paginator;
+  }
+});
+
+AWS.util.update(AWS.Service, {
+
+  /**
+   * Adds one method for each operation described in the api configuration
+   *
+   * @api private
+   */
+  defineMethods: function defineMethods(svc) {
+    AWS.util.each(svc.prototype.api.operations, function iterator(method) {
+      if (svc.prototype[method]) return;
+      var operation = svc.prototype.api.operations[method];
+      if (operation.authtype === 'none') {
+        svc.prototype[method] = function (params, callback) {
+          return this.makeUnauthenticatedRequest(method, params, callback);
+        };
+      } else {
+        svc.prototype[method] = function (params, callback) {
+          return this.makeRequest(method, params, callback);
+        };
+      }
+    });
+  },
+
+  /**
+   * Defines a new Service class using a service identifier and list of versions
+   * including an optional set of features (functions) to apply to the class
+   * prototype.
+   *
+   * @param serviceIdentifier [String] the identifier for the service
+   * @param versions [Array<String>] a list of versions that work with this
+   *   service
+   * @param features [Object] an object to attach to the prototype
+   * @return [Class<Service>] the service class defined by this function.
+   */
+  defineService: function defineService(serviceIdentifier, versions, features) {
+    AWS.Service._serviceMap[serviceIdentifier] = true;
+    if (!Array.isArray(versions)) {
+      features = versions;
+      versions = [];
+    }
+
+    var svc = inherit(AWS.Service, features || {});
+
+    if (typeof serviceIdentifier === 'string') {
+      AWS.Service.addVersions(svc, versions);
+
+      var identifier = svc.serviceIdentifier || serviceIdentifier;
+      svc.serviceIdentifier = identifier;
+    } else { // defineService called with an API
+      svc.prototype.api = serviceIdentifier;
+      AWS.Service.defineMethods(svc);
+    }
+
+    return svc;
+  },
+
+  /**
+   * @api private
+   */
+  addVersions: function addVersions(svc, versions) {
+    if (!Array.isArray(versions)) versions = [versions];
+
+    svc.services = svc.services || {};
+    for (var i = 0; i < versions.length; i++) {
+      if (svc.services[versions[i]] === undefined) {
+        svc.services[versions[i]] = null;
+      }
+    }
+
+    svc.apiVersions = Object.keys(svc.services).sort();
+  },
+
+  /**
+   * @api private
+   */
+  defineServiceApi: function defineServiceApi(superclass, version, apiConfig) {
+    var svc = inherit(superclass, {
+      serviceIdentifier: superclass.serviceIdentifier
+    });
+
+    function setApi(api) {
+      if (api.isApi) {
+        svc.prototype.api = api;
+      } else {
+        svc.prototype.api = new Api(api);
+      }
+    }
+
+    if (typeof version === 'string') {
+      if (apiConfig) {
+        setApi(apiConfig);
+      } else {
+        try {
+          setApi(AWS.apiLoader(superclass.serviceIdentifier, version));
+        } catch (err) {
+          throw AWS.util.error(err, {
+            message: 'Could not find API configuration ' +
+              superclass.serviceIdentifier + '-' + version
+          });
+        }
+      }
+      if (!Object.prototype.hasOwnProperty.call(superclass.services, version)) {
+        superclass.apiVersions = superclass.apiVersions.concat(version).sort();
+      }
+      superclass.services[version] = svc;
+    } else {
+      setApi(version);
+    }
+
+    AWS.Service.defineMethods(svc);
+    return svc;
+  },
+
+  /**
+   * @api private
+   */
+  hasService: function(identifier) {
+    return Object.prototype.hasOwnProperty.call(AWS.Service._serviceMap, identifier);
+  },
+
+  /**
+   * @api private
+   */
+  _serviceMap: {}
+});
+
+module.exports = AWS.Service;