kii-sdk.js

var ctor = (function() {  // generated by build.sh for running on Node.js
// Generated by CoffeeScript 1.6.2
var KiiRequest, KiiUtilities, root, _Kii, _KiiSocialConnect,
  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
  __hasProp = {}.hasOwnProperty,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  _this = this;

root = ((typeof exports) !== "undefined") && (exports !== null) ? new Object() : this;

root.KiiSocialNetworkName = {
  FACEBOOK: 1
};

root.KiiSite = {
  US: "https://api.kii.com/api",
  JP: "https://api-jp.kii.com/api",
  CN: "https://api-cn2.kii.com/api"
};

root.KiiSiteInternal = {
  DEV: "https://dev-jp.internal.kii.com/api",
  STG: "https://qa21.internal.kii.com/api"
};

/**
    @class The main SDK class
    @exports root.Kii as Kii
    
    This class must be initialized before any Kii SDK functions are performed. This class also allows the application to make some high-level user calls and access some application-wide data at any time using static methods.
*/


root.Kii = (function() {
  var _instance;

  function Kii() {}

  _instance = null;

  /** 
      Kii SDK Build Number
      @returns {String} current build number of the SDK
  */


  Kii.getBuildNumber = function() {
    return "1";
  };

  /** 
      Kii SDK Version Number
      @returns {String} current version number of the SDK
  */


  Kii.getSDKVersion = function() {
    return "2.1.6";
  };

  Kii.getBaseURL = function() {
    return _instance._baseURL;
  };

  /**
      Retrieve the current app ID
      @returns {String} The current app ID
  */


  Kii.getAppID = function() {
    return _instance._appID;
  };

  /**
      Retrieve the current app key
      @returns {String} The current app key
  */


  Kii.getAppKey = function() {
    return _instance._appKey;
  };

  Kii.isLogging = function() {
    return _instance._logging;
  };

  Kii.setLogging = function(logging) {
    root.Kii.logger("Setting logging: " + logging);
    return _instance._logging = logging;
  };

  /** Initialize the Kii SDK with a specific URL
  
  Should be the first Kii SDK action your application makes
  @param String appID The application ID found in your Kii developer console
  @param String appKey The application key found in your Kii developer console
  @param KiiSite site Can be one of the constants KiiSite.US, KiiSite.JP or KiiSite.CN depending on your location.
  @example
  Kii.initializeWithSite("my-app-id", "my-app-key", KiiSite.JP);
  */


  Kii.initializeWithSite = function(appID, appKey, site) {
    if (_instance == null) {
      _instance = new _Kii(appID, appKey, site);
    }
    return root.Kii.logger("Initialized " + appID + ", " + appKey + ", " + site);
  };

  /** Initialize the Kii SDK
  
  Should be the first Kii SDK action your application makes
  @param String appID The application ID found in your Kii developer console
  @param String appKey The application key found in your Kii developer console
  @example
  Kii.initialize("my-app-id", "my-app-key");
  */


  Kii.initialize = function(appID, appKey) {
    return root.Kii.initializeWithSite(appID, appKey, root.KiiSite.US);
  };

  Kii.error = function(message) {
    return console.log("KiiSDK Error => " + message);
  };

  Kii.logger = function(message) {
    if (_instance._logging) {
      return console.log(message);
    }
  };

  /**
      Creates a reference to a bucket for this user
      
      <br><br>The bucket will be created/accessed within this app's scope
      @param String bucketName The name of the bucket the app should create/access
      @returns {KiiBucket} A working KiiBucket object
      @example
      var bucket = Kii.bucketWithName("myBucket");
  */


  Kii.bucketWithName = function(bucketName) {
    return new root.KiiBucket._bucketWithName(bucketName, null);
  };

  /** 
      Creates a reference to a group with the given name
  
      @param {String} groupName An application-specific group name
      @returns {KiiGroup} A new KiiGroup reference
      @example
      var group = new Kii.groupWithName("myGroup");
  */


  Kii.groupWithName = function(groupName) {
    return new root.Kii.groupWithNameAndMembers(groupName, null);
  };

  /** 
      Creates a reference to a group with the given name and a list of default members
  
      @param {String} groupName An application-specific group name
      @param {Array} members An array of KiiUser objects to add to the group
      @returns {KiiGroup} A new KiiGroup reference
      @example
      var group = new KiiGroup.groupWithName("myGroup", members);
  */


  Kii.groupWithNameAndMembers = function(groupName, members) {
    return new root.KiiGroup.groupWithNameAndMembers(groupName, members);
  };

  Kii.logOut = function() {
    return _instance._currentUser = null;
  };

  Kii.loggedIn = function() {
    return _instance._currentUser != null;
  };

  Kii.getCurrentUser = function() {
    var user;

    if (_instance._currentUser != null) {
      user = new root.KiiUser();
      user._uuid = _instance._currentUser._uuid;
      user._username = _instance._currentUser._username;
      user._displayName = _instance._currentUser._displayName;
      user._password = _instance._currentUser._password;
      user._emailAddress = _instance._currentUser._emailAddress;
      user._phoneNumber = _instance._currentUser._phoneNumber;
      user._country = _instance._currentUser._country;
      user._created = _instance._currentUser._created;
      user._modified = _instance._currentUser._modified;
      user._emailVerified = _instance._currentUser._emailVerified;
      user._phoneVerified = _instance._currentUser._phoneVerified;
      user._accessToken = _instance._currentUser._accessToken;
      user._customInfo = _instance._currentUser._customInfo;
      root.Kii.logger("my instance:");
      root.Kii.logger(user);
      return user;
    } else {
      return null;
    }
  };

  Kii.setCurrentUser = function(user) {
    _instance._currentUser = new root.KiiUser();
    _instance._currentUser._uuid = user._uuid;
    _instance._currentUser._username = user._username;
    _instance._currentUser._displayName = user._displayName;
    _instance._currentUser._password = user._password;
    _instance._currentUser._emailAddress = user._emailAddress;
    _instance._currentUser._phoneNumber = user._phoneNumber;
    _instance._currentUser._country = user._country;
    _instance._currentUser._created = user._created;
    _instance._currentUser._modified = user._modified;
    _instance._currentUser._emailVerified = user._emailVerified;
    _instance._currentUser._phoneVerified = user._phoneVerified;
    _instance._currentUser._accessToken = user._accessToken;
    _instance._currentUser._customInfo = user._customInfo;
    root.Kii.logger("my instance:");
    return root.Kii.logger(_instance._currentUser);
  };

  /** Authenticate as app admin. 
  <br><br>
  <b>This api call must not placed on code which can be accessed by browser.
  This api is intended to be used by server side code like Node.js.
  If you use this api in code accessible by browser, your application id and application secret could be stolen.
  Attacker will be act as appadmin and all the data in your application will be suffered.
  </b>
  @param {String} clientId assigned to your application.
  @param {String} clientSecret assigned to your application.
  @param {Method} callbacks.success The callback method called when authentication succeeded. 
  @param {Method} callbacks.failure The callback method called when authentication failed.
  @example
  Kii.authenticateAsAppAdmin("your client id", "your client secret", {
      success: function(adminContext) {
          // adminContext : KiiAppAdminContext instance
          // Operate entities with adminContext.
      },
      failure: function(error, statusCode) {
          // Authentication failed.
      }
  );
  */


  Kii.authenticateAsAppAdmin = function(clientId, clientSecret, callbacks) {
    var authCallbacks, request,
      _this = this;

    request = new KiiRequest("/oauth2/token", false);
    request.setAnonymous(true);
    request.setMethod("POST");
    request.setData({
      'client_id': clientId,
      'client_secret': clientSecret
    });
    authCallbacks = {
      success: function(data) {
        var admin, id, token;

        token = data.access_token;
        id = data.id;
        root.Kii.logger("token: " + token);
        root.Kii.logger("id: " + id);
        admin = new root.KiiAppAdminContext({
          token: token,
          id: id
        });
        if (callbacks != null) {
          return callbacks.success(admin);
        }
      },
      failure: function(error, statusCode) {
        root.Kii.logger("error: " + error);
        root.Kii.logger("statusCode: " + statusCode);
        if (callbacks != null) {
          return callbacks.failure(error, statusCode);
        }
      }
    };
    return request.execute(authCallbacks, false);
  };

  return Kii;

})();

_Kii = (function() {
  _Kii.prototype._logging = false;

  _Kii.prototype._baseURL = null;

  _Kii.prototype._currentUser = null;

  function _Kii(appID, appKey, site) {
    console.log("Setting site: " + site);
    this._appKey = appKey;
    this._appID = appID;
    this._baseURL = site;
  }

  return _Kii;

})();

/**
    @class Represents a KiiACL object
    @exports root.KiiACL as KiiACL
*/


root.KiiACL = (function() {
  var _entries, _parent, _thisACL;

  _thisACL = null;

  _entries = null;

  _parent = null;

  function KiiACL() {
    this._userWithID = __bind(this._userWithID, this);
    this._groupWithID = __bind(this._groupWithID, this);
    this._getRequest = __bind(this._getRequest, this);
    this._saveItr = __bind(this._saveItr, this);
    this.save = __bind(this.save, this);
    this.removeACLEntry = __bind(this.removeACLEntry, this);
    this.putACLEntry = __bind(this.putACLEntry, this);
    this.listACLEntries = __bind(this.listACLEntries, this);
    this.aclPath = __bind(this.aclPath, this);
    this._setParent = __bind(this._setParent, this);    this._entries = [];
  }

  KiiACL.prototype._setParent = function(_parent) {
    this._parent = _parent;
  };

  KiiACL.prototype.aclPath = function() {
    var bucket, bucketName, group, object, objectId, path, user;

    if (this._parent instanceof root.KiiObject) {
      object = this._parent;
      if (object.getBucket().getUser() != null) {
        user = object.getBucket().getUser();
      } else if (object.getBucket().getGroup() != null) {
        group = object.getBucket().getGroup();
      }
      bucketName = object.getBucket().getBucketName();
      objectId = object.getUUID();
    } else if (this._parent instanceof root.KiiBucket) {
      bucket = this._parent;
      if (bucket.getUser() != null) {
        user = bucket.getUser();
      } else if (bucket.getGroup() != null) {
        group = bucket.getGroup();
      }
      bucketName = bucket.getBucketName();
    } else {
      root.Kii.error("Invalid ACL parent. Must belong to a KiiObject");
    }
    path = "/";
    if (group != null) {
      path += "groups/" + (group.getUUID()) + "/";
    } else if (user != null) {
      path += "users/" + (user.getUUID()) + "/";
    }
    if (objectId != null) {
      path += "buckets/" + bucketName + "/objects/" + objectId + "/acl";
    } else {
      path += "buckets/" + bucketName + "/acl";
    }
    return path;
  };

  /** Get the list of active ACLs associated with this object from the server
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful list request
  @param {Method} callbacks.failure The callback method to call on a failed list request
  @example
  var acl = . . .; // a KiiACL object
  acl.listACLEntries({
  	success: function(theACL, theEntries) {
  		// do something
  	},
  	
  	failure: function(theACL, anErrorString) {
  		// do something with the error response
  	}
  });
  */


  KiiACL.prototype.listACLEntries = function(callbacks) {
    var listCallbacks, request,
      _this = this;

    _thisACL = this;
    root.Kii.logger("Listing ACL entries");
    request = this._getRequest({
      path: this.aclPath(),
      withApp: true
    });
    listCallbacks = {
      success: function(data, statusCode) {
        var action, entity, key, results, subject, value, _i, _len;

        if (statusCode < 300 && statusCode >= 200) {
          results = [];
          for (key in data) {
            value = data[key];
            if (key === "WRITE_EXISTING_OBJECT") {
              action = root.KiiACLAction.KiiACLObjectActionWrite;
            } else if (key === "READ_EXISTING_OBJECT") {
              action = root.KiiACLAction.KiiACLObjectActionRead;
            } else if (key === "QUERY_OBJECTS_IN_BUCKET") {
              action = root.KiiACLAction.KiiACLBucketActionQueryObjects;
            } else if (key === "CREATE_OBJECTS_IN_BUCKET") {
              action = root.KiiACLAction.KiiACLBucketActionCreateObjects;
            } else if (key === "DROP_BUCKET_WITH_ALL_CONTENT") {
              action = root.KiiACLAction.KiiACLBucketActionDropBucket;
            }
            for (_i = 0, _len = value.length; _i < _len; _i++) {
              entity = value[_i];
              if (entity.groupID != null) {
                subject = _this._groupWithID(entity.groupID);
              } else if (entity.userID != null) {
                subject = _this._userWithID(entity.userID);
              }
              results.push(KiiACLEntry.entryWithSubject(subject, action));
            }
          }
          return callbacks.success(_thisACL, results);
        } else {
          return callbacks.failure(_thisACL, "Unable to retrieve ACL list");
        }
      },
      failure: function(error, statusCode) {
        return callbacks.failure(_thisACL, error);
      }
    };
    return request.execute(listCallbacks, false);
  };

  /** Add a KiiACLEntry to the local object, if not already present. This does not explicitly grant any permissions, which should be done through the KiiACLEntry itself. This method simply adds the entry to the local ACL object so it can be saved to the server.
  @param {KiiACLEntry} entry The KiiACLEntry to add
  @example
  var aclEntry = . . .; // a KiiACLEntry object
  var acl = . . .; // a KiiACL object
  acl.putACLEntry(aclEntry);
  */


  KiiACL.prototype.putACLEntry = function(entry) {
    if (($.inArray(entry, this._entries)) === -1) {
      return this._entries.push(entry);
    }
  };

  /** Remove a KiiACLEntry to the local object. This does not explicitly revoke any permissions, which should be done through the KiiACLEntry itself. This method simply removes the entry from the local ACL object and will not be saved to the server.
  @param {KiiACLEntry} entry The KiiACLEntry to remove
  @example 
  var aclEntry = . . .; // a KiiACLEntry object
  var acl = . . .; // a KiiACL object
  acl.removeACLEntry(aclEntry);
  */


  KiiACL.prototype.removeACLEntry = function(entry) {
    var ndx;

    ndx = $.inArray(entry, this._entries);
    if (ndx > -1) {
      return KiiUtilities.arrayRemove(this._entries, ndx, ndx);
    }
  };

  /** Save the list of ACLEntry objects associated with this ACL object to the server
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful save request
  @param {Method} callbacks.failure The callback method to call on a failed save request
  @example
  var obj = . . .; // a KiiObject
  obj.save({
      success: function(theSavedACL) {
          // do something with the saved acl
      },
  
      failure: function(theACL, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiACL.prototype.save = function(callbacks) {
    root.Kii.logger("SAving acl");
    return this._saveItr(0, callbacks);
  };

  KiiACL.prototype._saveItr = function(idx, callbacks) {
    var aclEntry, path, request, _errorStr,
      _this = this;

    _this = this;
    aclEntry = this._entries[idx];
    path = "" + (this.aclPath()) + "/" + (aclEntry.getActionString()) + "/" + (aclEntry.getEntityString());
    root.Kii.logger("Saving single @path: " + path);
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod(aclEntry.getGrant() === true ? "PUT" : "DELETE");
    _errorStr = null;
    return request.execute({
      success: function(data, status, xhr) {
        if (idx < _this._entries.length - 1) {
          return _this._saveItr(idx + 1, callbacks);
        } else {
          return callbacks.success(_this);
        }
      },
      failure: function(errorStr, statusCode, errorCode) {
        return callbacks.failure(_this, errorStr);
      }
    }, false);
  };

  KiiACL.aclWithParent = function(parent) {
    var acl;

    acl = new root.KiiACL();
    acl._setParent(parent);
    return acl;
  };

  KiiACL.prototype._getRequest = function(spec) {
    var path, request, withApp;

    path = spec.path;
    withApp = spec.withApp;
    request = new KiiRequest(path, withApp);
    return request;
  };

  KiiACL.prototype._groupWithID = function(id) {
    var group;

    group = root.KiiGroup._groupWithID(id);
    return group;
  };

  KiiACL.prototype._userWithID = function(id) {
    var user;

    user = root.KiiUser._userWithID(id);
    return user;
  };

  return KiiACL;

}).call(this);

root.KiiACLAction = {
  KiiACLBucketActionCreateObjects: 0,
  KiiACLBucketActionQueryObjects: 1,
  KiiACLBucketActionDropBucket: 2,
  KiiACLObjectActionRead: 3,
  KiiACLObjectActionWrite: 4
};

/**
    @class Represents a KiiACLEntry object
    @exports root.KiiACLEntry as KiiACLEntry
*/


root.KiiACLEntry = (function() {
  var _action, _grant, _subject;

  _action = null;

  _subject = null;

  _grant = null;

  function KiiACLEntry() {
    this.getEntityString = __bind(this.getEntityString, this);
    this.getActionString = __bind(this.getActionString, this);
    this.getGrant = __bind(this.getGrant, this);
    this.setGrant = __bind(this.setGrant, this);
    this.getSubject = __bind(this.getSubject, this);
    this.setSubject = __bind(this.setSubject, this);
    this.getAction = __bind(this.getAction, this);
    this.setAction = __bind(this.setAction, this);    this._action = -1;
    this._grant = true;
  }

  /** The action that is being permitted/restricted. Possible values:
  <br><br>
  KiiACLAction.KiiACLBucketActionCreateObjects,<br>
  KiiACLAction.KiiACLBucketActionQueryObjects,  <br>
  KiiACLAction.KiiACLBucketActionDropBucket,<br>
  KiiACLAction.KiiACLObjectActionRead,<br>
  KiiACLAction.KiiACLObjectActionWrite
  @param {KiiACLAction} value The action being permitted/restricted
  @throws {InvalidACLAction} If the value is not one of the permitted values
  */


  KiiACLEntry.prototype.setAction = function(value) {
    if (value >= root.KiiACLAction.KiiACLBucketActionCreateObjects && value <= root.KiiACLAction.KiiACLObjectActionWrite) {
      return this._action = value;
    } else {
      throw new InvalidACLAction;
    }
  };

  /** Get the action that is being permitted/restricted in this entry
  @returns {KiiACLAction}
  */


  KiiACLEntry.prototype.getAction = function() {
    return this._action;
  };

  /** The KiiUser or KiiGroup entity that is being permitted/restricted
  @param {KiiUser|KiiGroup} value The entity being permitted/restricted
  @throws {InvalidACLSubject} If the value is not one of the permitted values
  */


  KiiACLEntry.prototype.setSubject = function(value) {
    if (value instanceof root.KiiGroup || value instanceof root.KiiUser || value instanceof root.KiiAnyAuthenticatedUser || value instanceof root.KiiAnonymousUser) {
      return this._subject = value;
    } else {
      throw new InvalidACLSubject;
    }
  };

  /** Get the subject that is being permitted/restricted in this entry
  @returns {KiiUser|KiiGroup}
  */


  KiiACLEntry.prototype.getSubject = function() {
    return this._subject;
  };

  /** Set whether or not the action is being permitted to the subject
  @param {Boolean} value true if the action is permitted, false otherwise
  @throws {InvalidACLGrant} If the value is not a boolean type
  */


  KiiACLEntry.prototype.setGrant = function(value) {
    if (value === true || value === false) {
      return this._grant = value;
    } else {
      throw new InvalidACLGrant;
    }
  };

  /** Get whether or not the action is being permitted to the subject
  @returns {Boolean}
  */


  KiiACLEntry.prototype.getGrant = function() {
    return this._grant;
  };

  /** Create a KiiACLEntry object with a subject and action
  
  The entry will not be applied on the server until the KiiACL object is explicitly saved. This method simply returns a working KiiACLEntry with a specified subject and action.
  @param {KiiGroup|KiiUser|KiiAnyAuthenticatedUser|KiiAnonymousUser} subject A KiiGroup or KiiUser object to which the action/grant is being applied
  @param {KiiACLAction} action One of the specified KiiACLAction values the permissions is being applied to
  @return A KiiACLEntry object with the specified attributes
  */


  KiiACLEntry.entryWithSubject = function(subject, action) {
    var entry;

    root.Kii.logger("EWS: " + subject + ", " + action);
    entry = new root.KiiACLEntry();
    entry.setSubject(subject);
    entry.setAction(action);
    return entry;
  };

  KiiACLEntry.prototype.getActionString = function() {
    var retString;

    root.Kii.logger("Action: " + this.action);
    switch (this._action) {
      case root.KiiACLAction.KiiACLBucketActionCreateObjects:
        retString = "CREATE_OBJECTS_IN_BUCKET";
        break;
      case root.KiiACLAction.KiiACLBucketActionQueryObjects:
        retString = "QUERY_OBJECTS_IN_BUCKET";
        break;
      case root.KiiACLAction.KiiACLBucketActionDropBucket:
        retString = "DROP_BUCKET_WITH_ALL_CONTENT";
        break;
      case root.KiiACLAction.KiiACLObjectActionRead:
        retString = "READ_EXISTING_OBJECT";
        break;
      case root.KiiACLAction.KiiACLObjectActionWrite:
        retString = "WRITE_EXISTING_OBJECT";
        break;
      default:
        return retString;
    }
    return retString;
  };

  KiiACLEntry.prototype.getEntityString = function() {
    var entityId, type;

    if (this._subject instanceof root.KiiGroup) {
      entityId = this._subject.getUUID();
      type = "GroupID";
    } else if (this._subject instanceof root.KiiUser) {
      entityId = this._subject.getUUID();
      type = "UserID";
    } else if (this._subject instanceof root.KiiAnyAuthenticatedUser) {
      type = "UserID";
      entityId = "ANY_AUTHENTICATED_USER";
    } else if (this._subject instanceof root.KiiAnonymousUser) {
      type = "UserID";
      entityId = "ANONYMOUS_USER";
    }
    return "" + type + ":" + entityId;
  };

  return KiiACLEntry;

}).call(this);

/**
    @class Represents a KiiBucket object
    @exports root.KiiBucket as KiiBucket
*/


root.KiiBucket = (function() {
  var _bucketName, _group, _thisBucket, _user;

  KiiBucket.prototype._className = "KiiBucket";

  _thisBucket = null;

  _bucketName = null;

  _user = null;

  _group = null;

  KiiBucket.prototype.getUser = function() {
    return this._user;
  };

  KiiBucket.prototype._setUser = function(_user) {
    this._user = _user;
  };

  KiiBucket.prototype.getGroup = function() {
    return this._group;
  };

  KiiBucket.prototype._setGroup = function(_group) {
    this._group = _group;
  };

  /** The name of this bucket 
  @returns {String}
  */


  KiiBucket.prototype.getBucketName = function() {
    return this._bucketName;
  };

  KiiBucket.prototype._setBucketName = function(_bucketName) {
    this._bucketName = _bucketName;
  };

  /** Create a KiiObject within the current bucket
  
  <br><br>The object will not be created on the server until the KiiObject is explicitly saved. This method simply returns an empty working KiiObject.
  @returns {KiiObject} An empty KiiObject with no specific type
  @example
  var bucket = . . .; // a KiiBucket
  var object = bucket.createObject();
  */


  KiiBucket.prototype.createObject = function() {
    return root.KiiObject.objectWithBucket(this, null);
  };

  /** Create a KiiObject within the current bucket, with type
  
  <br><br>The object will not be created on the server until the KiiObject is explicitly saved. This method simply returns an empty working KiiObject with a specified type. The type allows for better indexing and improved query results. It is recommended to use this method - but for lazy creation, the createObject method is also available.
  @param String type A string representing the desired object type
  @returns An empty KiiObject with specified type
  @example 
  var bucket = . . .; // a KiiBucket
  var object = bucket.createObjectWithType("scores");
  */


  KiiBucket.prototype.createObjectWithType = function(type) {
    return root.KiiObject.objectWithBucket(this, type);
  };

  /** Get the ACL handle for this bucket
  
  <br><br>Any KiiACLEntry objects added or revoked from this ACL object will be appended to/removed from the server on ACL save. 
  	@returns {KiiACL} A KiiACL object associated with this KiiObject
  	@example 
  	var bucket = . . .; // a KiiBucket
  	var acl = bucket.acl();
  */


  KiiBucket.prototype.acl = function() {
    return root.KiiACL.aclWithParent(this);
  };

  /** Perform a query on the given bucket
  
  <br><br>The query will be executed against the server, returning a result set.
  @param KiiQuery query An object with callback methods defined
  @param Object callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful query request
  @param {Method} callbacks.failure The callback method to call on a failed query request
  @example 
  var bucket = . . .; // a KiiBucket
  var queryObject = . . .; // a KiiQuery
  
  // define the callbacks (stored in a variable for reusability)
  var queryCallbacks = {
      success: function(queryPerformed, resultSet, nextQuery) {
          // do something with the results
          for(var i=0; i&lt;resultSet.length; i++) {
              // do something with the object
              // resultSet[i]; // could be KiiObject, KiiGroup, KiiUser, etc
          }
  
          // if there are more results to be retrieved
          if(nextQuery != null) {
              
              // get them and repeat recursively until no results remain
              bucket.executeQuery(nextQuery, queryCallbacks);
          }
      },
      
      failure: function(queryPerformed, anErrorString) {
          // do something with the error response
      }
  };
  
  bucket.executeQuery(queryObject, queryCallbacks);
  */


  KiiBucket.prototype.executeQuery = function(query, callbacks) {
    var clauseData, data, executeCallbacks, path, request,
      _this = this;

    _thisBucket = this;
    path = this._generatePath() + "/query";
    data = {};
    if (query != null) {
      clauseData = query._dictValue();
      data.bestEffortLimit = query.getLimit();
      if (query.getPaginationKey() != null) {
        data.paginationKey = query.getPaginationKey();
      }
    } else {
      clauseData = {
        "clause": root.KiiQuery._emptyDictValue()
      };
    }
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod("POST");
    request.setContentType("application/vnd.kii.QueryRequest+json");
    data.bucketQuery = clauseData;
    request.setData(data);
    executeCallbacks = {
      success: function(data, statusCode) {
        var nextQuery, result, resultSet, _i, _len, _ref;

        if (statusCode < 300 && statusCode >= 200) {
          resultSet = [];
          _ref = data.results;
          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
            result = _ref[_i];
            resultSet.push(_thisBucket.objectWithJSON(result));
          }
          if (data.nextPaginationKey != null) {
            nextQuery = jQuery.extend(true, {}, query);
            nextQuery.setPaginationKey(data.nextPaginationKey);
          }
          if (callbacks != null) {
            return callbacks.success(query, resultSet, nextQuery);
          }
        } else if (callbacks != null) {
          return callbacks.failure(query, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisBucket, error);
        }
      }
    };
    return request.execute(executeCallbacks, false);
  };

  /** Delete the given bucket from the server
  
  @param Object callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful query request
  @param {Method} callbacks.failure The callback method to call on a failed query request
  @example 
  var bucket = . . .; // a KiiBucket
  bucket.delete({
      success: function(deletedBucket) {
          // do something with the result
      },
      
      failure: function(bucketToDelete, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiBucket.prototype["delete"] = function(callbacks) {
    var executeCallbacks, request,
      _this = this;

    _thisBucket = this;
    request = this._getRequest({
      path: this._generatePath(),
      withApp: true
    });
    request.setMethod("DELETE");
    executeCallbacks = {
      success: function(data, statusCode) {
        if (callbacks != null) {
          return callbacks.success(_thisBucket);
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisBucket, error);
        }
      }
    };
    return request.execute(executeCallbacks, true);
  };

  function KiiBucket(bucketName, parent) {
    this.objectWithJSON = __bind(this.objectWithJSON, this);
    this._generatePath = __bind(this._generatePath, this);
    this._getRequest = __bind(this._getRequest, this);
    this["delete"] = __bind(this["delete"], this);
    this.executeQuery = __bind(this.executeQuery, this);
    this.acl = __bind(this.acl, this);
    this.createObjectWithType = __bind(this.createObjectWithType, this);
    this.createObject = __bind(this.createObject, this);
    this._setBucketName = __bind(this._setBucketName, this);
    this.getBucketName = __bind(this.getBucketName, this);
    this._setGroup = __bind(this._setGroup, this);
    this.getGroup = __bind(this.getGroup, this);
    this._setUser = __bind(this._setUser, this);
    this.getUser = __bind(this.getUser, this);    this._bucketName = bucketName;
    if (parent != null) {
      if (parent instanceof root.KiiGroup) {
        this._group = parent;
      } else if (parent instanceof root.KiiUser) {
        this._user = parent;
      }
    }
  }

  KiiBucket._bucketWithName = function(bucketName, parent) {
    var bucket;

    bucket = new root.KiiBucket(bucketName, parent);
    return bucket;
  };

  KiiBucket.prototype._getRequest = function(spec) {
    var path, request, withApp;

    path = spec.path;
    withApp = spec.withApp;
    request = new KiiRequest(path, withApp);
    return request;
  };

  KiiBucket.prototype._generatePath = function() {
    var path;

    if (this._user != null) {
      path = "/users/" + (this._user.getUUID()) + "/buckets/" + this._bucketName;
    } else if (this._group != null) {
      path = "/groups/" + (this._group.getUUID()) + "/buckets/" + this._bucketName;
    } else {
      path = "/buckets/" + this._bucketName;
    }
    return path;
  };

  KiiBucket.prototype.objectWithJSON = function(json) {
    var newobject;

    newobject = this.createObject();
    newobject._updateWithJSON(json);
    return newobject;
  };

  return KiiBucket;

}).call(this);

root.KiiBucketAdmin = (function(_super) {
  var _adminToken;

  __extends(KiiBucketAdmin, _super);

  _adminToken = null;

  function KiiBucketAdmin(bucketName, parent, token) {
    this.acl = __bind(this.acl, this);
    this.createObjectWithType = __bind(this.createObjectWithType, this);
    this.createObject = __bind(this.createObject, this);
    this._getRequest = __bind(this._getRequest, this);    KiiBucketAdmin.__super__.constructor.call(this, bucketName, parent);
    this._adminToken = token;
  }

  KiiBucketAdmin.prototype._getRequest = function(spec) {
    var request;

    request = KiiBucketAdmin.__super__._getRequest.call(this, spec);
    request.setAdminToken(this._adminToken);
    return request;
  };

  KiiBucketAdmin.prototype.createObject = function() {
    return root.KiiObjectAdmin.objectWithBucket(this, null, this._adminToken);
  };

  KiiBucketAdmin.prototype.createObjectWithType = function(type) {
    return root.KiiObjectAdmin.objectWithBucket(this, type, this._adminToken);
  };

  KiiBucketAdmin.prototype.acl = function() {
    var acl;

    acl = new root.KiiACLAdmin(this, this._adminToken);
    return acl;
  };

  return KiiBucketAdmin;

})(root.KiiBucket);

/**
    @class Represents a KiiGroup object
    @exports root.KiiGroup as KiiGroup
*/


root.KiiGroup = (function() {
  var _addMembers, _groupName, _owner, _removeMembers, _thisGroup;

  _thisGroup = null;

  _groupName = null;

  _owner = null;

  _addMembers = null;

  _removeMembers = null;

  KiiGroup.prototype._getAddMembers = function() {
    return this._addMembers;
  };

  KiiGroup.prototype._getRemoveMembers = function() {
    return this._removeMembers;
  };

  function KiiGroup() {
    this._setOwnerFromContext = __bind(this._setOwnerFromContext, this);
    this._userWithID = __bind(this._userWithID, this);
    this._getRequest = __bind(this._getRequest, this);
    this.getOwner = __bind(this.getOwner, this);
    this["delete"] = __bind(this["delete"], this);
    this.refresh = __bind(this.refresh, this);
    this.save = __bind(this.save, this);
    this.changeGroupName = __bind(this.changeGroupName, this);
    this._saveMembers = __bind(this._saveMembers, this);
    this.getMemberList = __bind(this.getMemberList, this);
    this._removeMember = __bind(this._removeMember, this);
    this._addMember = __bind(this._addMember, this);
    this.removeUser = __bind(this.removeUser, this);
    this.addUser = __bind(this.addUser, this);
    this.bucketWithName = __bind(this.bucketWithName, this);
    this.objectURI = __bind(this.objectURI, this);
    this._setOwner = __bind(this._setOwner, this);
    this.getOwner = __bind(this.getOwner, this);
    this._setName = __bind(this._setName, this);
    this.getName = __bind(this.getName, this);
    this._setUUID = __bind(this._setUUID, this);
    this.getUUID = __bind(this.getUUID, this);
    this._setAddMembers = __bind(this._setAddMembers, this);
    this._getRemoveMembers = __bind(this._getRemoveMembers, this);
    this._getAddMembers = __bind(this._getAddMembers, this);    this._addMembers = [];
    this._removeMembers = [];
  }

  KiiGroup.prototype._setAddMembers = function(members) {
    var member, _i, _len, _results;

    if (members != null) {
      _results = [];
      for (_i = 0, _len = members.length; _i < _len; _i++) {
        member = members[_i];
        _results.push(this._addMembers.push(member));
      }
      return _results;
    }
  };

  /** Get the UUID of the given group, assigned by the server
  @returns {String}
  */


  KiiGroup.prototype.getUUID = function() {
    return this._uuid;
  };

  KiiGroup.prototype._setUUID = function(_uuid) {
    this._uuid = _uuid;
  };

  /** The name of this group 
  @returns {String}
  */


  KiiGroup.prototype.getName = function() {
    return this._groupName;
  };

  KiiGroup.prototype._setName = function(_groupName) {
    this._groupName = _groupName;
  };

  /** Get the creator of this group
  @returns {KiiUser}
  */


  KiiGroup.prototype.getOwner = function() {
    return this._owner;
  };

  KiiGroup.prototype._setOwner = function(_owner) {
    this._owner = _owner;
  };

  /** Get a specifically formatted string referencing the group
  
  <br><br>The group must exist in the cloud (have a valid UUID).
  @returns {String} A URI string based on the current group. null if a URI couldn't be generated.
  @example 
  var group = . . .; // a KiiGroup
  var uri = group.objectURI();
  */


  KiiGroup.prototype.objectURI = function() {
    if (this._uuid != null) {
      return "kiicloud://groups/" + this._uuid;
    } else {
      return null;
    }
  };

  /** Creates a reference to a bucket for this group
  
  <br><br>The bucket will be created/accessed within this group's scope
  @param {String} bucketName The name of the bucket the user should create/access
  @returns {KiiBucket} A working KiiBucket object
  @example 
  var group = . . .; // a KiiGroup
  var bucket = group.bucketWithName("myBucket");
  */


  KiiGroup.prototype.bucketWithName = function(bucketName) {
    var bucket;

    bucket = new root.KiiBucket(bucketName, this);
    return bucket;
  };

  /** Adds a user to the given group
  
  <br><br>This method will NOT access the server immediately. You must call save to add the user on the server. This allows multiple users to be added/removed before calling save.
  @param {KiiUser} member The user to be added to the group
  @example 
  var user = . . .; // a KiiUser
  var group = . . .; // a KiiGroup
  group.addUser(user);
  group.save(callbacks);
  */


  KiiGroup.prototype.addUser = function(member) {
    var ndx;

    if ($.inArray(member, this._addMembers === -1)) {
      this._addMembers.push(member);
    }
    ndx = $.inArray(member, this._removeMembers);
    if (ndx >= 0) {
      return KiiUtilities.arrayRemove(this._removeMembers, ndx, ndx);
    }
  };

  /** Removes a user from the given group
  
  <br><br>This method will NOT access the server immediately. You must call save to remove the user on the server. This allows multiple users to be added/removed before calling save.
  @param {KiiUser} member The user to be added to the group
  @example 
  var user = . . .; // a KiiUser
  var group = . . .; // a KiiGroup
  group.removeUser(user);
  group.save(callbacks);
  */


  KiiGroup.prototype.removeUser = function(member) {
    var ndx;

    if ($.inArray(member, this._removeMembers === -1)) {
      this._removeMembers.push(member);
    }
    ndx = $.inArray(member, this._addMembers);
    if (ndx >= 0) {
      return KiiUtilities.arrayRemove(this._addMembers, ndx, ndx);
    }
  };

  KiiGroup.prototype._addMember = function(member, callback) {
    var memberCallbacks, request,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Adding member " + (member.getUUID()) + " to group " + this._groupName);
    request = this._getRequest({
      path: "/groups/" + this._uuid + "/members/" + (member.getUUID()),
      withApp: true
    });
    request.setMethod("PUT");
    memberCallbacks = {
      success: function(data, statusCode) {
        var ndx;

        ndx = $.inArray(member, _thisGroup._getAddMembers());
        KiiUtilities.arrayRemove(_thisGroup._getAddMembers(), ndx, ndx);
        return callback();
      },
      failure: function(error, statusCode) {
        var ndx;

        ndx = $.inArray(member, _thisGroup._getAddMembers());
        KiiUtilities.arrayRemove(_thisGroup._getAddMembers(), ndx, ndx);
        return callback();
      }
    };
    return request.execute(memberCallbacks, true);
  };

  KiiGroup.prototype._removeMember = function(member, callback) {
    var removeCallbacks, request,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Removing member " + (member.getUUID()) + " to group " + this._groupName);
    request = this._getRequest({
      path: "/groups/" + this._uuid + "/members/" + (member.getUUID()),
      withApp: true
    });
    request.setMethod("DELETE");
    removeCallbacks = {
      success: function(data, statusCode) {
        var ndx;

        ndx = $.inArray(member, _thisGroup._getRemoveMembers());
        KiiUtilities.arrayRemove(_thisGroup._getRemoveMembers(), ndx, ndx);
        return callback();
      },
      failure: function(error, statusCode) {
        var ndx;

        ndx = $.inArray(member, _thisGroup._getRemoveMembers());
        KiiUtilities.arrayRemove(_thisGroup._getRemoveMembers(), ndx, ndx);
        return callback();
      }
    };
    return request.execute(removeCallbacks, true);
  };

  /** Gets a list of all current members of a group				
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful list request
  @param {Method} callbacks.failure The callback method to call on a failed list request
  @example 
  var group = . . .; // a KiiGroup
  group.getMemberList({
      success: function(theGroup, memberList) {
          // do something with the result
          for(var i=0; i&lt;memberList.length; i++){
              var u = memberList[i]; // a KiiUser within the group
          }
      },
      
      failure: function(theGroup, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiGroup.prototype.getMemberList = function(callbacks) {
    var listCallbacks, request,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Getting member list for group " + this._groupName);
    request = this._getRequest({
      path: "/groups/" + this._uuid + "/members",
      withApp: true
    });
    request.setAccept("application/vnd.kii.MembersRetrievalResponse+json");
    listCallbacks = {
      success: function(data, statusCode) {
        var member, memberList, members, _i, _len;

        if (statusCode < 300 && statusCode >= 200) {
          memberList = [];
          members = data['members'];
          for (_i = 0, _len = members.length; _i < _len; _i++) {
            member = members[_i];
            memberList.push(_this._userWithID(member.userID));
          }
          if (callbacks != null) {
            return callbacks.success(_thisGroup, memberList);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisGroup, member, "Unable to get member list of group");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisGroup, error);
        }
      }
    };
    return request.execute(listCallbacks, false);
  };

  KiiGroup.prototype._saveMembers = function(callbacks) {
    var member, _i, _j, _len, _len1, _ref, _ref1,
      _this = this;

    _thisGroup = this;
    _ref = this._removeMembers;
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      member = _ref[_i];
      this._removeMember(member, function() {
        return _thisGroup._saveMembers(callbacks);
      });
      return;
    }
    _ref1 = this._addMembers;
    for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
      member = _ref1[_j];
      this._addMember(member, function() {
        return _thisGroup._saveMembers(callbacks);
      });
      return;
    }
    return callbacks.success(_thisGroup);
  };

  /** Updates the group name on the server
  
  @param {String} newName A String of the desired group name
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful save request
  @param {Method} callbacks.failure The callback method to call on a failed save request
  @example 
  var group = . . .; // a KiiGroup
  group.changeGroupName("myNewName", {
      success: function(theRenamedGroup) {
          // do something with the group
      },
      
      failure: function(theGroup, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiGroup.prototype.changeGroupName = function(newName, callbacks) {
    var request, saveCallbacks,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Saving group: " + this.name);
    if (this._uuid != null) {
      request = this._getRequest({
        path: "/groups/" + this._uuid + "/name",
        withApp: true
      });
      request.setContentType("text/plain");
      request.setMethod("PUT");
      request.setData(newName);
      saveCallbacks = {
        success: function(data, statusCode) {
          if (statusCode < 300 && statusCode >= 200) {
            _thisGroup._setName(newName);
            if (callbacks != null) {
              return callbacks.success(_thisGroup);
            }
          } else if (callbacks != null) {
            return callbacks.failure(_thisGroup, "Unable to change group name - invalid response");
          }
        },
        failure: function(error, statusCode) {
          if (callbacks != null) {
            return callbacks.failure(_thisGroup, error);
          }
        }
      };
      return request.execute(saveCallbacks, true);
    } else {
      return callbacks.failure(_thisGroup, "Invalid group. Save the group on the server before updating the name.");
    }
  };

  /** Saves the latest group values to the server
  
  <br><br>If the group does not yet exist, it will be created. If the group already exists, the fields that have changed will be updated accordingly.
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful save request
  @param {Method} callbacks.failure The callback method to call on a failed save request
  @example 
  var group = . . .; // a KiiGroup
  group.save({
      success: function(theSavedGroup) {
          // do something with the saved group
      },
      
      failure: function(theGroup, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiGroup.prototype.save = function(callbacks) {
    var data, request, saveCallbacks,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Saving group: " + this.name);
    if (this._uuid == null) {
      request = this._getRequest({
        path: "/groups",
        withApp: true
      });
      request.setContentType("application/vnd.kii.GroupCreationRequest+json");
      request.setMethod("POST");
      data = {};
      if (this._groupName != null) {
        data.name = this._groupName;
      }
      this._setOwnerFromContext(data);
      request.setData(data);
      saveCallbacks = {
        success: function(data, statusCode) {
          if (statusCode < 300 && statusCode >= 200) {
            _thisGroup._setUUID(data.groupID);
            return _thisGroup._saveMembers(callbacks);
          }
        },
        failure: function(error, statusCode) {
          if (callbacks != null) {
            return callbacks.failure(_thisGroup, error);
          }
        }
      };
      return request.execute(saveCallbacks, false);
    } else {
      return this._saveMembers(callbacks);
    }
  };

  /** Updates the local group's data with the group data on the server
  
  <br><br>The group must exist on the server. Local data will be overwritten.    	
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful refresh request
  @param {Method} callbacks.failure The callback method to call on a failed refresh request
  @example 
  var group = . . .; // a KiiGroup
  group.refresh({
      success: function(theRefreshedGroup) {
          // do something with the refreshed group
      },
      
      failure: function(theGroup, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiGroup.prototype.refresh = function(callbacks) {
    var refreshCallbacks, request,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Refreshing group: " + this._groupName);
    request = new this._getRequest({
      path: "/groups/" + this._uuid,
      withApp: true
    });
    request.setAccept("application/vnd.kii.GroupRetrievalResponse+json");
    refreshCallbacks = {
      success: function(data, statusCode) {
        _thisGroup = root.KiiGroup._groupWithJSON(data);
        if (callbacks != null) {
          return callbacks.success(_thisGroup);
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisGroup, error);
        }
      }
    };
    return request.execute(refreshCallbacks, false);
  };

  /** Delete the group from the server
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful delete request
  @param {Method} callbacks.failure The callback method to call on a failed delete request
  @example 
  var group = . . .; // a KiiGroup
  group.delete({
      success: function(theDeletedGroup) {
          // do something
      },
      
      failure: function(theGroup, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiGroup.prototype["delete"] = function(callbacks) {
    var deleteCallbacks, request,
      _this = this;

    _thisGroup = this;
    root.Kii.logger("Deleting group: " + this._groupName);
    request = this._getRequest({
      path: "/groups/" + this._uuid,
      withApp: true
    });
    request.setMethod("DELETE");
    deleteCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
          return callbacks.success(_thisGroup);
        } else if (callbacks != null) {
          return callbacks.failure(_thisGroup, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisGroup, error);
        }
      }
    };
    return request.execute(deleteCallbacks, true);
  };

  /** Gets the owner of the associated group
  
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful add request
  @param {Method} callbacks.failure The callback method to call on a failed add request
  @example 
  var group = . . .; // a KiiGroup
  group.getOwner({
      success: function(theGroup, theOwner) {
          // do something
      },
  
      failure: function(theGroup, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiGroup.prototype.getOwner = function(member, callbacks) {
    var _this = this;

    _thisGroup = this;
    root.Kii.logger("Getting owner of group " + this._groupName);
    return this.refresh({
      success: function(group) {
        if (callbacks != null) {
          return callbacks.success(group, group.getOwner());
        }
      },
      failure: function(group, error) {
        if (callbacks != null) {
          return callbacks.failure(group, error);
        }
      }
    });
  };

  /** Creates a reference to a group with the given name
  @param {String} groupName An application-specific group name
  @returns {KiiGroup} A new KiiGroup reference
  @example
  var group = new KiiGroup.groupWithName("myGroup");
  */


  KiiGroup.groupWithName = function(groupName) {
    return root.KiiGroup.groupWithNameAndMembers(groupName, null);
  };

  /** Creates a reference to a group with the given name and a list of default members
  @param {String} groupName An application-specific group name
  @param {Array} members An array of KiiUser objects to add to the group
  @returns {KiiGroup} A new KiiGroup reference
  @example
  var group = new KiiGroup.groupWithName("myGroup", members);
  */


  KiiGroup.groupWithNameAndMembers = function(groupName, members) {
    var group;

    group = new root.KiiGroup();
    group._setName(groupName);
    group._setAddMembers(members);
    return group;
  };

  /** Generate a new KiiGroup based on a given URI
  @param {String} uri The URI of the group to be represented
  @returns {KiiGroup} A new KiiGroup with its parameters filled in from the URI
  @throws {InvalidURIException} If the URI given is invalid
  @example
  var group = new KiiGroup.groupWithURI("kiicloud://myuri");
  */


  KiiGroup.groupWithURI = function(uri) {
    var compLength, components, group, newURI;

    group = null;
    newURI = uri.substr("kiicloud://".length);
    components = newURI.split("/");
    compLength = components.length;
    if (compLength > 0) {
      group = new root.KiiGroup();
      group._setUUID(components[compLength - 1]);
    } else {
      throw new root.InvalidURIException;
    }
    return group;
  };

  KiiGroup._groupWithID = function(id) {
    var group;

    group = new root.KiiGroup();
    group._setUUID(id);
    return group;
  };

  KiiGroup._groupWithJSON = function(json) {
    var group;

    group = new root.KiiGroup();
    if (json.groupID != null) {
      group._setUUID(json.groupID);
    }
    if (json.name != null) {
      group._setName(json.name);
    }
    if (json.owner != null) {
      group._setOwner(root.KiiUser._userWithID(json.owner));
    }
    return group;
  };

  KiiGroup.prototype._getRequest = function(spec) {
    var path, request, withApp;

    path = spec.path;
    withApp = spec.withApp;
    request = new KiiRequest(path, withApp);
    return request;
  };

  KiiGroup.prototype._userWithID = function(id) {
    var user;

    user = root.KiiUser._userWithID(id);
    return user;
  };

  KiiGroup.prototype._setOwnerFromContext = function(data) {
    if (root.Kii.getCurrentUser() != null) {
      this._owner = root.Kii.getCurrentUser();
      return data.owner = this._owner.getUUID();
    }
  };

  return KiiGroup;

}).call(this);

/**
    @class Represents a KiiObject object
    @exports root.KiiObject as KiiObject
*/


root.KiiObject = (function() {
  var _bucket, _created, _customInfo, _modified, _objectType, _owner, _thisObject, _uuid;

  _thisObject = null;

  KiiObject.prototype._alteredFields = [];

  _uuid = null;

  _created = null;

  _modified = null;

  _objectType = null;

  _customInfo = null;

  _bucket = null;

  _owner = null;

  /** Get the UUID of the given object, assigned by the server
  @returns {String}
  */


  KiiObject.prototype.getUUID = function() {
    return this._uuid;
  };

  KiiObject.prototype._setUUID = function(_uuid) {
    this._uuid = _uuid;
  };

  /** Get the server's creation date of this object
  @returns {String}
  */


  KiiObject.prototype.getCreated = function() {
    return this._created;
  };

  KiiObject.prototype._setCreated = function(_created) {
    this._created = _created;
  };

  /** Get the modified date of the given object, assigned by the server 
  @returns {String}
  */


  KiiObject.prototype.getModified = function() {
    return this._modified;
  };

  KiiObject.prototype._setModified = function(_modified) {
    this._modified = _modified;
  };

  /** Get the application-defined type name of the object
  @returns {String}
  */


  KiiObject.prototype.getObjectType = function() {
    return this._objectType;
  };

  KiiObject.prototype._setObjectType = function(_objectType) {
    this._objectType = _objectType;
  };

  KiiObject.prototype.getBucket = function() {
    root.Kii.logger("GEtting bucket " + this._bucket);
    return this._bucket;
  };

  KiiObject.prototype._setBucket = function(_bucket) {
    this._bucket = _bucket;
  };

  function KiiObject() {
    this._userWithID = __bind(this._userWithID, this);
    this._getRequest = __bind(this._getRequest, this);
    this["delete"] = __bind(this["delete"], this);
    this.refresh = __bind(this.refresh, this);
    this.save = __bind(this.save, this);
    this.saveAllFields = __bind(this.saveAllFields, this);
    this._performSave = __bind(this._performSave, this);
    this._updateWithJSON = __bind(this._updateWithJSON, this);
    this.objectURI = __bind(this.objectURI, this);
    this.objectACL = __bind(this.objectACL, this);
    this.get = __bind(this.get, this);
    this.set = __bind(this.set, this);
    this._getPath = __bind(this._getPath, this);
    this._setBucket = __bind(this._setBucket, this);
    this.getBucket = __bind(this.getBucket, this);
    this._setObjectType = __bind(this._setObjectType, this);
    this.getObjectType = __bind(this.getObjectType, this);
    this._setModified = __bind(this._setModified, this);
    this.getModified = __bind(this.getModified, this);
    this._setCreated = __bind(this._setCreated, this);
    this.getCreated = __bind(this.getCreated, this);
    this._setUUID = __bind(this._setUUID, this);
    this.getUUID = __bind(this.getUUID, this);    this._customInfo = {};
  }

  KiiObject.prototype._getPath = function() {
    var path;

    if (this._bucket.getUser() != null) {
      path = "/users/" + (this._bucket.getUser().getUUID()) + "/buckets/" + (this._bucket.getBucketName()) + "/objects/";
    } else if (this._bucket.getGroup() != null) {
      path = "/groups/" + (this._bucket.getGroup().getUUID()) + "/buckets/" + (this._bucket.getBucketName()) + "/objects/";
    } else {
      path = "/buckets/" + (this._bucket.getBucketName()) + "/objects/";
    }
    if (this._uuid != null) {
      path += this._uuid;
    }
    return path;
  };

  /** Sets a key/value pair to a KiiObject
  
  <br><br>If the key already exists, its value will be written over. If the object is of invalid type, it will return false and a KiiError will be thrown (quietly). Accepted types are any JSON-encodable objects.
  <br><b>NOTE: Before involving floating point value, please consider using integer instead. For example, use percentage, permil, ppm, etc.</br></b>
  The reason is:
   <li>Will dramatically improve the performance of bucket query.</li>
   <li>Bucket query does not support the mixed result of integer and floating point.
   ex.) If you use same key for integer and floating point and inquire object with the integer value, objects which has floating point value with the key would not be evaluated in the query. (and vice versa)</li> 
  @param {String} key The key to set. The key must not be a system key (created, metadata, modified, type, uuid) or begin with an underscore (_)
  @param {Object} value The value to be set. Object must be of a JSON-encodable type (Ex: dictionary, array, string, number, etc)
  @example 
  var obj = . . .; // a KiiObject
  obj.set("score", 4298);
  */


  KiiObject.prototype.set = function(key, value) {
    this._customInfo[key] = value;
    return this._alteredFields.push(key);
  };

  /** Gets the value associated with the given key
  @param {String} key The key to retrieve
  @returns {Object} The object associated with the key. null if none exists
  @example 
  var obj = . . .; // a KiiObject
  var score = obj.get("score");
  */


  KiiObject.prototype.get = function(key) {
    return this._customInfo[key];
  };

  /** Get the ACL handle for this file
  
  <br><br>Any KiiACLEntry objects added or revoked from this ACL object will be appended to/removed from the server on ACL save. 
  	@returns {KiiACL} A KiiACL object associated with this KiiObject
  	@example 
  	var obj = . . .; // a KiiObject
  	var acl = obj.objectACL();
  */


  KiiObject.prototype.objectACL = function() {
    return root.KiiACL.aclWithParent(this);
  };

  /** Get a specifically formatted string referencing the object
  
  <br><br>The object must exist in the cloud (have a valid UUID).
  @returns {String} A URI string based on the current object. null if a URI couldn't be generated.
  @example 
  var obj = . . .; // a KiiObject
  var uri = obj.objectURI();
  */


  KiiObject.prototype.objectURI = function() {
    var base, uri;

    base = "kiicloud://";
    if ((this._bucket != null) && (this._uuid != null)) {
      uri = base;
      if (this._bucket.getGroup() != null) {
        uri += "groups/" + (this._bucket.getGroup().getUUID()) + "/";
      } else if (this._bucket.getUser() != null) {
        uri += "users/" + (this._bucket.getUser().getUUID()) + "/";
      }
      uri += "buckets/" + (this._bucket.getBucketName()) + "/objects/" + this._uuid;
    }
    return uri;
  };

  KiiObject.prototype._updateWithJSON = function(json) {
    var key, val, _results;

    _results = [];
    for (key in json) {
      val = json[key];
      if (key === "objectID" || key === "_id" || key === "uuid") {
        root.Kii.logger("Setting uuid: " + val);
        _results.push(this._uuid = val);
      } else if (key === "createdAt" || key === "_created" || key === "created") {
        _results.push(this._created = val);
      } else if (key === "modifiedAt" || key === "_modified" || key === "modified") {
        _results.push(this._modified = val);
      } else if (key === "_owner") {
        _results.push(this._owner = this._userWithID(val));
      } else if (key === "_dataType") {
        _results.push(this._objectType = val);
      } else if (key[0] !== "_") {
        _results.push(this._customInfo[key] = val);
      } else {
        _results.push(void 0);
      }
    }
    return _results;
  };

  KiiObject.prototype._performSave = function(allFields, callbacks) {
    var data, key, path, request, saveCallbacks, _i, _len, _ref,
      _this = this;

    _thisObject = this;
    path = this._getPath();
    request = new this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod(this._uuid != null ? "PUT" : "POST");
    data = {};
    if (allFields) {
      data = this._customInfo;
    } else {
      _ref = this._alteredFields;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        key = _ref[_i];
        data[key] = this._customInfo[key];
      }
    }
    request.setData(data);
    if (this._objectType != null) {
      request.setContentType("application/vnd." + (root.Kii.getAppID()) + "." + this._objectType + "+json");
    }
    if ((this._uuid != null) && !allFields) {
      request.addHeader("X-HTTP-Method-Override", "PATCH");
      request.setMethod("POST");
    }
    saveCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200) {
          _thisObject._updateWithJSON(data);
          _thisObject._alteredFields = [];
          if (callbacks != null) {
            return callbacks.success(_thisObject);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisObject, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisObject, error);
        }
      }
    };
    return request.execute(saveCallbacks, false);
  };

  /** Saves the latest object values to the server
  
  <br><br>If the object does not yet exist, it will be created. If the object already exists, all fields will be removed or changed to match the local values. 
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful save request
  @param {Method} callbacks.failure The callback method to call on a failed save request
  @example 
  var obj = . . .; // a KiiObject
  obj.saveAllFields({
      success: function(theSavedObject) {
          // do something with the saved object
      },
      
      failure: function(theObject, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiObject.prototype.saveAllFields = function(callbacks) {
    return this._performSave(true, callbacks);
  };

  /** Saves the latest object values to the server
  
  <br><br>If the object does not yet exist, it will be created. If the object already exists, the fields that have changed will be updated accordingly.
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful save request
  @param {Method} callbacks.failure The callback method to call on a failed save request
  @example 
  var obj = . . .; // a KiiObject
  obj.save({
      success: function(theSavedObject) {
          // do something with the saved object
      },
      
      failure: function(theObject, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiObject.prototype.save = function(callbacks) {
    return this._performSave(false, callbacks);
  };

  /** Updates the local object's data with the user data on the server
  
  <br><br>The object must exist on the server. Local data will be overwritten.    	
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful refresh request
  @param {Method} callbacks.failure The callback method to call on a failed refresh request
  @example 
  var obj = . . .; // a KiiObject
  obj.refresh({
      success: function(theRefreshedObject) {
          // do something with the refreshed object
      },
  
      failure: function(theObject, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiObject.prototype.refresh = function(callbacks) {
    var path, refreshCallbacks, request,
      _this = this;

    _thisObject = this;
    path = this._getPath();
    request = new this._getRequest({
      path: path,
      withApp: true
    });
    refreshCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200) {
          _thisObject._updateWithJSON(data);
          if (callbacks != null) {
            return callbacks.success(_thisObject);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisObject, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisObject, error);
        }
      }
    };
    return request.execute(refreshCallbacks, false);
  };

  /** Delete the object from the server
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful delete request
  @param {Method} callbacks.failure The callback method to call on a failed delete request
  @example 
  var obj = . . .; // a KiiObject
  obj.delete({
      success: function(theDeletedObject) {
          // do something
      },
      
      failure: function(theObject, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiObject.prototype["delete"] = function(callbacks) {
    var path, refreshCallbacks, request,
      _this = this;

    _thisObject = this;
    path = this._getPath();
    request = new this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod("DELETE");
    refreshCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
          return callbacks.success(_thisObject);
        } else if (callbacks != null) {
          return callbacks.failure(_thisObject, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisObject, error);
        }
      }
    };
    return request.execute(refreshCallbacks, true);
  };

  KiiObject.objectWithBucket = function(bucket, type) {
    var obj;

    root.Kii.logger("Creating object w type: " + type);
    obj = new root.KiiObject;
    obj._setBucket(bucket);
    obj._setObjectType(type);
    root.Kii.logger(obj);
    return obj;
  };

  /** Generate a new KiiObject based on a given URI
  @param {String} uri The URI of the object to be represented
  @returns {KiiObject} A new KiiObject with its parameters filled in from the URI
  @throws {InvalidURIException} If the URI is not in the proper format
  @example
  var group = new KiiObject.objectWithURI("kiicloud://myuri");
  */


  KiiObject.objectWithURI = function(uri) {
    var bucket, bucketIndex, bucketName, compLength, components, group, newURI, obj, subject, user;

    newURI = uri.substr("kiicloud://".length);
    components = newURI.split("/");
    compLength = components.length;
    root.Kii.logger(components);
    if (compLength >= 4) {
      bucketIndex = compLength === 4 ? 1 : 3;
      bucketName = components[bucketIndex];
      if (components[0] === "groups") {
        group = new root.KiiGroup._groupWithID(components[1]);
      } else if (components[0] === "users") {
        user = root.KiiUser._userWithID(components[1]);
      }
      subject = null;
      if (group != null) {
        subject = group;
      } else if (user != null) {
        subject = user;
      }
      bucket = new root.KiiBucket._bucketWithName(bucketName, subject);
      root.Kii.logger(bucket);
      obj = bucket.createObject();
      obj._setUUID(components[compLength - 1]);
      root.Kii.logger(obj);
    } else {
      throw new root.InvalidURIException;
    }
    return obj;
  };

  KiiObject.prototype._getRequest = function(spec) {
    var path, request, withApp;

    path = spec.path;
    withApp = spec.withApp;
    request = new KiiRequest(path, withApp);
    return request;
  };

  KiiObject.prototype._userWithID = function(id) {
    var user;

    user = root.KiiUser._userWithID(id);
    return user;
  };

  return KiiObject;

}).call(this);

/**
    @class Represents a KiiQuery object
    @exports root.KiiQuery as KiiQuery
*/


root.KiiQuery = (function() {
  var _clause, _cursor, _limit, _paginationKey, _sortDescending, _sortField, _sortString;

  function KiiQuery() {
    this._dictValue = __bind(this._dictValue, this);
    this.sortByAsc = __bind(this.sortByAsc, this);
    this.sortByDesc = __bind(this.sortByDesc, this);
    this.setLimit = __bind(this.setLimit, this);
    this.getLimit = __bind(this.getLimit, this);
    this._setClause = __bind(this._setClause, this);
    this.setPaginationKey = __bind(this.setPaginationKey, this);
    this.getPaginationKey = __bind(this.getPaginationKey, this);
  }

  _sortString = null;

  _cursor = null;

  _paginationKey = null;

  _sortDescending = false;

  _sortField = null;

  _limit = 25;

  _clause = null;

  KiiQuery.prototype.getPaginationKey = function() {
    return this._paginationKey;
  };

  KiiQuery.prototype.setPaginationKey = function(_paginationKey) {
    this._paginationKey = _paginationKey;
  };

  KiiQuery.prototype._setClause = function(_clause) {
    this._clause = _clause;
  };

  /** Get the limit of the current query
  @returns {Integer}
  */


  KiiQuery.prototype.getLimit = function() {
    return this._limit;
  };

  /** Set the limit of the given query
  @param value The desired limit. Must be an integer > 0
  @throws InvalidLimitException
  */


  KiiQuery.prototype.setLimit = function(value) {
    if (value > 0) {
      return this._limit = value;
    } else {
      throw new root.InvalidLimitException;
    }
  };

  /** Create a KiiQuery object based on a KiiClause
  <br><br>
  By passing null as the ‘clause’ parameter, all objects can be retrieved.
  @param clause The KiiClause to be executed with the query
  */


  KiiQuery.queryWithClause = function(clause) {
    var query;

    query = new root.KiiQuery();
    query._setClause(clause);
    return query;
  };

  /** Set the query to sort by a field in descending order
  
  If a sort has already been set, it will be overwritten.
  @param {String} field The key that should be used to sort
  */


  KiiQuery.prototype.sortByDesc = function(_sortField) {
    this._sortField = _sortField;
    return this._sortDescending = true;
  };

  /** Set the query to sort by a field in ascending order
  
  If a sort has already been set, it will be overwritten.
  @param {String} field The key that should be used to sort
  */


  KiiQuery.prototype.sortByAsc = function(_sortField) {
    this._sortField = _sortField;
    return this._sortDescending = false;
  };

  KiiQuery._emptyDictValue = function() {
    return {
      type: "all"
    };
  };

  KiiQuery.prototype._dictValue = function() {
    var data;

    data = {
      descending: this._sortDescending
    };
    if (this._clause != null) {
      data.clause = this._clause._getDictValue();
    } else {
      data.clause = root.KiiQuery._emptyDictValue();
    }
    if (this._sortField != null) {
      data.orderBy = this._sortField;
    }
    return data;
  };

  return KiiQuery;

}).call(this);

/**
    @class Represents a KiiClause expression object
    @exports root.KiiClause as KiiClause
*/


root.KiiClause = (function() {
  var _dictExpression, _whereClauses, _whereType;

  function KiiClause() {
    this._getDictValue = __bind(this._getDictValue, this);
    this._setDictValue = __bind(this._setDictValue, this);
    this._setWhereClauses = __bind(this._setWhereClauses, this);
    this._setWhereType = __bind(this._setWhereType, this);
  }

  _dictExpression = null;

  _whereType = null;

  _whereClauses = null;

  KiiClause.constructor = function() {
    KiiClause._whereClauses = [];
    return KiiClause._dictExpression = {};
  };

  KiiClause.prototype._setWhereType = function(_whereType) {
    this._whereType = _whereType;
  };

  KiiClause.prototype._setWhereClauses = function(_whereClauses) {
    this._whereClauses = _whereClauses;
  };

  KiiClause.prototype._setDictValue = function(_dictExpression) {
    this._dictExpression = _dictExpression;
  };

  KiiClause.prototype._getDictValue = function() {
    var clause, clauses, retDict, _i, _len, _ref;

    retDict = {};
    if ((this._whereClauses != null) && (this._whereType != null)) {
      clauses = [];
      if (this._whereClauses.length === 1) {
        clause = this._whereClauses[0];
        if (this._whereType === "not") {
          retDict = {
            "type": this._whereType,
            "clause": clause._getDictValue()
          };
        } else {
          retDict = clause._getDictValue();
        }
      } else {
        _ref = this._whereClauses;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          clause = _ref[_i];
          clauses.push(clause._getDictValue());
        }
        retDict = {
          "type": this._whereType,
          "clauses": clauses
        };
      }
    } else if (this._whereClauses != null) {
      if (this._whereClauses.length > 0) {
        retDict = this._whereClauses[0]._getDictValue();
      }
    } else if (this._dictExpression != null) {
      retDict = this._dictExpression;
    }
    if (retDict == null) {
      retDict = root.KiiQuery.emptyDictValue();
    }
    return retDict;
  };

  KiiClause.createWithWhere = function(whereType, whereClauses) {
    var expression;

    expression = new root.KiiClause();
    expression._setWhereType(whereType);
    expression._setWhereClauses(whereClauses);
    return expression;
  };

  KiiClause.create = function(operator, key, value) {
    var expression, _dict;

    expression = new root.KiiClause();
    _dict = {};
    if (operator === "=") {
      _dict.type = "eq";
      _dict.field = key;
      _dict.value = value;
    } else if (operator === "<") {
      _dict.type = "range";
      _dict.field = key;
      _dict.upperLimit = value;
      _dict.upperIncluded = false;
    } else if (operator === "<=") {
      _dict.type = "range";
      _dict.field = key;
      _dict.upperLimit = value;
      _dict.upperIncluded = true;
    } else if (operator === ">") {
      _dict.type = "range";
      _dict.field = key;
      _dict.lowerLimit = value;
      _dict.lowerIncluded = false;
    } else if (operator === ">=") {
      _dict.type = "range";
      _dict.field = key;
      _dict.lowerLimit = value;
      _dict.lowerIncluded = true;
    } else if (operator === "in") {
      _dict.type = "in";
      _dict.field = key;
      _dict.values = value;
    } else if (operator === "prefix") {
      _dict.type = "prefix";
      _dict.field = key;
      _dict.prefix = value;
    }
    expression._setDictValue(_dict);
    return expression;
  };

  /** Create a KiiClause with the AND operator concatenating multiple KiiClause objects
  @param {List} A variable-length list of KiiClause objects to concatenate
  @example
  KiiClause clause = KiiClause.and(clause1, clause2, clause3, . . .)
  */


  KiiClause.and = function() {
    return KiiClause.createWithWhere("and", arguments);
  };

  /** Create a KiiClause with the OR operator concatenating multiple KiiClause objects
  @param {List} A variable-length list of KiiClause objects to concatenate
  @example
  KiiClause clause = KiiClause.or(clause1, clause2, clause3, . . .)
  */


  KiiClause.or = function() {
    return KiiClause.createWithWhere("or", arguments);
  };

  /** Create an expression of the form (key == value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.equals = function(key, value) {
    if (value._className != null) {
      value = value.objectURI;
    }
    return root.KiiClause.create("=", key, value);
  };

  /** Create an expression of the form (key != value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.notEquals = function(key, value) {
    if (value._className != null) {
      value = value.objectURI;
    }
    return root.KiiClause.createWithWhere("not", [root.KiiClause.equals(key, value)]);
  };

  /** Create an expression of the form (key > value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.greaterThan = function(key, value) {
    return root.KiiClause.create(">", key, value);
  };

  /** Create an expression of the form (key >= value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.greaterThanOrEqual = function(key, value) {
    return root.KiiClause.create(">=", key, value);
  };

  /** Create an expression of the form (key < value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.lessThan = function(key, value) {
    return root.KiiClause.create("<", key, value);
  };

  /** Create an expression of the form (key <= value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.lessThanOrEqual = function(key, value) {
    return root.KiiClause.create("<=", key, value);
  };

  /** Create an expression of the form (key in values)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause["in"] = function(key, values) {
    return root.KiiClause.create("in", key, values);
  };

  /** Create an expression of the form (key STARTS WITH value)
  @param {String} key The key to compare
  @param {Object} value the value to compare
  */


  KiiClause.startsWith = function(key, value) {
    return root.KiiClause.create("prefix", key, value);
  };

  return KiiClause;

}).call(this);

KiiRequest = (function() {
  var _adminToken, _thisRequest;

  _thisRequest = null;

  KiiRequest._path = null;

  KiiRequest._method = null;

  KiiRequest._headers = null;

  KiiRequest._data = null;

  KiiRequest._contentType = null;

  KiiRequest._anonymous = false;

  KiiRequest._accept = null;

  KiiRequest._success = null;

  KiiRequest._failure = null;

  _adminToken = null;

  KiiRequest.prototype.getPath = function() {
    return this._path;
  };

  KiiRequest.prototype.setPath = function(_path) {
    this._path = _path;
  };

  KiiRequest.prototype.getMethod = function() {
    return this._method;
  };

  KiiRequest.prototype.setMethod = function(_method) {
    this._method = _method;
  };

  KiiRequest.prototype.getHeaders = function() {
    return this._headers;
  };

  KiiRequest.prototype.setHeaders = function(_headers) {
    this._headers = _headers;
  };

  KiiRequest.prototype.getData = function() {
    return this._data;
  };

  KiiRequest.prototype.setData = function(_data) {
    this._data = _data;
  };

  KiiRequest.prototype.getContentType = function() {
    return this._contentType;
  };

  KiiRequest.prototype.setContentType = function(_contentType) {
    this._contentType = _contentType;
  };

  KiiRequest.prototype.isAnonymous = function() {
    return this._anonymous;
  };

  KiiRequest.prototype.setAnonymous = function(_anonymous) {
    this._anonymous = _anonymous;
  };

  KiiRequest.prototype.getAccept = function() {
    return this._accept;
  };

  KiiRequest.prototype.setAccept = function(_accept) {
    this._accept = _accept;
  };

  KiiRequest.prototype.addHeader = function(name, value) {
    return this._headers[name] = value;
  };

  KiiRequest.prototype.setAdminToken = function(token) {
    return this._adminToken = token;
  };

  function KiiRequest(path, withApp) {
    this.execute = __bind(this.execute, this);
    this.setAdminToken = __bind(this.setAdminToken, this);
    this.addHeader = __bind(this.addHeader, this);
    this.setAccept = __bind(this.setAccept, this);
    this.getAccept = __bind(this.getAccept, this);
    this.setAnonymous = __bind(this.setAnonymous, this);
    this.isAnonymous = __bind(this.isAnonymous, this);
    this.setContentType = __bind(this.setContentType, this);
    this.getContentType = __bind(this.getContentType, this);
    this.setData = __bind(this.setData, this);
    this.getData = __bind(this.getData, this);
    this.setHeaders = __bind(this.setHeaders, this);
    this.getHeaders = __bind(this.getHeaders, this);
    this.setMethod = __bind(this.setMethod, this);
    this.getMethod = __bind(this.getMethod, this);
    this.setPath = __bind(this.setPath, this);
    this.getPath = __bind(this.getPath, this);
    var _this = this;

    _thisRequest = this;
    this._path = withApp ? "/apps/" + (root.Kii.getAppID()) + path : path;
    this._method = "GET";
    this._headers = {
      "accept": "*/*"
    };
    this._contentType = "application/json";
    this._anonymous = false;
    this._success = function() {};
    this._failure = function() {};
  }

  KiiRequest.prototype.execute = function(callbacks, ignoreBody) {
    var ajaxData, json_text, key, postData, url, val, _ref,
      _this = this;

    this._success = callbacks.success != null ? callbacks.success : this._success;
    this._failure = callbacks.failure != null ? callbacks.failure : this._failure;
    url = root.Kii.getBaseURL() + this._path;
    root.Kii.logger("POSTING: ");
    root.Kii.logger(this._data);
    if (this._data != null) {
      postData = {};
    }
    _ref = this._data;
    for (key in _ref) {
      val = _ref[key];
      postData[key] = encodeURIComponent(val);
    }
    json_text = JSON.stringify(this._data);
    root.Kii.logger("Making request[" + this._method + "] to " + url + " with data: " + json_text);
    this._headers['x-kii-appid'] = root.Kii.getAppID();
    this._headers['x-kii-appkey'] = root.Kii.getAppKey();
    if (this._accept != null) {
      this._headers['accept'] = this._accept;
    }
    if (!this._anonymous && (root.KiiUser.getCurrentUser() != null)) {
      this._headers['Authorization'] = "Bearer " + (root.KiiUser.getCurrentUser().getAccessToken());
    }
    if (this._adminToken != null) {
      this._headers['Authorization'] = "Bearer " + this._adminToken;
    }
    root.Kii.logger("Headers: ");
    root.Kii.logger(this._headers);
    $.support.cors = true;
    ajaxData = {
      type: this._method,
      url: url,
      dataType: "json",
      headers: this._headers,
      contentType: this._contentType,
      error: function(xhr, status, error) {
        var errString, json;

        if (error) {
          errString = error;
        } else {
          errString = status + " : " + url;
        }
        try {
          json = jQuery.parseJSON(decodeURIComponent(xhr.responseText));
        } catch (_error) {
          error = _error;
          json = null;
        }
        if (json != null) {
          if (json.errorCode != null) {
            errString = json.errorCode;
            if (json.message != null) {
              errString += ": " + json.message;
            }
          }
        }
        root.Kii.logger("Failure: " + errString);
        root.Kii.logger(xhr.responseText);
        return _thisRequest._failure(errString, xhr.status);
      },
      success: function(data, status, xhr) {
        var e, errString, json;

        root.Kii.logger("Completed Request[" + xhr.status + "]");
        root.Kii.logger(xhr.responseText);
        if (ignoreBody) {
          return _thisRequest._success(null, xhr.status);
        } else {
          try {
            json = jQuery.parseJSON(xhr.responseText);
          } catch (_error) {
            e = _error;
            json = null;
          }
          if (json != null) {
            if (json.errorCode != null) {
              errString = json.errorCode;
              if (json.message != null) {
                errString += ": " + json.message;
              }
              return _thisRequest._failure(errString, xhr.status, json.errorCode);
            } else {
              return _thisRequest._success(json, xhr.status);
            }
          } else {
            return _thisRequest._success(null, xhr.status, null);
          }
        }
      }
    };
    if (this._method !== "GET" && (json_text != null)) {
      ajaxData.data = json_text;
      ajaxData.processData = false;
    }
    return $.ajax(ajaxData);
  };

  return KiiRequest;

})();

/**
    @class Represents a KiiUser object
    @exports root.KiiUser as KiiUser
*/


root.KiiUser = (function() {
  var _accessToken, _country, _created, _customInfo, _displayName, _emailAddress, _emailVerified, _modified, _password, _phoneNumber, _phoneVerified, _thisUser, _username, _uuid;

  _thisUser = null;

  _uuid = null;

  _username = null;

  _displayName = null;

  _password = null;

  _emailAddress = null;

  _phoneNumber = null;

  _country = null;

  _created = null;

  _modified = null;

  _emailVerified = null;

  _phoneVerified = null;

  _accessToken = null;

  _customInfo = null;

  function KiiUser() {
    this._getRequest = __bind(this._getRequest, this);
    this._updateWithJSON = __bind(this._updateWithJSON, this);
    this["delete"] = __bind(this["delete"], this);
    this.refresh = __bind(this.refresh, this);
    this.save = __bind(this.save, this);
    this.changeEmail = __bind(this.changeEmail, this);
    this.changePhone = __bind(this.changePhone, this);
    this.memberOfGroups = __bind(this.memberOfGroups, this);
    this.resendPhoneNumberVerification = __bind(this.resendPhoneNumberVerification, this);
    this.resendEmailVerification = __bind(this.resendEmailVerification, this);
    this.resendVerification = __bind(this.resendVerification, this);
    this.verifyPhoneNumber = __bind(this.verifyPhoneNumber, this);
    this.verifyCredentials = __bind(this.verifyCredentials, this);
    this.updatePassword = __bind(this.updatePassword, this);
    this.register = __bind(this.register, this);
    this._authenticateWithToken = __bind(this._authenticateWithToken, this);
    this._authenticate = __bind(this._authenticate, this);
    this.bucketWithName = __bind(this.bucketWithName, this);
    this.get = __bind(this.get, this);
    this.set = __bind(this.set, this);
    this.objectURI = __bind(this.objectURI, this);
    this._setAccessToken = __bind(this._setAccessToken, this);
    this.getAccessToken = __bind(this.getAccessToken, this);
    this._setPhoneVerified = __bind(this._setPhoneVerified, this);
    this.getPhoneVerified = __bind(this.getPhoneVerified, this);
    this._setEmailVerified = __bind(this._setEmailVerified, this);
    this.getEmailVerified = __bind(this.getEmailVerified, this);
    this._setModified = __bind(this._setModified, this);
    this.getModified = __bind(this.getModified, this);
    this._setCreated = __bind(this._setCreated, this);
    this.getCreated = __bind(this.getCreated, this);
    this.setCountry = __bind(this.setCountry, this);
    this.getCountry = __bind(this.getCountry, this);
    this._setPassword = __bind(this._setPassword, this);
    this._setPhoneNumber = __bind(this._setPhoneNumber, this);
    this.getPhoneNumber = __bind(this.getPhoneNumber, this);
    this._setEmailAddress = __bind(this._setEmailAddress, this);
    this.getEmailAddress = __bind(this.getEmailAddress, this);
    this._validateDisplayName = __bind(this._validateDisplayName, this);
    this.setDisplayName = __bind(this.setDisplayName, this);
    this.getDisplayName = __bind(this.getDisplayName, this);
    this._setUsername = __bind(this._setUsername, this);
    this.getUsername = __bind(this.getUsername, this);
    this._setUUID = __bind(this._setUUID, this);
    this.getUUID = __bind(this.getUUID, this);    this._customInfo = {};
  }

  /** Get the UUID of the given user, assigned by the server
  @returns {String}
  */


  KiiUser.prototype.getUUID = function() {
    return this._uuid;
  };

  KiiUser.prototype._setUUID = function(_uuid) {
    this._uuid = _uuid;
  };

  /** Get the username of the given user 
  @returns {String}
  */


  KiiUser.prototype.getUsername = function() {
    return this._username;
  };

  KiiUser.prototype._setUsername = function(value) {
    root.Kii.logger("Setting username: " + value);
    if (KiiUtilities._validateUsername(value)) {
      return this._username = $.trim(value);
    } else {
      throw new root.InvalidUsernameException;
    }
  };

  /** Get the display name associated with this user
  @returns {String}
  */


  KiiUser.prototype.getDisplayName = function() {
    return this._displayName;
  };

  /** Set the display name associated with this user. Cannot be used for logging a user in; is non-unique
  @param {String} value Must be between 4-50 alphanumeric characters, must start with a letter
  @throws {InvalidDisplayNameException} If the displayName is not a valid format
  */


  KiiUser.prototype.setDisplayName = function(value) {
    this._validateDisplayName(value);
    return this._displayName = value;
  };

  KiiUser.prototype._validateDisplayName = function(value) {
    if (typeof value === !'string') {
      throw new root.InvalidDisplayNameException;
    }
    if (4 > value.length || value.length > 50) {
      throw new root.InvalidDisplayNameException;
    }
  };

  /** Get the email address associated with this user
  @returns {String}
  */


  KiiUser.prototype.getEmailAddress = function() {
    return this._emailAddress;
  };

  KiiUser.prototype._setEmailAddress = function(value) {
    root.Kii.logger("Setting email: " + value);
    if (KiiUtilities._validateEmail(value)) {
      return this._emailAddress = $.trim(value);
    } else {
      throw new root.InvalidEmailException;
    }
  };

  /** Get the phone number associated with this user
  @returns {String}
  */


  KiiUser.prototype.getPhoneNumber = function() {
    return this._phoneNumber;
  };

  KiiUser.prototype._setPhoneNumber = function(value) {
    root.Kii.logger("Setting phone number: " + value);
    if (KiiUtilities._validatePhoneNumber(value)) {
      return this._phoneNumber = value;
    } else {
      throw new root.InvalidPhoneNumberException;
    }
  };

  KiiUser.prototype._setPassword = function(value) {
    if (KiiUtilities._validatePassword(value)) {
      return this._password = value;
    } else {
      throw new root.InvalidPasswordException;
    }
  };

  /** Get the country code associated with this user
  @returns {String}
  */


  KiiUser.prototype.getCountry = function() {
    return this._country;
  };

  /** Set the country code associated with this user
  @param {String} value The country code to set. Must be 2 alphabetic characters. Ex: US, JP, CN
  @throws {InvalidCountryException} If the country code is not a valid format
  */


  KiiUser.prototype.setCountry = function(value) {
    if (KiiUtilities._validateCountryCode(value)) {
      return this._country = value;
    } else {
      throw new root.InvalidCountryException;
    }
  };

  /** Get the server's creation date of this user
  @returns {String}
  */


  KiiUser.prototype.getCreated = function() {
    return this._created;
  };

  KiiUser.prototype._setCreated = function(_created) {
    this._created = _created;
  };

  /** Get the modified date of the given user, assigned by the server 
  @returns {String}
  */


  KiiUser.prototype.getModified = function() {
    return this._modified;
  };

  KiiUser.prototype._setModified = function(_modified) {
    this._modified = _modified;
  };

  /** Get the status of the user's email verification. This field is assigned by the server
  @returns {Boolean} true if the user's email address has been verified by the user, false otherwise
  */


  KiiUser.prototype.getEmailVerified = function() {
    return this._emailVerified;
  };

  KiiUser.prototype._setEmailVerified = function(_emailVerified) {
    this._emailVerified = _emailVerified;
  };

  /** Get the status of the user's phone number verification. This field is assigned by the server
  @returns {Boolean} true if the user's email address has been verified by the user, false otherwise
  */


  KiiUser.prototype.getPhoneVerified = function() {
    return this._phoneVerified;
  };

  KiiUser.prototype._setPhoneVerified = function(_phoneVerified) {
    this._phoneVerified = _phoneVerified;
  };

  /** Get the access token for the user - only available if the user is currently logged in
  @returns {String}
  */


  KiiUser.prototype.getAccessToken = function() {
    root.Kii.logger("Getting access token: " + this._accessToken);
    return this._accessToken;
  };

  KiiUser.prototype._setAccessToken = function(_accessToken) {
    this._accessToken = _accessToken;
    return root.Kii.logger("Setting access token: " + this._accessToken);
  };

  /** Get a specifically formatted string referencing the user
  
  <br><br>The user must exist in the cloud (have a valid UUID).
  @returns {String} A URI string based on the given user. null if a URI couldn't be generated.
  @example 
  var user = . . .; // a KiiUser
  var uri = user.objectURI();
  */


  KiiUser.prototype.objectURI = function() {
    var uri;

    if (this._uuid != null) {
      uri = "kiicloud://users/" + this._uuid;
    }
    return uri;
  };

  /** Sets a key/value pair to a KiiUser
  
  <br><br>If the key already exists, its value will be written over. If the object is of invalid type, it will return false and a KiiError will be thrown (quietly). Accepted types are any JSON-encodable objects.
  @param {String} key The key to set. The key must not be a system key (created, metadata, modified, type, uuid) or begin with an underscore (_)
  @param {Object} value The value to be set. Object must be of a JSON-encodable type (Ex: dictionary, array, string, number, etc)
  @example 
  var user = . . .; // a KiiUser
  user.set("score", 4298);
  */


  KiiUser.prototype.set = function(key, value) {
    root.Kii.logger(this);
    root.Kii.logger(this._customInfo);
    return this._customInfo[key] = value;
  };

  /** Gets the value associated with the given key
  @param {String} key The key to retrieve
  @returns {Object} The object associated with the key. null if none exists
  @example 
  var user = . . .; // a KiiUser
  var score = user.get("score");
  */


  KiiUser.prototype.get = function(key) {
    return this._customInfo[key];
  };

  /**
      The currently authenticated user
      
      @returns {KiiUser}
      @example
      var user = KiiUser.getCurrentUser();
  */


  KiiUser.getCurrentUser = function() {
    return root.Kii.getCurrentUser();
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for manipulation. This user will not be authenticated until one of the authentication methods are called on it. It can be treated as any other KiiObject before it is authenticated.
  @param username The user's desired username. Must be between 3 and 64 characters, which can include alphanumeric characters as well as underscores '_', dashes '-' and periods '.'
  @param password The user's password. Must be between 4-50 characters, made up of ascii characters excludes control characters. 
  @returns a working KiiUser object
  @throws {InvalidUsernameException} If the username is not in the proper format
  @throws {InvalidPasswordException} If the password is not in the proper format
  @example 
  var user = KiiUser.userWithUsername("myusername", "mypassword");
  */


  KiiUser.userWithUsername = function(username, password) {
    var user;

    user = new root.KiiUser();
    user._setUsername(username);
    user._setPassword(password);
    return user;
  };

  KiiUser._userWithEmailAddress = function(emailAddress, password) {
    var user;

    user = new root.KiiUser();
    user._setEmailAddress(emailAddress);
    user._setPassword(password);
    return user;
  };

  KiiUser._userWithPhoneNumber = function(phoneNumber, password) {
    var user;

    user = new root.KiiUser();
    user._setPhoneNumber(phoneNumber);
    user._setPassword(password);
    return user;
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for registration. This user will not be authenticated until the registration method is called on it. It can be treated as any other KiiUser before it is registered.
  @param phoneNumber The user's phone number
  @param password The user's password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @throws {InvalidPasswordException} If the password is not in the proper format
  @throws {InvalidPhoneNumberException} If the phone number is not in the proper format
  @returns a working KiiUser object
  @example 
  var user = KiiUser.userWithPhoneNumber("+874012345678", "mypassword");
  */


  KiiUser.userWithPhoneNumber = function(phoneNumber, password) {
    var user;

    user = new root.KiiUser();
    user._setPhoneNumber(phoneNumber);
    user._setPassword(password);
    return user;
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for registration. This user will not be authenticated until the registration method is called on it. It can be treated as any other KiiUser before it is registered.
  @param phoneNumber The user's phone number
  @param username The user's desired username. Must be between 3 and 64 characters, which can include alphanumeric characters as well as underscores '_', dashes '-' and periods '.'
  @param password The user's password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @throws {InvalidUsernameException} If the username is not in the proper format
  @throws {InvalidPasswordException} If the password is not in the proper format
  @throws {InvalidPhoneNumberException} If the phone number is not in the proper format
  @returns a working KiiUser object
  @example 
  var user = KiiUser.userWithPhoneNumberAndUsername("+874012345678", "johndoe", "mypassword");
  */


  KiiUser.userWithPhoneNumberAndUsername = function(phoneNumber, username, password) {
    var user;

    user = new root.KiiUser();
    user._setPhoneNumber(phoneNumber);
    user._setUsername(username);
    user._setPassword(password);
    return user;
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for registration. This user will not be authenticated until the registration method is called on it. It can be treated as any other KiiUser before it is registered.
  @param emailAddress The user's email address
  @param password The user's password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @throws {InvalidPasswordException} If the password is not in the proper format
  @throws {InvalidEmailException} If the email address is not in the proper format
  @returns a working KiiUser object
  @example 
  var user = KiiUser.userWithEmailAddress("johndoe@example.com", "mypassword");
  */


  KiiUser.userWithEmailAddress = function(emailAddress, password) {
    var user;

    user = new root.KiiUser();
    user._setEmailAddress(emailAddress);
    user._setPassword(password);
    return user;
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for registration. This user will not be authenticated until the registration method is called on it. It can be treated as any other KiiUser before it is registered.
  @param emailAddress The user's email address
  @param username The user's desired username. Must be between 3 and 64 characters, which can include alphanumeric characters as well as underscores '_', dashes '-' and periods '.'
  @param password The user's password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @throws {InvalidUsernameException} If the username is not in the proper format
  @throws {InvalidPasswordException} If the password is not in the proper format
  @throws {InvalidEmailException} If the phone number is not in the proper format
  @returns a working KiiUser object
  @example 
  var user = KiiUser.userWithEmailAddressAndUsername("johndoe@example.com", "johndoe", "mypassword");
  */


  KiiUser.userWithEmailAddressAndUsername = function(emailAddress, username, password) {
    var user;

    user = new root.KiiUser();
    user._setEmailAddress(emailAddress);
    user._setUsername(username);
    user._setPassword(password);
    return user;
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for registration. This user will not be authenticated until the registration method is called on it. It can be treated as any other KiiUser before it is registered.
  @param emailAddress The user's email address
  @param phoneNumber The user's phone number
  @param password The user's password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @throws {InvalidPhoneNumberException} If the phone number is not in the proper format
  @throws {InvalidPasswordException} If the password is not in the proper format
  @throws {InvalidEmailException} If the phone number is not in the proper format
  @returns a working KiiUser object
  @example 
  var user = KiiUser.userWithEmailAddressAndPhoneNumber("johndoe@example.com", "+874012345678", "mypassword");
  */


  KiiUser.userWithEmailAddressAndPhoneNumber = function(emailAddress, phoneNumber, password) {
    var user;

    user = new root.KiiUser();
    user._setEmailAddress(emailAddress);
    user._setPhoneNumber(phoneNumber);
    user._setPassword(password);
    return user;
  };

  /** Create a user object to prepare for registration with credentials pre-filled
  
  <br><br>Creates an pre-filled user object for registration. This user will not be authenticated until the registration method is called on it. It can be treated as any other KiiUser before it is registered.
  @param emailAddress The user's email address
  @param phoneNumber The user's phone number
  @param username The user's desired username. Must be between 3 and 64 characters, which can include alphanumeric characters as well as underscores '_', dashes '-' and periods '.'
  @param password The user's password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @throws {InvalidPhoneNumberException} If the phone number is not in the proper format
  @throws {InvalidEmailException} If the phone number is not in the proper format
  @throws {InvalidUsernameException} If the username is not in the proper format
  @throws {InvalidPasswordException} If the password is not in the proper format
  @returns a working KiiUser object
  @example 
  var user = KiiUser.userWithCredentials("johndoe@example.com", "+874012345678", "johndoe", "mypassword");
  */


  KiiUser.userWithCredentials = function(emailAddress, phoneNumber, username, password) {
    var user;

    user = new root.KiiUser();
    user._setEmailAddress(emailAddress);
    user._setPhoneNumber(phoneNumber);
    user._setUsername(username);
    user._setPassword(password);
    return user;
  };

  KiiUser._validateURI = function(value) {
    var match, pattern, retValue;

    value = $.trim(value);
    pattern = /^kiicloud:\/\/users\/([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/i;
    if ((typeof value).toLowerCase() === "string") {
      match = value.match(pattern);
      if (match != null) {
        retValue = match[1];
      }
    }
    return retValue;
  };

  /** Generate a new KiiUser based on a given URI
  @param {String} uri The URI of the object to be represented 
  @returns {KiiUser} A new KiiUser with its parameters filled in from the URI
  @throws {InvalidURIException} If the URI is not in the proper format
  @example
  var user = new KiiUser.userWithURI("kiicloud://myuri");
  */


  KiiUser.userWithURI = function(uri) {
    var user, uuid;

    root.Kii.logger("About to extract from: " + uri);
    uuid = root.KiiUser._validateURI(uri);
    root.Kii.logger("Extracted uuid from uri: " + uuid);
    if (uuid != null) {
      user = new root.KiiUser();
      user._setUUID(uuid);
    } else {
      throw new root.InvalidURIException;
    }
    return user;
  };

  KiiUser._userWithID = function(id) {
    var user;

    user = new root.KiiUser();
    user._setUUID(id);
    return user;
  };

  /** Creates a reference to a bucket for this user
  
  <br><br>The bucket will be created/accessed within this user's scope
  @param {String} bucketName The name of the bucket the user should create/access
  @returns {KiiBucket} A working KiiBucket object
  @example 
  var user = . . .; // a KiiUser
  var bucket = user.bucketWithName("myBucket");
  */


  KiiUser.prototype.bucketWithName = function(bucketName) {
    return new root.KiiBucket._bucketWithName(bucketName, this);
  };

  KiiUser.prototype._authenticate = function(callbacks) {
    var authCallbacks, request, username,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Authenticating user:");
    root.Kii.logger(this);
    root.Kii.logger("Email verified: " + this._emailVerified);
    root.Kii.logger("Phone verified: " + this._phoneVerified);
    if (this._username != null) {
      username = this._username;
    } else if ((this._emailAddress != null) && this._emailVerified === true) {
      username = this._emailAddress;
    } else if ((this._phoneNumber != null) && this._phoneVerified === true) {
      username = this._phoneNumber;
    } else if (this._emailAddress != null) {
      username = this._emailAddress;
    } else if (this._phoneNumber != null) {
      username = this._phoneNumber;
    }
    request = this._getRequest({
      path: "/oauth2/token",
      withApp: false
    });
    request.setAnonymous(true);
    request.setMethod("POST");
    request.setData({
      username: username,
      password: this._password
    });
    authCallbacks = {
      success: function(data) {
        _thisUser._setUUID(data.id);
        _thisUser._setAccessToken(data.access_token);
        root.Kii.setCurrentUser(_thisUser);
        if (callbacks != null) {
          return callbacks.success(root.Kii.getCurrentUser());
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(authCallbacks, false);
  };

  KiiUser.prototype._authenticateWithToken = function(token, callbacks) {
    var authCallbacks, request,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Authenticating user " + this);
    root.Kii.logger(callbacks);
    request = this._getRequest({
      path: "/users/me",
      withApp: true
    });
    request.setAnonymous(true);
    request.addHeader("Authorization", "Bearer " + token);
    authCallbacks = {
      success: function(data) {
        _thisUser._updateWithJSON(data);
        _thisUser._setAccessToken(token);
        root.Kii.setCurrentUser(_thisUser);
        if (callbacks != null) {
          return callbacks.success(root.Kii.getCurrentUser());
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(authCallbacks, false);
  };

  /** Authenticates a user with the server
  @param {String} userIdentifier The username, validated email address, or validated phone number of the user to authenticate
  @param {String} password The password of the user to authenticate
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful authentication request
  @param {Method} callbacks.failure The callback method to call on a failed authentication request
  @example
  KiiUser.authenticate("myusername", "mypassword", {
      success: function(theAuthedUser) {
          // do something with the authenticated user
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.authenticate = function(userIdentifier, password, callbacks) {
    var error, user;

    try {
      root.Kii.logger("UserIdentifier: " + userIdentifier);
      if (!KiiUtilities._validatePassword(password)) {
        throw new root.InvalidPasswordException;
      }
      if (KiiUtilities._validateEmail(userIdentifier)) {
        user = root.KiiUser._userWithEmailAddress(userIdentifier, password);
      } else if (KiiUtilities._validatePhoneNumber(userIdentifier)) {
        user = root.KiiUser._userWithPhoneNumber(userIdentifier, password);
      } else if (KiiUtilities._validateUsername(userIdentifier)) {
        user = root.KiiUser.userWithUsername(userIdentifier, password);
      } else {
        throw new root.InvalidUserIdentifierException;
      }
      return user._authenticate(callbacks);
    } catch (_error) {
      error = _error;
      if (callbacks != null) {
        return callbacks.failure(null, error.message);
      }
    }
  };

  /** Asynchronously authenticates a user with the server using a valid access token
  
  Authenticates a user with the server. This method is non-blocking.
  @param {String} accessToken A valid access token associated with the desired user
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful authentication request
  @param {Method} callbacks.failure The callback method to call on a failed authentication request
  @example
  KiiUser.authenticateWithToken("mytoken", {
      success: function(theAuthedUser) {
          // do something with the authenticated user
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.authenticateWithToken = function(token, callbacks) {
    var user;

    user = new root.KiiUser();
    return user._authenticateWithToken(token, callbacks);
  };

  /** Registers a user with the server
  
  <br><br>The user object must have an associated email/password combination.
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful registration request
  @param {Method} callbacks.failure The callback method to call on a failed registration request
  @example 
  var user = KiiUser.userWithUsername("myusername", "mypassword");
  user.register({
      success: function(theAuthedUser) {
          // do something with the authenticated user
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.register = function(callbacks) {
    var data, key, registrationCallbacks, request, value, _ref,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Registering user " + this);
    data = {
      password: this._password
    };
    if (this._username != null) {
      data.loginName = this._username;
    }
    if (this._displayName != null) {
      data.displayName = this._displayName;
    }
    if (this._emailAddress != null) {
      data.emailAddress = this._emailAddress;
    }
    if (this._phoneNumber != null) {
      data.phoneNumber = this._phoneNumber;
    }
    if (this._country != null) {
      data.country = this._country;
    }
    root.Kii.logger("CINFO");
    root.Kii.logger(this._customInfo);
    _ref = this._customInfo;
    for (key in _ref) {
      value = _ref[key];
      root.Kii.logger("Key/val: " + key + "/" + value);
      data[key] = value;
    }
    request = this._getRequest({
      path: "/users",
      withApp: true
    });
    request.setMethod("POST");
    request.setData(data);
    request.setAnonymous(true);
    request.setContentType("application/vnd.kii.RegistrationRequest+json");
    registrationCallbacks = {
      success: function(data) {
        root.Kii.logger("Succreg");
        _thisUser._updateWithJSON(data);
        return _thisUser._authenticate(callbacks);
      },
      failure: function(error, statusCode) {
        root.Kii.logger("Failreg");
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(registrationCallbacks, false);
  };

  /** Update a user's password on the server
  
  <br><br>Update a user's password with the server. The fromPassword must be equal to the current password associated with the account in order to succeed.
  @param {String} fromPassword The user's current password
  @param {String} toPassword The user's desired password. Must be at least 4 characters, made up of alphanumeric and/or: @,#,$,%,^,&
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful update password request
  @param {Method} callbacks.failure The callback method to call on a failed update password request
  @throws {InvalidPasswordException} If the new password is not in the proper format
  @example 
  var user = Kii.currentUser();
  user.updatePassword("oldpassword", "newpassword", {
      success: function(theUser) {
          // do something
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.updatePassword = function(fromPassword, toPassword, callbacks) {
    var data, path, request, updateCallbacks,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Updating password from " + fromPassword + " to " + toPassword);
    if (KiiUtilities._validatePassword(toPassword)) {
      data = {
        oldPassword: fromPassword,
        newPassword: toPassword
      };
      path = "/users/" + this._uuid + "/password";
      request = this._getRequest({
        path: path,
        withApp: true
      });
      request.setMethod("PUT");
      request.setData(data);
      request.setContentType("application/vnd.kii.ChangePasswordRequest+json");
      updateCallbacks = {
        success: function(data, statusCode) {
          if (statusCode < 300 && statusCode >= 200) {
            _thisUser._setPassword(toPassword);
            if (callbacks != null) {
              return callbacks.success(_thisUser);
            }
          } else if (callbacks != null) {
            return callbacks.failure(_thisUser, "Unable to change password");
          }
        },
        failure: function(error, statusCode) {
          if (callbacks != null) {
            return callbacks.failure(_thisUser, error);
          }
        }
      };
      return request.execute(updateCallbacks, true);
    } else if (callbacks != null) {
      return callbacks.failure(_thisUser, (new root.InvalidPasswordException()).message);
    }
  };

  /** Reset a user's password on the server
  
  <br><br>Reset a user's password on the server. The user is determined by the specified userIdentifier - which can be an email address or phone number that has already been associated with an account. Reset instructions will be sent to that identifier.
  <br><br><b>Please Note:</b> This will reset the user's access token, so if they are currently logged in - their session will no longer be valid.
  @param {String} userIdentifier The user's current password
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful update password request
  @param {Method} callbacks.failure The callback method to call on a failed update password request
  @example 
  KiiUser.resetPassword("johndoe@example.com", {
      success: function() {
          // do something
      },
      
      failure: function(anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.resetPassword = function(userIdentifier, callbacks) {
    var accountType, path, request, resetCallbacks;

    root.Kii.logger("Resetting password with identifier: " + userIdentifier);
    if (KiiUtilities._validateEmail(userIdentifier)) {
      accountType = "EMAIL";
    } else if (KiiUtilities._validatePhoneNumber(userIdentifier)) {
      accountType = "PHONE";
    } else if (callbacks != null) {
      callbacks.failure("Invalid user identifier. Must be a valid email address or phone number");
      return;
    }
    if (accountType != null) {
      path = "/users/" + accountType + ":" + userIdentifier + "/password/request-reset";
      request = new KiiRequest(path, true);
      request.setMethod("POST");
      request.setAnonymous(true);
      resetCallbacks = {
        success: function(data, statusCode) {
          if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
            return callbacks.success();
          } else if (callbacks != null) {
            return callbacks.failure("Unable to reset password");
          }
        },
        failure: function(error, statusCode) {
          if (callbacks != null) {
            return callbacks.failure(error);
          }
        }
      };
      return request.execute(resetCallbacks, true);
    }
  };

  KiiUser.prototype.verifyCredentials = function(type, code, callbacks) {
    var path, request, verifyCallbacks,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Verifying " + type + " with code: " + code);
    path = "/users/me/" + type + "/verify";
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod("POST");
    request.setData({
      verificationCode: code
    });
    request.setContentType("application/vnd.kii.AddressVerificationRequest+json");
    verifyCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200) {
          if (type === "email-address") {
            _thisUser._setEmailVerified(true);
          } else if (type === "phone-number") {
            _thisUser._setPhoneVerified(true);
          }
          if (callbacks != null) {
            return callbacks.success(_thisUser);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to verify " + type);
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(verifyCallbacks, true);
  };

  /** Verify the current user's phone number
  
  <br><br>This method is used to verify the phone number of the currently logged in user.
  @param {String} verificationCode The code which verifies the currently logged in user
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful verification request
  @param {Method} callbacks.failure The callback method to call on a failed verification request
  @example 
  var user = Kii.currentUser();
  user.verifyPhoneNumber("012345", {
      success: function(theUser) {
          // do something
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.verifyPhoneNumber = function(verificationCode, callbacks) {
    return this.verifyCredentials("phone-number", verificationCode, callbacks);
  };

  KiiUser.prototype.resendVerification = function(type, callbacks) {
    var path, request, resendCallbacks,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Resending verification " + type);
    path = "/users/me/" + type + "/resend-verification";
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod("POST");
    resendCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
          return callbacks.success(_thisUser);
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to resend " + type + " verification");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(resendCallbacks, true);
  };

  /** Resend the email verification code to the user
  
  <br><br>This method will re-send the email verification to the currently logged in user
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful resend request
  @param {Method} callbacks.failure The callback method to call on a failed resend request
  @example 
  var user = Kii.currentUser();
  user.resendEmailVerification({
      success: function(theUser) {
          // do something
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.resendEmailVerification = function(callbacks) {
    return this.resendVerification("email-address", callbacks);
  };

  /** Resend the SMS verification code to the user
  
  <br><br>This method will re-send the SMS verification to the currently logged in user
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful resend request
  @param {Method} callbacks.failure The callback method to call on a failed resend request
  @example 
  var user = Kii.currentUser();
  user.resendPhoneNumberVerification({
      success: function(theUser) {
          // do something
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.resendPhoneNumberVerification = function(callbacks) {
    return this.resendVerification("phone-number", callbacks);
  };

  /** Retrieve a list of groups which the user is a member of
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful resend request
  @param {Method} callbacks.failure The callback method to call on a failed resend request
  @example 
  var user = Kii.currentUser();
  user.memberOfGroups({
      success: function(theUser, groupList) {
          // do something with the results
          for(var i=0; i&lt;groupList.length; i++) {
              var g = groupList[i]; // a KiiGroup object
          }
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.memberOfGroups = function(callbacks) {
    var memberCallbacks, path, request,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Getting groups for member " + this._uuid);
    path = "/groups/?is_member=" + this._uuid;
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setAccept("application/vnd.kii.GroupsRetrievalResponse+json");
    memberCallbacks = {
      success: function(data, statusCode) {
        var group, groupList, _i, _len, _ref;

        if (statusCode < 300 && statusCode >= 200) {
          groupList = [];
          _ref = data.groups;
          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
            group = _ref[_i];
            groupList.push(root.KiiGroup._groupWithJSON(group));
          }
          if (callbacks != null) {
            return callbacks.success(_thisUser, groupList);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to retrieve groups");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(memberCallbacks, false);
  };

  /** Updates the user's phone number on the server
  @param {String} newPhoneNumber The new phone number to change to
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful resend request
  @param {Method} callbacks.failure The callback method to call on a failed resend request
  @example 
  var user = Kii.currentUser();
  user.changePhone('+19415551234', {
      success: function(theUser) {
          // do something on success
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.changePhone = function(newPhoneNumber, callbacks) {
    var path, request, updateCallbacks,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Updating phone number to " + newPhoneNumber);
    path = "/users/" + this._uuid + "/phone-number";
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod("PUT");
    request.setContentType("application/vnd.kii.PhoneNumberModificationRequest+json");
    request.setData({
      phoneNumber: newPhoneNumber
    });
    updateCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
          _thisUser._setPhoneVerified(false);
          _thisUser._setPhoneNumber(newPhoneNumber);
          return callbacks.success(_thisUser);
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to update phone number");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(updateCallbacks, true);
  };

  /** Updates the user's email address on the server
  @param {String} newEmail The new email address to change to
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful resend request
  @param {Method} callbacks.failure The callback method to call on a failed resend request
  @example 
  var user = Kii.currentUser();
  user.changeEmail('mynewemail@kii.com', {
      success: function(theUser) {
          // do something on success
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.changeEmail = function(newEmail, callbacks) {
    var path, request, updateCallbacks,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Updating email address to: " + newEmail);
    if (KiiUtilities._validateEmail(newEmail)) {
      path = "/users/" + this._uuid + "/email-address";
      request = this._getRequest({
        path: path,
        withApp: true
      });
      request.setMethod("PUT");
      request.setContentType("application/vnd.kii.EmailAddressModificationRequest+json");
      request.setData({
        emailAddress: newEmail
      });
      updateCallbacks = {
        success: function(data, statusCode) {
          if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
            _thisUser._setEmailVerified(false);
            _thisUser._setEmailAddress(newEmail);
            return callbacks.success(_thisUser);
          } else if (callbacks != null) {
            return callbacks.failure(_thisUser, "Unable to update email address");
          }
        },
        failure: function(error, statusCode) {
          if (callbacks != null) {
            return callbacks.failure(_thisUser, error);
          }
        }
      };
      return request.execute(updateCallbacks, true);
    } else {
      return callbacks.failure(_thisUser, "Invalid email address format");
    }
  };

  /** Saves the latest user values to the server
  
  <br><br>If the user does not yet exist, it will NOT be created. Otherwise, the fields that have changed will be updated accordingly.
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful save request
  @param {Method} callbacks.failure The callback method to call on a failed save request
  @example 
  var user = Kii.getCurrentUser(); // a KiiUser
  user.save({
      success: function(theSavedUser) {
          // do something with the saved user
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.save = function(callbacks) {
    var data, path, request, updateCallbacks,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Saving user: " + this._uuid);
    path = "/users/" + this._uuid;
    root.Kii.logger("CUSTOMINFO: ");
    root.Kii.logger(this._customInfo);
    request = this._getRequest({
      path: path,
      withApp: true
    });
    request.setMethod("POST");
    request.setContentType("application/vnd.kii.UserUpdateRequest+json");
    data = this._customInfo;
    if (this._country != null) {
      data.country = this._country;
    }
    if (this._displayName != null) {
      data.displayName = this._displayName;
    }
    request.setData(data);
    updateCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200) {
          _thisUser._setModified(data.modifiedAt);
          if (callbacks != null) {
            return callbacks.success(_thisUser);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(updateCallbacks, false);
  };

  /** Updates the local user's data with the user data on the server
  
  <br><br>The user must exist on the server. Local data will be overwritten.      
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful refresh request
  @param {Method} callbacks.failure The callback method to call on a failed refresh request
  @example 
  var user = Kii.getCurrentUser(); // a KiiUser
  user.refresh({
      success: function(theRefreshedUser) {
          // do something with the refreshed user
      },
  
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype.refresh = function(callbacks) {
    var refreshCallbacks, request,
      _this = this;

    _thisUser = this;
    root.Kii.logger("Refreshing user: " + this._uuid);
    request = this._getRequest({
      path: "/users/" + this._uuid,
      withApp: true
    });
    refreshCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200) {
          _thisUser._updateWithJSON(data);
          if (callbacks != null) {
            return callbacks.success(_thisUser);
          }
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(refreshCallbacks, false);
  };

  /** Delete the user from the server
  @param {Object} callbacks An object with callback methods defined
  @param {Method} callbacks.success The callback method to call on a successful delete request
  @param {Method} callbacks.failure The callback method to call on a failed delete request
  @example 
  var user = Kii.getCurrentUser(); // a KiiUser
  obj.delete({
      success: function(theDeletedUser) {
          // do something
      },
      
      failure: function(theUser, anErrorString) {
          // do something with the error response
      }
  });
  */


  KiiUser.prototype["delete"] = function(callbacks) {
    var refreshCallbacks, request,
      _this = this;

    root.Kii.logger("Deleting user...");
    _thisUser = this;
    request = this._getRequest({
      path: "/users/" + this._uuid,
      withApp: true
    });
    request.setMethod("DELETE");
    refreshCallbacks = {
      success: function(data, statusCode) {
        if (statusCode < 300 && statusCode >= 200 && (callbacks != null)) {
          return callbacks.success(_thisUser);
        } else if (callbacks != null) {
          return callbacks.failure(_thisUser, "Unable to parse response");
        }
      },
      failure: function(error, statusCode) {
        if (callbacks != null) {
          return callbacks.failure(_thisUser, error);
        }
      }
    };
    return request.execute(refreshCallbacks, true);
  };

  /**
      Logs the currently logged-in user out of the KiiSDK
      @example
      KiiUser.logOut();
  */


  KiiUser.logOut = function() {
    return root.Kii.logOut();
  };

  /**
      Checks to see if there is a user authenticated with the SDK
      @example
      if(KiiUser.loggedIn()) {
          // do something
      }
  */


  KiiUser.loggedIn = function() {
    return root.Kii.loggedIn();
  };

  /**
      Retrieves the currently logged-in user
      @example
      KiiUser.getCurrentUser();
  */


  KiiUser.getCurrentUser = function() {
    return root.Kii.getCurrentUser();
  };

  KiiUser.prototype._updateWithJSON = function(json) {
    var key, value;

    root.Kii.logger("Updating with:");
    root.Kii.logger(json);
    for (key in json) {
      value = json[key];
      root.Kii.logger("key/val => " + key + "/" + value);
      root.Kii.logger("Substr " + (key.substring(0, 1)));
      if (key === "userID" || key === "id") {
        this._uuid = value;
      } else if (key === "created" || key === "createdAt" || key === "_created") {
        this._created = value;
      } else if (key === "modified" || key === "modifiedAt" || key === "_modified") {
        this._modified = value;
      } else if (key === "loginName") {
        this._username = value;
      } else if (key === "displayName") {
        this._displayName = value;
      } else if (key === "country") {
        root.Kii.logger("Is setting country");
        this._country = value;
      } else if (key === "emailAddress") {
        this._emailAddress = value;
      } else if (key === "phoneNumber") {
        this._phoneNumber = value;
      } else if (key === "emailAddressVerified") {
        root.Kii.logger("Email verified: " + value);
        this._emailVerified = value;
      } else if (key === "phoneNumberVerified") {
        root.Kii.logger("Phone verified: " + value);
        this._phoneVerified = value;
      } else if (key === "") {
        root.Kii.logger("Setting empty to custom info");
        this._customInfo[key] = value;
      } else if (key.substring(0, 1 !== "_")) {
        root.Kii.logger("Setting to custom info");
        this._customInfo[key] = value;
      } else {
        root.Kii.logger("Doing nothing");
      }
    }
    if ((this._displayName == null) && (this._username != null)) {
      return this._displayName = this._username;
    }
  };

  KiiUser.prototype._getRequest = function(spec) {
    var path, request, withApp;

    path = spec.path;
    withApp = spec.withApp;
    request = new KiiRequest(path, withApp);
    return request;
  };

  return KiiUser;

}).call(this);

KiiUtilities = (function() {
  function KiiUtilities() {}

  KiiUtilities.arrayRemove = function(array, from, to) {
    var rest;

    rest = array.slice(((to || from) + 1) || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.push.apply(array, rest);
  };

  KiiUtilities._validateEmail = function(value) {
    var pattern;

    value = $.trim(value);
    pattern = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,6}$/i;
    if ((typeof value).toLowerCase() !== "string") {
      root.Kii.logger("Not string");
      return false;
    } else if (value.match(pattern)) {
      return true;
    } else {
      return false;
    }
  };

  KiiUtilities._validatePhoneNumber = function(value) {
    var pattern;

    value = $.trim(value);
    pattern = /^[\\+]+[0-9]{10,}$/i;
    if ((typeof value).toLowerCase() !== "string") {
      root.Kii.logger("Not string");
      return false;
    } else if (value.match(pattern)) {
      return true;
    } else {
      return false;
    }
  };

  KiiUtilities._validateLocalPhone = function(value) {
    var pattern;

    value = $.trim(value);
    pattern = /^\d+$/;
    if ((typeof value).toLowerCase() !== "string") {
      root.Kii.logger("Not string");
      return false;
    } else if (value.match(pattern)) {
      return true;
    } else {
      root.Kii.logger("Invalid format");
      return false;
    }
  };

  KiiUtilities._assertLocalPhoneIsValid = function(value) {
    if (!KiiUtilities._validateLocalPhone(value)) {
      throw new root.InvalidLocalPhoneNumberException;
    }
  };

  KiiUtilities._validateCountryCode = function(value) {
    var pattern;

    value = $.trim(value);
    pattern = /^[a-z]{2}$/i;
    if ((typeof value).toLowerCase() !== "string") {
      root.Kii.logger("Not string");
      return false;
    } else if (value.match(pattern)) {
      root.Kii.logger("Is true");
      return true;
    } else {
      return false;
    }
  };

  KiiUtilities._assertCountryCodeIsValid = function(value) {
    if (!KiiUtilities._validateCountryCode(value)) {
      throw new root.InvalidCountryException;
    }
  };

  KiiUtilities._validatePassword = function(value) {
    var pattern;

    root.Kii.logger("Validating password: " + value);
    pattern = /^[\x20-\x7E]{4,50}$/;
    if ((typeof value).toLowerCase() !== "string") {
      root.Kii.logger("not string");
      return false;
    } else if (value.match(pattern)) {
      root.Kii.logger("matched");
      return true;
    } else {
      root.Kii.logger("other exception");
      return false;
    }
  };

  KiiUtilities._assertPasswordIsValid = function(value) {
    if (!KiiUtilities._validatePassword(value)) {
      throw new root.InvalidPasswordException;
    }
  };

  KiiUtilities._validateUsername = function(value) {
    var pattern;

    pattern = /^[a-zA-Z0-9-_\\.]{3,64}$/i;
    if ((typeof value).toLowerCase() !== "string") {
      return false;
    } else if (value.match(pattern)) {
      return true;
    } else {
      return false;
    }
  };

  return KiiUtilities;

}).call(this);

/**
    @class Represents a KiiSocialConnect object
    @exports root.KiiACL as KiiACL
*/


root.KiiSocialConnect = (function() {
  var _instance;

  function KiiSocialConnect() {}

  _instance = null;

  /** Set up a reference to one of the supported KiiSocialNetworks.
   
   The user will not be authenticated or linked to a KiiUser
   until one of those methods are called explicitly.
   @param {KiiSocialNetworkName} networkName One of the supported KiiSocialNetworkName values
   @param {String} apiKey The SDK key assigned by the social network provider
   @param {String} apiSecret The SDK secret assigned by the social network provider
   @param {Object} extras Extra options that should be passed to the SNS. Examples could be (Facebook) a dictionary of permissions to grant to the authenticated user.
  */


  KiiSocialConnect.setupNetwork = function(networkName, apiKey, apiSecret, extras) {
    var manager;

    if (_instance == null) {
      _instance = new _KiiSocialConnect;
    }
    manager = _instance._getManager(networkName);
    manager._reset();
    manager._setup(apiKey, apiSecret, extras);
    return root.Kii.logger("Set key: " + manager._key);
  };

  /** Log a user into the social network provided
   
   This will initiate the login process for the given network. If a KiiUser has already been authenticated, this will authenticate and link the user to the network. Otherwise, this will generate a KiiUser that is automatically linked to the social network. The network must already be set up via setupNetwork
   @param networkName One of the supported KiiSocialNetworkName values
   @param options A dictionary of key/values to pass to KiiSocialConnect
   @param {Object} callbacks An object with callback methods defined
   @param {Method} callbacks.success The callback method to call on a successful log in request
   @param {Method} callbacks.failure The callback method to call on a failed log in request
   @example 
   
   KiiSocialConnect.logIn(KiiSocialNetworkName.FACEBOOK, {
   
       success: function(user, network) {
           // do something now that the user is logged in
       },
      
       failure: function(user, network, anErrorString) {
           // do something with the error response
       }
   });
  */


  KiiSocialConnect.logIn = function(networkName, options, callbacks) {
    var called;

    called = false;
    if (_instance != null) {
      root.Kii.logger("And manager: ");
      root.Kii.logger(_instance._getManager(networkName));
      if (_instance._getManager(networkName)) {
        _instance._getManager(networkName)._logIn(options, callbacks);
        called = true;
      }
    }
    root.Kii.logger("Callbacks");
    root.Kii.logger(callbacks);
    if (!called && (callbacks != null)) {
      return callbacks.failure(root.KiiUser.getCurrentUser(), networkName, "Unable to get network. Please ensure the network name is one of the supported KiiSocialNetworkName values");
    }
  };

  /** Link the currently logged in user with a social network
   
   This will initiate the login process for the given network, which for SSO-enabled services like Facebook, will send the user to the Facebook site for authentication. There must be a currently authenticated KiiUser. Otherwise, you can use the logIn: method to create and log in a KiiUser using a network. The network must already be set up via setupNetwork
   @param networkName One of the supported KiiSocialNetworkName values
   @param options A dictionary of key/values to pass to KiiSocialConnect
   @param {Object} callbacks An object with callback methods defined
   @param {Method} callbacks.success The callback method to call on a successful log in request
   @param {Method} callbacks.failure The callback method to call on a failed log in request
   @example 
   
   KiiSocialConnect.linkCurrentUserWithNetwork(KiiSocialNetworkName.FACEBOOK, {
   
       success: function(user, network) {
           // do something now that the user is linked
       },
      
       failure: function(user, network, anErrorString) {
           // do something with the error response
       }
   });
  */


  KiiSocialConnect.linkCurrentUserWithNetwork = function(networkName, options, callbacks) {
    var called;

    root.Kii.logger("Trying with instance");
    root.Kii.logger(_instance);
    called = false;
    if (_instance != null) {
      root.Kii.logger("And manager: ");
      root.Kii.logger(_instance._getManager(networkName));
      if (_instance._getManager(networkName)) {
        _instance._getManager(networkName)._linkWithCurrentUser(options, callbacks);
        called = true;
      }
    }
    root.Kii.logger("Callbacks");
    root.Kii.logger(callbacks);
    if (!called && (callbacks != null)) {
      return callbacks.failure(root.KiiUser.getCurrentUser(), networkName, "Unable to get network. Please ensure the network name is one of the supported KiiSocialNetworkName values");
    }
  };

  /** Unlink the currently logged in user with a social network
   
   The network must already be set up via setupNetwork
   @param networkName One of the supported KiiSocialNetworkName values
   @param {Object} callbacks An object with callback methods defined
   @param {Method} callbacks.success The callback method to call on a successful log in request
   @param {Method} callbacks.failure The callback method to call on a failed log in request
   @example 
   
   KiiSocialConnect.unLinkCurrentUserFromNetwork(KiiSocialNetworkName.FACEBOOK, {
   
       success: function(user, network) {
           // do something now that the user is unlinked
       },
      
       failure: function(user, network, anErrorString) {
           // do something with the error response
       }
   });
  */


  KiiSocialConnect.unLinkCurrentUserFromNetwork = function(networkName, callbacks) {
    var called;

    root.Kii.logger("Trying with instance");
    root.Kii.logger(_instance);
    called = false;
    if (_instance != null) {
      root.Kii.logger("And manager: ");
      root.Kii.logger(_instance._getManager(networkName));
      if (_instance._getManager(networkName)) {
        _instance._getManager(networkName)._unlinkFromCurrentUser(callbacks);
        called = true;
      }
    }
    root.Kii.logger("Callbacks");
    root.Kii.logger(callbacks);
    if (!called && (callbacks != null)) {
      return callbacks.failure(root.KiiUser.getCurrentUser(), networkName, "Unable to get network. Please ensure the network name is one of the supported KiiSocialNetworkName values");
    }
  };

  /** Retrieve the current user's access token from a social network
  
  The network must be set up and linked to the current user. It is recommended you save this to preferences for multi-session use.
  @param networkName One of the supported KiiSocialNetworkName values
  @returns {String} The current access token, null if unavailable
  */


  KiiSocialConnect.getAccessTokenForNetwork = function(networkName) {
    return _instance._getManager(networkName)._getToken();
  };

  /** Retrieve the current user's access token expiration date from a social network
  
  The network must be set up and linked to the current user. It is recommended you save this to preferences for multi-session use.
  @param networkName One of the supported KiiSocialNetworkName values
  @returns {String} The current access token expiration date, null if unavailable
  */


  KiiSocialConnect.getAccessTokenExpirationForNetwork = function(networkName) {
    return _instance._getManager(networkName)._getTokenExpiration();
  };

  return KiiSocialConnect;

}).call(this);

_KiiSocialConnect = (function() {
  var _facebookManager;

  function _KiiSocialConnect() {
    this._getManager = __bind(this._getManager, this);
  }

  _facebookManager = null;

  _KiiSocialConnect.prototype._getManager = function(networkName) {
    if (networkName === root.KiiSocialNetworkName.FACEBOOK) {
      if (this._facebookManager != null) {
        return this._facebookManager;
      } else {
        return this._facebookManager = new root.KiiSCNFacebook();
      }
    }
  };

  return _KiiSocialConnect;

})();

root.KiiSocialConnectNetwork = (function() {
  var _callbacks, _extras, _key, _network, _secret, _token, _tokenExpiration;

  KiiSocialConnectNetwork.prototype._className = "KiiSocialConnectNetwork";

  _network = null;

  _key = null;

  _secret = null;

  _extras = null;

  _token = null;

  _tokenExpiration = null;

  _callbacks = null;

  KiiSocialConnectNetwork.prototype._setNetwork = function(_network) {
    this._network = _network;
  };

  KiiSocialConnectNetwork.prototype._getNetwork = function() {
    return this._network;
  };

  KiiSocialConnectNetwork.prototype._setKey = function(_key) {
    this._key = _key;
  };

  KiiSocialConnectNetwork.prototype._getKey = function() {
    return this._key;
  };

  KiiSocialConnectNetwork.prototype._setSecret = function(_secret) {
    this._secret = _secret;
  };

  KiiSocialConnectNetwork.prototype._getSecret = function() {
    return this._secret;
  };

  KiiSocialConnectNetwork.prototype._setExtras = function(_extras) {
    this._extras = _extras;
  };

  KiiSocialConnectNetwork.prototype._getExtras = function() {
    return this._extras;
  };

  KiiSocialConnectNetwork.prototype._setToken = function(_token) {
    this._token = _token;
  };

  KiiSocialConnectNetwork.prototype._getToken = function() {
    return this._token;
  };

  KiiSocialConnectNetwork.prototype._setTokenExpiration = function(_tokenExpiration) {
    this._tokenExpiration = _tokenExpiration;
  };

  KiiSocialConnectNetwork.prototype._getTokenExpiration = function() {
    return this._tokenExpiration;
  };

  KiiSocialConnectNetwork.prototype._setCallbacks = function(_callbacks) {
    this._callbacks = _callbacks;
  };

  KiiSocialConnectNetwork.prototype._getCallbacks = function() {
    return this._callbacks;
  };

  function KiiSocialConnectNetwork(_network) {
    this._network = _network;
    this._setup = __bind(this._setup, this);
    this._unlinkFromCurrentUser = __bind(this._unlinkFromCurrentUser, this);
    this._linkWithCurrentUser = __bind(this._linkWithCurrentUser, this);
    this._logOut = __bind(this._logOut, this);
    this._logIn = __bind(this._logIn, this);
    this._reset = __bind(this._reset, this);
    this._isAuthenticated = __bind(this._isAuthenticated, this);
    this._getCallbacks = __bind(this._getCallbacks, this);
    this._setCallbacks = __bind(this._setCallbacks, this);
    this._getTokenExpiration = __bind(this._getTokenExpiration, this);
    this._setTokenExpiration = __bind(this._setTokenExpiration, this);
    this._getToken = __bind(this._getToken, this);
    this._setToken = __bind(this._setToken, this);
    this._getExtras = __bind(this._getExtras, this);
    this._setExtras = __bind(this._setExtras, this);
    this._getSecret = __bind(this._getSecret, this);
    this._setSecret = __bind(this._setSecret, this);
    this._getKey = __bind(this._getKey, this);
    this._setKey = __bind(this._setKey, this);
    this._getNetwork = __bind(this._getNetwork, this);
    this._setNetwork = __bind(this._setNetwork, this);
  }

  KiiSocialConnectNetwork.prototype._isAuthenticated = function() {
    return this._token != null;
  };

  KiiSocialConnectNetwork.prototype._reset = function() {
    this._token = null;
    this._tokenExpiration = null;
    this._key = null;
    this._secret = null;
    return this._extras = null;
  };

  KiiSocialConnectNetwork.prototype._logIn = function(options, _callbacks) {
    this._callbacks = _callbacks;
  };

  KiiSocialConnectNetwork.prototype._logOut = function() {};

  KiiSocialConnectNetwork.prototype._linkWithCurrentUser = function(options, _callbacks) {
    this._callbacks = _callbacks;
  };

  KiiSocialConnectNetwork.prototype._unlinkFromCurrentUser = function(_callbacks) {
    this._callbacks = _callbacks;
  };

  KiiSocialConnectNetwork.prototype._setup = function(_key, _secret, _extras) {
    this._key = _key;
    this._secret = _secret;
    this._extras = _extras;
  };

  return KiiSocialConnectNetwork;

})();

root.KiiSCNFacebook = (function(_super) {
  var _authWindow;

  __extends(KiiSCNFacebook, _super);

  _authWindow = null;

  function KiiSCNFacebook() {
    this._unlinkFromCurrentUser = __bind(this._unlinkFromCurrentUser, this);
    this._linkWithCurrentUser = __bind(this._linkWithCurrentUser, this);
    this._logOut = __bind(this._logOut, this);
    this._logIn = __bind(this._logIn, this);
    this._unlink = __bind(this._unlink, this);
    this._link = __bind(this._link, this);
    this._register = __bind(this._register, this);
    this._setup = __bind(this._setup, this);    KiiSCNFacebook.__super__.constructor.call(this, KiiSocialNetworkName.FACEBOOK);
  }

  KiiSCNFacebook.prototype._setup = function(_key, _secret, _extras) {
    this._key = _key;
    this._secret = _secret;
    this._extras = _extras;
    KiiSCNFacebook.__super__._setup.call(this, this._key, this._secret, this._extras);
    this._extras.appId = this._key;
    root.Kii.logger(this._extras);
    return FB.init(this._extras);
  };

  KiiSCNFacebook.prototype._register = function(token, expires) {
    var registrationCallbacks, request,
      _this = this;

    _this = this;
    request = new KiiRequest("/integration/facebook", true);
    request.setMethod("POST");
    request.setData({
      accessToken: token
    });
    request.setAnonymous(true);
    request.setContentType("application/vnd.kii.AuthTokenFacebookRequest+json");
    registrationCallbacks = {
      success: function(data) {
        var user;

        _this._setToken(token);
        _this._setTokenExpiration(expires);
        user = new root.KiiUser();
        user._updateWithJSON(data);
        user._setAccessToken(data['access_token']);
        root.Kii.setCurrentUser(user);
        if (_this._callbacks != null) {
          return _this._callbacks.success(root.KiiUser.getCurrentUser(), _this._network);
        }
      },
      failure: function(error, statusCode) {
        if (_this._callbacks != null) {
          return _this._callbacks.failure(null, _this._network, error);
        }
      }
    };
    return request.execute(registrationCallbacks, false);
  };

  KiiSCNFacebook.prototype._link = function(token, expires) {
    var linkCallbacks, request,
      _this = this;

    _this = this;
    request = new KiiRequest("/users/me/facebook/link", true);
    request.setMethod("POST");
    request.setData({
      accessToken: token
    });
    linkCallbacks = {
      success: function(data) {
        _this._setToken(token);
        _this._setTokenExpiration(expires);
        if (_this._callbacks != null) {
          return _this._callbacks.success(root.KiiUser.getCurrentUser(), _this._network);
        }
      },
      failure: function(error, statusCode) {
        if (_this._callbacks != null) {
          return _this._callbacks.failure(root.KiiUser.getCurrentUser(), _this._network, error);
        }
      }
    };
    return request.execute(linkCallbacks, true);
  };

  KiiSCNFacebook.prototype._unlink = function() {
    var request, unlinkCallbacks,
      _this = this;

    _this = this;
    request = new KiiRequest("/users/me/facebook/unlink", true);
    request.setMethod("POST");
    unlinkCallbacks = {
      success: function(data) {
        if (_this._callbacks != null) {
          return _this._callbacks.success(root.KiiUser.getCurrentUser(), _this._network);
        }
      },
      failure: function(error, statusCode) {
        if (_this._callbacks != null) {
          return _this._callbacks.failure(root.KiiUser.getCurrentUser(), _this._network, error);
        }
      }
    };
    return request.execute(unlinkCallbacks, true);
  };

  KiiSCNFacebook.prototype._logIn = function(options, callbacks) {
    var _this = this;

    KiiSCNFacebook.__super__._logIn.call(this, options, callbacks);
    root.Kii.logger("should auth fb");
    _this = this;
    root.Kii.logger("Checking options");
    root.Kii.logger(options);
    if ((options != null) && (options.access_token != null) && (options.access_token_expires != null)) {
      root.Kii.logger("Have options: ");
      root.Kii.logger(options);
      if (root.KiiUser.getCurrentUser() != null) {
        return _this._link(options.access_token, options.access_token_expires);
      } else {
        return _this._register(options.access_token, options.access_token_expires);
      }
    } else {
      return FB.login(function(response) {
        if (response.authResponse != null) {
          if (root.KiiUser.getCurrentUser() != null) {
            return _this._link(response.authResponse.accessToken, response.authResponse.expiresIn);
          } else {
            return _this._register(response.authResponse.accessToken, response.authResponse.expiresIn);
          }
        } else {
          if (_this._callbacks != null) {
            return _this._callbacks.failure(null, _this._network, "User cancelled login or did not fully authorize");
          }
        }
      });
    }
  };

  KiiSCNFacebook.prototype._logOut = function() {
    KiiSCNFacebook.__super__._logOut.apply(this, arguments);
    return root.Kii.logger("Log out fb");
  };

  KiiSCNFacebook.prototype._linkWithCurrentUser = function(options, callbacks) {
    var _this = this;

    KiiSCNFacebook.__super__._linkWithCurrentUser.call(this, options, callbacks);
    _this = this;
    if (root.KiiUser.getCurrentUser() != null) {
      if ((options != null) && (options.access_token != null) && (options.access_token_expires != null)) {
        return _this._link(options.access_token, options.access_token_expires);
      } else {
        return FB.login(function(response) {
          if (response.authResponse) {
            return _this._link(response.authResponse.accessToken, response.authResponse.expiresIn);
          } else if (_this._callbacks != null) {
            return _this._callbacks.failure(null, _this._network, "User cancelled Facebook login or did not fully authorize");
          }
        });
      }
    } else if (callbacks != null) {
      return callbacks.failure("A KiiUser must be logged in before linking to Facebook");
    }
  };

  KiiSCNFacebook.prototype._unlinkFromCurrentUser = function(callbacks) {
    KiiSCNFacebook.__super__._unlinkFromCurrentUser.call(this, callbacks);
    if (root.KiiUser.getCurrentUser() != null) {
      return this._unlink();
    } else if (callbacks != null) {
      return callbacks.failure("A KiiUser must be logged in before unlinking from Facebook");
    }
  };

  return KiiSCNFacebook;

})(root.KiiSocialConnectNetwork);

root.InvalidDisplayNameException = function() {
  return this.message = "Unable to set displayName. Must be between 4-50 characters.";
};

root.InvalidPasswordException = function() {
  return this.message = "Unable to set password. Must be between 4-50 characters composed with ascii (exclude control character)";
};

root.InvalidUsernameException = function() {
  return this.message = "Unable to set username. Must be between 3 and 64 characters, which can include alphanumeric characters as well as underscores '_' and periods '.'";
};

root.InvalidUserIdentifierException = function() {
  return this.message = "User identifier should be one of user name, phone number or email";
};

root.InvalidEmailException = function() {
  return this.message = "Unable to set email address. Must be a valid email";
};

root.InvalidPhoneNumberException = function() {
  return this.message = "Unable to set phone number. Must begin with a '+' and be at least 10 digits";
};

root.InvalidLocalPhoneNumberException = function() {
  return this.message = "Unable to set phone number. Must be a sequence of numbers";
};

root.InvalidCountryException = function() {
  return _this.message = "Unable to set country code. Must be 2 alphabetic characters. Ex: US, JP, CN";
};

root.InvalidURIException = function() {
  return _this.message = "Unable to set URI. Must be of the form kiicloud://some/path/to/object/or/entity";
};

root.InvalidACLAction = function() {
  return _this.message = "Unable to set ACL action. Must be one of the permitted values in KiiACLAction";
};

root.InvalidACLSubject = function() {
  return _this.message = "Unable to set ACL subject. Must be of type KiiUser or KiiGroup";
};

root.InvalidACLGrant = function() {
  return _this.message = "Unable to set ACL grant. Must be a boolean type";
};

root.InvalidLimitException = function() {
  return _this.message = "Unable to set query limit. Must be an integer > 0";
};

/**
    @class represents the app admin context 
    <br><br>
    <B>This class must not referred from code accessbile from browser.
    This class is intended to be used by server side code like Node.js.
    If you use this class in code accessible by browser, your application id and application secret could be stolen.
    Attacker will be act as appadmin and all the data in your application will be suffered.
    </B>
    Application administrator context. entities obtained from this class will be manupulated by application admin.
    @exports root.KiiAppAdminContext as KiiAppAdminContext
*/


root.KiiAppAdminContext = (function() {
  var _id, _token;

  _token = null;

  _id = null;

  function KiiAppAdminContext(spec) {
    this._getToken = __bind(this._getToken, this);
    this._getId = __bind(this._getId, this);    this._token = spec.token;
    this._id = spec.id;
  }

  /**
      Creates a reference to a bucket operated by app admin.
      <br><br>The bucket will be created/accessed within this app's scope
      @param String bucketName The name of the bucket the app should create/access
      @returns {KiiBucket} A working KiiBucket object
      @example
      Kii.authenticateAsAppAdmin("client-id", "client-secret", {
          success: function(adminContext) {
              var bucket = adminContext.bucketWithName("myBucket");
              // KiiBucket operation by app admin is available now.
          },
          failure: function(errorString, errorCode) {
              // auth failed.
          }
      });
  */


  KiiAppAdminContext.prototype.bucketWithName = function(bucketName) {
    var adminBucket;

    adminBucket = new root.KiiBucketAdmin(bucketName, null, this._token);
    return adminBucket;
  };

  /**
      Creates a reference to a group operated by app admin.
      @param String group name.
      @returns {KiiGroup} A working KiiGroup object
      @example
      Kii.authenticateAsAppAdmin("client-id", "client-secret", {
          success: function(adminContext) {
              var group = appAdmin.groupWithName("newGroup");
              // KiiGroup operation by app admin is available now.
          },
          failure: function(errorString, errorCode) {
              // auth failed.
          }
      });
  */


  KiiAppAdminContext.prototype.groupWithName = function(groupName) {
    var group;

    group = root.KiiGroupAdmin._groupWithName(groupName, this);
    return group;
  };

  /**
      Creates a reference to a user operated by app admin.
      @param String user id.
      @returns {KiiUser} A working KiiUser object
      @example
      Kii.authenticateAsAppAdmin("client-id", "client-secret", {
          success: function(adminContext) {
              var user;
              user = appAdmin.userWithID("userid");
              // KiiUser operation by app admin is available now.
          },
          failure: function(errorString, errorCode) {
              // auth failed.
          }
      });
  */


  KiiAppAdminContext.prototype.userWithID = function(userid) {
    var user;

    user = root.KiiUserAdmin._userWithID(userid, this);
    return user;
  };

  KiiAppAdminContext.prototype._getId = function() {
    return this._id;
  };

  KiiAppAdminContext.prototype._getToken = function() {
    return this._token;
  };

  return KiiAppAdminContext;

})();

root.KiiACLAdmin = (function(_super) {
  var _adminToken;

  __extends(KiiACLAdmin, _super);

  _adminToken = null;

  function KiiACLAdmin(parent, adminToken) {
    this._userWithID = __bind(this._userWithID, this);
    this._groupWithID = __bind(this._groupWithID, this);
    this._getRequest = __bind(this._getRequest, this);    KiiACLAdmin.__super__.constructor.call(this);
    this._setParent(parent);
    this._adminToken = adminToken;
  }

  KiiACLAdmin.prototype._getRequest = function(spec) {
    var request;

    request = KiiACLAdmin.__super__._getRequest.call(this, spec);
    request.setAdminToken(this._adminToken);
    return request;
  };

  KiiACLAdmin.prototype._groupWithID = function(id) {
    var group;

    group = root.KiiGroupAdmin._groupWithID(id, this._adminToken);
    return group;
  };

  KiiACLAdmin.prototype._userWithID = function(id) {
    var user;

    user = root.KiiUserAdmin._userWithID(id, this._adminToken);
    return user;
  };

  return KiiACLAdmin;

})(root.KiiACL);

root.KiiGroupAdmin = (function(_super) {
  var _adminContext;

  __extends(KiiGroupAdmin, _super);

  _adminContext = null;

  function KiiGroupAdmin(adminContext) {
    this._setOwnerFromContext = __bind(this._setOwnerFromContext, this);
    this._userWithID = __bind(this._userWithID, this);
    this.bucketWithName = __bind(this.bucketWithName, this);
    this._getRequest = __bind(this._getRequest, this);    KiiGroupAdmin.__super__.constructor.call(this);
    this._adminContext = adminContext;
  }

  KiiGroupAdmin.prototype._getRequest = function(spec) {
    var request;

    request = KiiGroupAdmin.__super__._getRequest.call(this, spec);
    request.setAdminToken(this._adminContext._getToken());
    return request;
  };

  KiiGroupAdmin._groupWithName = function(groupName, adminContext) {
    return root.KiiGroupAdmin._groupWithNameAndMembers(groupName, null, adminContext);
  };

  KiiGroupAdmin._groupWithNameAndMembers = function(groupName, members, adminContext) {
    var group;

    group = new root.KiiGroupAdmin(adminContext);
    group._setName(groupName);
    group._setAddMembers(members);
    return group;
  };

  KiiGroupAdmin._groupWithID = function(id, adminContext) {
    var group;

    group = new root.KiiGroupAdmin(adminContext);
    group._setUUID(id);
    return group;
  };

  KiiGroupAdmin.prototype.bucketWithName = function(name) {
    var bucket;

    bucket = new root.KiiBucketAdmin(name, this, this._adminContext._getToken());
    return bucket;
  };

  KiiGroupAdmin.prototype._userWithID = function(id) {
    var user;

    user = root.KiiUserAdmin._userWithID(id, this._adminContext._getToken());
    return user;
  };

  KiiGroupAdmin.prototype._setOwnerFromContext = function(data) {};

  return KiiGroupAdmin;

}).call(this, root.KiiGroup);

root.KiiObjectAdmin = (function(_super) {
  var _adminToken;

  __extends(KiiObjectAdmin, _super);

  _adminToken = null;

  function KiiObjectAdmin(token) {
    this._userWithID = __bind(this._userWithID, this);
    this.objectACL = __bind(this.objectACL, this);
    this._getRequest = __bind(this._getRequest, this);    KiiObjectAdmin.__super__.constructor.call(this);
    this._adminToken = token;
  }

  KiiObjectAdmin.prototype._getRequest = function(spec) {
    var request;

    root.Kii.logger("admin req: " + this._adminToken);
    request = KiiObjectAdmin.__super__._getRequest.call(this, spec);
    request.setAdminToken(this._adminToken);
    return request;
  };

  KiiObjectAdmin.objectWithBucket = function(bucket, type, adminToken) {
    var obj;

    root.Kii.logger("Creating object w type: " + type);
    obj = new root.KiiObjectAdmin(adminToken);
    obj._setBucket(bucket);
    obj._setObjectType(type);
    root.Kii.logger(obj);
    return obj;
  };

  KiiObjectAdmin.prototype.objectACL = function() {
    var acl;

    acl = new root.KiiACLAdmin(this, this._adminToken);
    return acl;
  };

  KiiObjectAdmin.prototype._userWithID = function(id) {
    var user;

    user = root.KiiUserAdmin._userWithID(id, this._adminToken);
    return user;
  };

  return KiiObjectAdmin;

}).call(this, root.KiiObject);

root.KiiUserAdmin = (function(_super) {
  var _adminContext;

  __extends(KiiUserAdmin, _super);

  _adminContext = null;

  function KiiUserAdmin(adminContext) {
    this.bucketWithName = __bind(this.bucketWithName, this);
    this._getRequest = __bind(this._getRequest, this);    KiiUserAdmin.__super__.constructor.call(this);
    this._adminContext = adminContext;
  }

  KiiUserAdmin._userWithID = function(id, adminContext) {
    var user;

    user = new root.KiiUserAdmin(adminContext);
    user._setUUID(id);
    return user;
  };

  KiiUserAdmin.prototype._getRequest = function(spec) {
    var request;

    request = KiiUserAdmin.__super__._getRequest.call(this, spec);
    request.setAdminToken(this._adminContext._getToken());
    return request;
  };

  KiiUserAdmin.prototype.bucketWithName = function(bucketName) {
    var bucket;

    return bucket = new root.KiiBucketAdmin(bucketName, this, this._adminContext._getToken());
  };

  return KiiUserAdmin;

}).call(this, root.KiiUser);

/**
	@class Represent an anonymous user for setting the ACL of an object. This will include anyone using the application but have not signed up or authenticated as registered user.

	When retrieving ACL from an object, test for this class to determine the subject type. Example:

		if(acl.subject typeof KiiAnonymousUser) {
        	// the ACL is set for anonymous users
    	}

    @exports root.KiiAnonymousUser as KiiAnonymousUser
*/


root.KiiAnonymousUser = (function() {
  function KiiAnonymousUser() {}

  return KiiAnonymousUser;

})();

/**
	@class Represent any authenticated user for setting the ACL of an object. This will include anyone using the application who has registered and authenticated in the current session.

	When retrieving ACL from an object, test for this class to determine the subject type. Example:

		if(acl.subject typeof KiiAnyAuthenticatedUser) {
        	// the ACL is set for any authenticated users
    	}

    @exports root.KiiAnyAuthenticatedUser as KiiAnyAuthenticatedUser
*/


root.KiiAnyAuthenticatedUser = (function() {
  function KiiAnyAuthenticatedUser() {}

  return KiiAnyAuthenticatedUser;

})();

return root;
});  // generated by build.sh for running on Node.js

// Following code was generated by build.sh for running on Node.js
(function() {
var b = ((typeof module) !== "undefined") && (module !== null);
if (b && module.exports) {
  module.exports = {
    create: function() {
      return ctor.call(this);
    }
  };
} else {
  ctor();
}
})();