path: root/models/lib/class.vimeo.php

<?php
/**
* SimpleVimeo
* 
* API Framework for vimeo.com
* @package      SimpleVimeo
* @author       Adrian Rudnik <adrian@periocode.de>
* @link         http://code.google.com/p/php5-simplevimeo/
*/

/**
* Enable debug to output raw request and response information
*/

define('VIMEO_DEBUG_REQUEST', true);
define('VIMEO_DEBUG_RESPONSE', true);

/**
* Vimeo base class
*
* Provides vital functions to API (access, permission and object handling)
*
* @package     SimpleVimeo
* @subpackage  Base
*/

class VimeoBase {

    const PROJECT_NAME      = 'php5-simplevimeo';
    
    /**
    * Currently logged in user object
    * @var  VimeoUserEntity
    */
    private static $oUser = false;
    
    /**
    * Currently logged in user permission
    * @var  string
    */
    private static $ePermission = false;
    
    /**
    * Currently logged in user token
    * @var  string
    */
    private static $sToken = false;
    
    /**
    * Vimeo Application API key
    * @var  string
    */
    private static $sApiKey = '7a223534b3c1d0979a954f93cb746173  ';
    
    /**
    * Vimeo Application API secret key
    * @var  string
    */
    private static $sApiSecret = 'b11e83370';

    const VIMEO_REST_URL    = 'http://vimeo.com/api/rest/';
    const VIMEO_AUTH_URL    = 'http://vimeo.com/services/auth/';
    const VIMEO_UPLOAD_URL  = 'http://vimeo.com/services/upload/';
    const VIMEO_LOGIN_URL   = 'http://vimeo.com/log_in';

    /**
    * You can choose between the following engines:
    * executeRemoteCall_FSOCK = PHP5 file_get_content and stream_contexts (bad error handling)
    * executeRemoteCall_CURL = CURL is used for file transfer (better error handling)
    */
    const REQUEST_ENGINE_CURL           = 'executeRemoteCall_CURL';
    const VIDEOPOST_ENGINE_FSOCK        = 'executeVideopostCall_CURL';
    
    const PERMISSION_NONE               = false;
    const PERMISSION_READ               = 'read';
    const PERMISSION_WRITE              = 'write';
    const PERMISSION_DELETE             = 'delete';
    
    const COOKIE_FILE                   = '/tmp/simplevimeo.cookies';
    
    const DEBUG_ENABLE					= false;
    const DEBUG_LOGFILE					= '/tmp/simplevimeo.debug';
    
    /**
    * Debug output function
    */
    public static function debug($sTitle, $sContent) {
    	if(self::DEBUG_ENABLE) {
			$sMessage = 'DEBUG ' . date('Y-m-d H:i:s', time()) . "\n";
			$sMessage .= 'CONTENT: ' . $sContent . "\n";
			$sMesasge .= $sContent . "\n\n";
			
			$fhLog = fopen(self::DEBUG_LOGFILE, 'a+');
			
			if(!$fhLog) {
				throw new VimeoBaseException('Debug Logfile "' . self::DEBUG_LOGFILE . '" could not be found or written');
			} else {
				fputs($fhLog, $sMessage);
				fclose($fhLog);
			}
    	}
    }
    
    /**
    * Update Authentication
    * 
    * Initializes user and permission information if a token is present.
    * You can alter this method or skip it if you store user information
    * and permission in an external database. Then i would recommend a
    * VimeoAuthRequest::checkLoogin for confirmation.
    * 
    * @access   private
    * @return   void
    */
    private function updateAuthentication() {
        if(self::$sToken && (!self::$ePermission || !self::$oUser)) {
            $oResponse = VimeoAuthRequest::checkToken(self::$sToken);
            
            // Parse user
            self::$oUser = $oResponse->getUser();
            
            // Parse permission
            self::$ePermission = $oResponse->getPermission();
        }
    }
    
    /**
    * Check permission
    * 
    * Checks the current user permission with the given one. This will be
    * heavily used by the executeRemoteCall method to ensure the user
    * will not run into trouble.
    * 
    * @access   public
    * @param    string      Needed Permission
    * @return   boolean     TRUE if access can be granted, FALSE if permission denied
    */
    public function checkPermission($ePermissionNeeded) {
        // Update authentication data before permission check
        self::updateAuthentication();
        
        // Permission DELETE check
        if($ePermissionNeeded == self::PERMISSION_DELETE && self::$ePermission == self::PERMISSION_DELETE) {
            return true;
        }
        
        // Permission WRITE check
        if($ePermissionNeeded == self::PERMISSION_WRITE && (self::$ePermission == self::PERMISSION_DELETE || self::$ePermission == self::PERMISSION_WRITE)) {
            return true;
        }
        
        // Permission READ check
        if($ePermissionNeeded == self::PERMISSION_READ && (self::$ePermission == self::PERMISSION_DELETE || self::$ePermission == self::PERMISSION_WRITE || self::$ePermission == self::PERMISSION_READ)) {
            return true;
        }
        
        return false;
    }
    
    /**
    * Proxy for API queries
    * 
    * Will check permission for the requested API method as well as type
    * of the object result response or exception. Will call the given
    * API query handler method (default: executeRemoteCall_CURL) for
    * the raw connection stuff
    * 
    * @access   public
    * @param    string          API method name
    * @param    array           Additional arguments that need to be passed to the API
    * @return   VimeoResponse   Response object of API corresponding query (for vimeo.test.login you will get VimeoTestLoginResponse object)
    */
    public function executeRemoteCall($sMethod, $aArgs = array()) {
        // Get exception handler
        $sExceptionClass = VimeoMethod::getExceptionObjectForMethod($sMethod);
        
        // Check for errors in parameters
        $sTargetClass = VimeoMethod::getTargetObjectForMethod($sMethod);
        
        // Get the permission needed to run this method
        $ePermissionNeeded = VimeoMethod::getPermissionRequirementForMethod($sMethod);
        
        // If permission requirement is not met refuse to even call the API, safes bandwith for both ends
        if($ePermissionNeeded != VimeoBase::PERMISSION_NONE && !self::checkPermission($ePermissionNeeded)) {
            throw new $sExceptionClass('Permission error: "' . VimeoMethod::getPermissionRequirementForMethod($sMethod) . '" needed, "' . self::$ePermission . '" given');
        }
        
        // Append method to request arguments
        $aArgs['method'] = $sMethod;
        
        // Check that the API query handler method exists and can be called
        if(!method_exists(__CLASS__, self::REQUEST_ENGINE_CURL)) {
            throw new VimeoBaseException('Internal error: Request engine handler method not found', 2);
        }
        
        // Build up the needed API arguments

        // Set API key
        $aArgs['api_key']       = self::$sApiKey;
        
        // Set request format
        $aArgs['format']        = 'php';

        // Set token
        if(self::$sToken) $aArgs['auth_token'] = self::$sToken;
        
        // Generate signature
        $aArgs['api_sig']       = self::buildSignature($aArgs);

        // Do the request
        $aResponse = call_user_func(array(__CLASS__, self::REQUEST_ENGINE_CURL), $aArgs);

        // Debug request
        if(defined('VIMEO_DEBUG_REQUEST') && VIMEO_DEBUG_REQUEST) {
            self::debug('API request', print_r($aArgs, true));
        }
        
        // Debug response
        if(defined('VIMEO_DEBUG_RESPONSE') && VIMEO_DEBUG_RESPONSE) {
            self::debug('API response', print_r($aResponse, true));
        }
        
        // Transform the result into a result class
        $oResult = new $sTargetClass($aResponse);
        
        // Check if request was successfull
        if(!$oResult->getStatus()) {
            // If not, create an given exception class for the given method and pass through error code and message
            throw new $sExceptionClass($oResult->getError()->getMessage(), $oResult->getError()->getCode());
        }
        
        // Return the base class object instance for the corresponding API query
        return $oResult;
    }
    
    /**
    * Execute raw API query with CURL
    * 
    * Implements CURL API queries in php format response
    * 
    * @author   Ted Roden
    * @access   private
    * @param    array       Additional arguments for the API query
    * @return   stdClass    Simple PHP object enclosing the API result
    */
    private function executeRemoteCall_CURL($aArgs) {
        $ch = curl_init(self::VIMEO_REST_URL);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs);
        curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME);

        $data = curl_exec($ch);
        if(curl_errno($ch))
            throw new VimeoRequestException('executeRemoteCall_CURL error: ' . curl_error($ch), curl_errno($ch));
        else {
            curl_close($ch);
            
            if(!$data || strlen(trim($data)) < 2) {
                throw new VimeoRequestException('API request error: No result returned.', 1);
            }
            return unserialize($data);
        }
    }
    
    /**
    * Execute raw API query with FSOCK
    * 
    * Implements FSOCK API queries in php format response
    * 
    * @access   private
    * @param    array       Additional arguemnts for the API query
    * @return   stdClass    Simple PHP object enclosing the API result
    */
    private function executeRemoteCall_FSOCK($aArgs) {
        $sResponse = file_get_contents(self::VIMEO_REST_URL, NULL, stream_context_create(array('http' => array('method' => 'POST', 'header'=> 'Content-type: application/x-www-form-urlencoded', 'content' => http_build_query($aArgs)))));
        if(!$sResponse || strlen(trim($sResponse)) < 2) {
            throw new VimeoRequestException('API request error: No result returned.', 1);
        } else {
            return unserialize($sResponse);
        }
    }

    /**
    * Proxy for video uploads
    * 
    * Will call the given video upload handler method (default: executeVideopostCall_FSOCK)
    * for the raw connection and send stuff
    * 
    * @access   public
    * @param    string          Local filename to be transfered
    * @param    string          Ticket
    * @return   string          VimeoVideosCheckUploadStatusResponse
    */
    public function executeVideopostCall($sFilename, $sTicket = false) {
        // Check that the upload query handler method exists and can be called
        if(!method_exists(__CLASS__, self::VIDEOPOST_ENGINE_FSOCK)) {
            throw new VimeoUploadException('Upload error: Videopost engine handler method not found', 1);
        }
        
        // If permission requirement is not met refuse to even call the API, safes bandwith for both ends
        if(!self::checkPermission(VimeoBase::PERMISSION_WRITE)) {
            throw new VimeoUploadException('Upload error: Missing "write" permission for current user', 2);
        }

        // Check that the file exists
        if(!file_exists($sFilename)) {
            throw new VimeoUploadException('Upload error: Local file does not exists', 3);
        }
        
        // Check that the file is readable
        if(!is_readable($sFilename)) {
            throw new VimeoUploadException('Upload error: Local file is not readable', 4);
        }
        
        // Check that the file size is not larger then the allowed size you can upload
        $oResponse = VimeoPeopleRequest::getUploadStatus();
        if(filesize($sFilename) > $oResponse->getRemainingBytes()) {
            throw new VimeoUploadException('Upload error: Videosize exceeds remaining bytes', 5);
        }
        
        // Try to get a upload ticket
        if(!$sTicket) {
            $oResponse = VimeoVideosRequest::getUploadTicket();
            $sTicket = $oResponse->getTicket();
        }
        
        // Build up the needed API arguments

        // Set API key
        $aArgs['api_key']       = self::$sApiKey;
        
        // Set request format
        $aArgs['format']        = 'php';

        // Set token
        if(self::$sToken) $aArgs['auth_token'] = self::$sToken;
        
        // Set ticket
        $aArgs['ticket_id']     = $sTicket;
        
        // Generate signature
        $aArgs['api_sig']       = self::buildSignature($aArgs);
        
        // Set file
        $aArgs['file']          = "@$sFilename";
        
        // Do the upload
        $sResponse = call_user_func(array(__CLASS__, self::VIDEOPOST_ENGINE_FSOCK), $aArgs);

        // Call vimeo.videos.checkUploadStatus to prevent abandoned status
        return VimeoVideosRequest::checkUploadStatus($sTicket);
    }
    
    private function executeVideopostCall_CURL($aArgs) {
        // Disable time limit
        set_time_limit(0);
        
        $ch = curl_init(self::VIMEO_UPLOAD_URL);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs);
        curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME);

        $data = curl_exec($ch);
        if(curl_errno($ch))
            throw new VimeoRequestException('executeRemoteCall_CURL error: ' . curl_error($ch), curl_errno($ch));
        else {
            curl_close($ch);
            return unserialize($data);
        }
    }
    
    /**
    * Build API query signature
    * 
    * Composes the signature needed to verify its really us doing the query
    * 
    * @author   Ted Roden
    * @access   private
    * @param    array       Additional arguments for the API query
    * @return   string      MD5 signature
    */
    private static function buildSignature($aArgs) {
        $s = '';
        
        // sort by name
        ksort($aArgs);

        foreach($aArgs as $k => $v) 
            $s .= $k . $v;

        return(md5(self::$sApiSecret . $s));    
    }
    
    /**
    * Build authentication URL
    * 
    * Easy way to build a correct authentication url. You can use this
    * to link the user directly to the correct vimeo authentication page.
    * 
    * @access   public
    * @param    string      Permission level you need the user to give you (i.e. VimeoBase::PERMISSION_READ)
    * @return   string      URL you can use to directly link the user to the vimeo authentication page
    */
    public static function buildAuthenticationUrl($ePermission) {
        
        $aArgs = array(
            'api_key' => self::$sApiKey,
            'perms' => $ePermission
        );
        
        return self::VIMEO_AUTH_URL . '?api_key=' . self::$sApiKey . '&perms=' . $ePermission . '&api_sig=' . self::buildSignature($aArgs);
    }
    
    /**
    * Get current logged in user token
    * 
    * @access   public
    * @return   string      Token or FALSE if not logged in
    */
    public static function getToken() {
        return self::$sToken;
    }
    
    /**
    * Set current logged in user token
    * 
    * @access   public
    * @param    string      Authentication token
    * @return   void
    */
    public static function setToken($sToken) {
        self::$sToken = $sToken;
    }
    
    /**
    * Clear current logged in user token
    * 
    * Removes the current logged in user from the cache. Next API query
    * will be made as clean, not logged in, request.
    * 
    * @access   public
    * @return   void
    */
    public static function clearToken() {
        self::$sToken = false;
    }
    
    /**
    * Execute a permit request
    * 
    * ONLY USED IN SITE-MODE, see howto.autologin.php
    * Permits the current CURL cached user with your vimeo API application
    * 
    * @access   public
    * @param    string      Permission
    * @return   string      Vimeo Token
    */
    public function permit($ePermission) {
        // Disable time limit
        set_time_limit(0);
        
        // Construct login data
        $aArgs = array(
            'api_key' => VimeoBase::$sApiKey,
            'perms' => $ePermission,
            'accept' => 'yes'
        );
        $ch = curl_init(VimeoBase::buildAuthenticationUrl($ePermission));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs);
        curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_COOKIEFILE, VimeoBase::COOKIE_FILE);
        curl_setopt($ch, CURLOPT_COOKIEJAR, VimeoBase::COOKIE_FILE);
        
        $sPageContent = curl_exec($ch);
        if(curl_errno($ch)) {
            throw new VimeoRequestException('Error: Tried to login failed ' . curl_error($ch), curl_errno($ch));
            return false;
        } else {
            $sResponseUrl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
            
        }
        return $sPageContent;
    }
    
    /**
    * Ensures that the user is logged in
    * 
    * ONLY USED IN SITE-MODE, see howto.autologin.php
    * Ensures the site-account is logged in
    * 
    * @access   public
    * @param    string          Username
    * @param    string          Password
    * @return   boolean         TRUE if user could be logged in, FALSE if an error occured (try manually to see error)
    */
    public function login($sUsername, $sPassword) {
        // Disable time limit
        set_time_limit(0);
        
        // Construct login data
        $aArgs = array(
            'sign_in[email]' => $sUsername,
            'sign_in[password]' => $sPassword,
            'redirect' => ''
        );
        
        $ch = curl_init(VimeoBase::VIMEO_LOGIN_URL);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $aArgs);
        curl_setopt($ch, CURLOPT_USERAGENT, self::PROJECT_NAME);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_COOKIEFILE, VimeoBase::COOKIE_FILE);
        curl_setopt($ch, CURLOPT_COOKIEJAR, VimeoBase::COOKIE_FILE);
        
        $sPageContent = curl_exec($ch);
        
        if(curl_errno($ch)) {
            throw new VimeoRequestException('Error: Tried to login failed ' . curl_error($ch), curl_errno($ch));
            return false;
        } else {
            $sResponseUrl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
            curl_close($ch);
        }                           
        
        if(stristr($sResponseUrl, 'log_in') !== false) {
            // Login failed
            return false;
        } else {
            return true;
        }
    }
}

/**
* Vimeo base exception class
*
* Every exception caused by VimeoBase class will be of this type
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoBaseException extends VimeoException {}

/**
* Vimeo request exception class
*
* Exception thrown when requesting the API failed
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoRequestException extends VimeoException {}

/**
* Vimeo upload exception class
*
* Exception thrown when uploading a video failed
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoUploadException extends VimeoException {}

/**
* Vimeo API method handler class
*
* This class will ensure that only functions can be called if the method is implemented
* and the permission is right (p). It also states what the source (s), result (t) and
* exception (e) object will be.
* 
* @package     SimpleVimeo
* @subpackage  Base
*/

class VimeoMethod {
    
    private static $aMethods = array(
        // Vimeo Test methods
        'vimeo.test.login'                  => array(       's' => 'VimeoTestRequest',
                                                            't' => 'VimeoTestLoginResponse',
                                                            'e' => 'VimeoTestLoginException',
                                                            'p' => VimeoBase::PERMISSION_READ),
        
        'vimeo.test.echo'                   => array(       's' => 'VimeoTestRequest',
                                                            't' => 'VimeoTestEchoResponse',
                                                            'e' => 'VimeoTestEchoException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.test.null'                   => array(       's' => 'VimeoTestRequest',
                                                            't' => 'VimeoTestNullResponse',
                                                            'e' => 'VimeoTestNullException',
                                                            'p' => VimeoBase::PERMISSION_READ),
                                                            
        // Vimeo Auth methods
        'vimeo.auth.getToken'               => array(       's' => 'VimeoAuthRequest',
                                                            't' => 'VimeoAuthGetTokenResponse',
                                                            'e' => 'VimeoAuthGetTokenException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.auth.getFrob'                => array(       's' => 'VimeoAuthRequest',
                                                            't' => 'VimeoAuthGetFrobResponse',
                                                            'e' => 'VimeoAuthGetFrobException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.auth.checkToken'             => array(       's' => 'VimeoAuthRequest',
                                                            't' => 'VimeoAuthCheckTokenResponse',
                                                            'e' => 'VimeoAuthCheckTokenException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
        
        // Vimeo Videos methods
        'vimeo.videos.getList'              => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetListResponse',
                                                            'e' => 'VimeoVideosGetListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.videos.getUploadedList'      => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetUploadedListResponse',
                                                            'e' => 'VimeoVideosGetUploadedListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.videos.getAppearsInList'     => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetAppearsInListResponse',
                                                            'e' => 'VimeoVideosGetAppearsInListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.videos.getSubscriptionsList' => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetSubscriptionsListResponse',
                                                            'e' => 'VimeoVideosGetSubscriptionsListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.videos.getListByTag'         => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetListByTagResponse',
                                                            'e' => 'VimeoVideosGetListByTagException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.videos.getLikeList'          => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetLikeListResponse',
                                                            'e' => 'VimeoVideosGetLikeListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.videos.getContactsList'      => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetContactsListResponse',
                                                            'e' => 'VimeoVideosGetContactsListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.videos.getContactsLikeList'  => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetContactsLikeListResponse',
                                                            'e' => 'VimeoVideosGetContactsLikeListException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.videos.search'               => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosSearchResponse',
                                                            'e' => 'VimeoVideosSearchException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.videos.getInfo'              => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetInfoResponse',
                                                            'e' => 'VimeoVideosGetInfoException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.videos.getUploadTicket'      => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosGetUploadTicketResponse',
                                                            'e' => 'VimeoVideosGetUploadTicketException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),

        'vimeo.videos.checkUploadStatus'    => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosCheckUploadStatusResponse',
                                                            'e' => 'VimeoVideosCheckUploadStatusException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),
                                                            
        'vimeo.videos.delete'               => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosDeleteResponse',
                                                            'e' => 'VimeoVideosDeleteException',
                                                            'p' => VimeoBase::PERMISSION_DELETE),

        'vimeo.videos.setTitle'             => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosSetTitleResponse',
                                                            'e' => 'VimeoVideosSetTitleException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),

        'vimeo.videos.setCaption'           => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosSetCaptionResponse',
                                                            'e' => 'VimeoVideosSetCaptionException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),
                                                            
        'vimeo.videos.setFavorite'          => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosSetFavoriteResponse',
                                                            'e' => 'VimeoVideosSetFavoriteException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),
                                                            
        'vimeo.videos.addTags'              => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosAddTagsResponse',
                                                            'e' => 'VimeoVideosAddTagsException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),
                                                            
        'vimeo.videos.removeTag'            => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosRemoveTagResponse',
                                                            'e' => 'VimeoVideosRemoveTagException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),

        'vimeo.videos.clearTags'            => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosClearTagsResponse',
                                                            'e' => 'VimeoVideosClearTagsException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),

        'vimeo.videos.setPrivacy'           => array(       's' => 'VimeoVideosRequest',
                                                            't' => 'VimeoVideosSetPrivacyResponse',
                                                            'e' => 'VimeoVideosSetPrivacyException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),

        // Vimeo People methods
        'vimeo.people.findByUserName'       => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleFindByUsernameResponse',
                                                            'e' => 'VimeoPeopleFindByUsernameException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.people.findByEmail'          => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleFindByEmailResponse',
                                                            'e' => 'VimeoPeopleFindByEmailException',
                                                            'p' => VimeoBase::PERMISSION_NONE),

        'vimeo.people.getInfo'              => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleGetInfoResponse',
                                                            'e' => 'VimeoPeopleGetInfoException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
                                                            
        'vimeo.people.getPortraitUrl'       => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleGetPortraitUrlResponse',
                                                            'e' => 'VimeoPeopleGetPortraitUrlException',
                                                            'p' => VimeoBase::PERMISSION_NONE),
        
        'vimeo.people.addContact'           => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleAddContactResponse',
                                                            'e' => 'VimeoPeopleAddContactException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),
                                                            
        'vimeo.people.removeContact'        => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleRemoveContactResponse',
                                                            'e' => 'VimeoPeopleRemoveContactException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),
                                                            
        'vimeo.people.getUploadStatus'      => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleGetUploadStatusResponse',
                                                            'e' => 'VimeoPeopleGetUploadStatusException',
                                                            'p' => VimeoBase::PERMISSION_READ),

        'vimeo.people.addSubscription'      => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleAddSubscriptionResponse',
                                                            'e' => 'VimeoPeopleAddSubscriptionException',
                                                            'p' => VimeoBase::PERMISSION_WRITE),

        'vimeo.people.removeSubscription'   => array(       's' => 'VimeoPeopleRequest',
                                                            't' => 'VimeoPeopleRemoveSubscriptionResponse',
                                                            'e' => 'VimeoPeopleRemoveSubscriptionException',
                                                            'p' => VimeoBase::PERMISSION_WRITE)
    );
        
    public static function getSourceObjectForMethod($sMethod) {
        // Check if the method can be handled
        self::checkMethod($sMethod);
        
        return self::$aMethods[$sMethod]['s'];
    }
    
    public static function getTargetObjectForMethod($sMethod) {
        // Check if the method can be handled
        self::checkMethod($sMethod);
        
        return self::$aMethods[$sMethod]['t'];
    }
    
    public static function getExceptionObjectForMethod($sMethod) {
        // Check if the method can be handled
        self::checkMethod($sMethod);
        
        return self::$aMethods[$sMethod]['e'];
    }

    public static function getPermissionRequirementForMethod($sMethod) {
        // Check if the method can be handled
        self::checkMethod($sMethod);
        
        return self::$aMethods[$sMethod]['p'];
    }
    
    public static function checkMethod($sMethod) {
        // Check if the method can be handled
        if(!isset(self::$aMethods[$sMethod])) {
            throw new VimeoMethodException('Unhandled vimeo method "' . $sMethod . '" given', 2);
        }
    }
}

/**
* Vimeo method exception class
*
* Every exception caused by VimeoMethod class will be of this type
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoMethodException extends Exception {}

/*
* Abstract class constructs that the whole api stuff will be based on
*/

/**
* Vimeo exception class
*
* Every exception the whole SimpleVimeo throws will be extended of this base
* class. You can extend this one to alter all exceptions.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
* @abstract
*/

abstract class VimeoException extends Exception {}

/**
* Vimeo array of object handler class
* 
* This class is for array of object handling. i.e.: An array of video objects.
* It ensures that you can work with foreach and count without getting into a hassle.
* 
* @package      SimpleVimeo
* @subpackage   Base
* @abstract
*/

abstract class VimeoObjectList implements Iterator, Countable {
    /**
    * Array for instanced objects
    * @var  array
    */
    private $aInstances = array();
    
    /**
    * Integer how many results
    * @var  integer
    */
    private $iCount = 0;
    
    /**
    * Class name
    * @var  string
    */
    private $sClassName;
    
    private $aIDs = array();
    
    /**
    * Constructor
    * 
    * @access   public
    * @return   void
    */
    public function __construct() {
        // Parse class name
        $this->sClassName = str_replace('List', '', get_class($this));
    }
    
    /**
    * Add object to array
    * 
    * @access   public
    * @param    object      Object to be added to array
    * @param    integer     Array index to be used for the given object
    * @return   void
    */
    public function add($oObject, $iID = false) {
        if($iID !== false) {
            $this->aInstances[$iID] = $oObject;
        } else {
            $this->aInstances[] = $oObject;
        }
        
        $this->aIDs[] = $iID;
        
        $this->iCount++;
    }

    /**
    * Returns all array indexes for further parsing
    * 
    * @access   public
    * @return   array       Array with object array indexes
    */
    public function getAllUniqueIDs() {
        return $this->getIDs();
    }
    
    /**
    * @ignore
    */
    public function rewind() {
        reset($this->aInstances);
    }
    
    /**
    * @ignore
    */
    public function current() {
        return current($this->aInstances);
    }
    
    /**
    * @ignore
    */
    public function key() {
        return key($this->aInstances);
    }
    
    /**
    * @ignore
    */
    public function next() {
        return next($this->aInstances);
    }
    
    /**
    * @ignore
    */
    public function valid() {
        return $this->current() !== FALSE;
    }
    
    /**
    * @ignore
    */
    public function count() {
        return $this->iCount;
    }
}

/**
* Vimeo request class
*
* Every API query collection class will be based on this.
* 
* @package     SimpleVimeo
* @subpackage  ApiRequest
* @abstract
*/

abstract class VimeoRequest {}

/**
* Vimeo response class
*
* Every API response class will be based on this. It also handles
* everytime response variables like if the query was successfull and
* the generation time.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
* @abstract
*/

abstract class VimeoResponse {
    private $bStatus = false;
    private $fPerformance = false;
    private $iErrorCode = false;
    private $oError = false;
    
    /**
    * Constructor
    * 
    * Parses the API response
    * You dont need to pass a response if you need to give a hint your coding tool for code completion
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        if($aResponse) {
            // Parse status
            $this->setStatus($aResponse->stat);
            
            // Parse performance
            $this->fPerformance = (float) $aResponse->generated_in;
            
            // Parse error information
            if(!$this->bStatus) {
                $this->oError = new VimeoErrorEntity($aResponse->err->code, $aResponse->err->msg);
            }
        }
    }
    
    private function setStatus($sStatus) {
        if($sStatus === 'ok') {
            $this->bStatus = true;
        }
    }
    
    public function getStatus() {
        return $this->bStatus;
    }
    
    public function getPerformance() {
        return $this->fPerformance;
    }
    
    public function getError() {
        return $this->oError;
    }
}

/*
* Entity classes for default instances of users etc. they are always the same
* and their array of object handlers
*/

/**
* Vimeo API error entity class
*
* Implements API delivered error entities into an PHP 5 object with given result parameters.
* 
* @package     SimpleVimeo
* @subpackage  Entities
*/

class VimeoErrorEntity {
    private $iErrorCode = false;
    private $sErrorMessage = false;
    
    public function __construct($iErrorCode, $sErrorMessage) {
        $this->iErrorCode = $iErrorCode;
        $this->sErrorMessage = $sErrorMessage;
    }
    
    public function getCode() {
        return $this->iErrorCode;
    }
    
    public function getMessage() {
        return $this->sErrorMessage;
    }
}

/**
* Vimeo API user entity class
*
* Implements API delivered user entities into an PHP 5 object with given result parameters.
* 
* @package     SimpleVimeo
* @subpackage  Entities
*/

class VimeoUserEntity {
    private $iUserNsId = false;
    private $iUserId = false;
    private $sUsername = false;
    private $sFullname = false;
    
    // Optional information when vimeo.person.getInfo is called
    private $sLocation = false;
    private $sUrl = false;
    private $iNumberOfContacts = false;
    private $iNumberOfUploads = false;
    private $iNumberOfLikes = false;
    private $iNumberOfVideos = false;
    private $iNumberOfVideosAppearsIn = false;
    private $sProfileUrl = false;
    private $sVideosUrl = false;
    
    public function __construct($aResponseSnippet) {
        if(isset($aResponseSnippet->id)) {
            $this->iUserId = $aResponseSnippet->id;
        }
        
        if(isset($aResponseSnippet->nsid)) {
            $this->iUserNsId = $aResponseSnippet->nsid;
        }
        
        if(isset($aResponseSnippet->username)) {
            $this->sUsername = $aResponseSnippet->username;
        }
        
        if(isset($aResponseSnippet->fullname)) {
            $this->sFullname = $aResponseSnippet->fullname;
        }
        
        if(isset($aResponseSnippet->display_name)) {
            $this->sFullname = $aResponseSnippet->display_name;
        }
        
        // Optional stuff
        if(isset($aResponseSnippet->location)) {
            $this->sLocation = $aResponseSnippet->location;
        }
        
        if(isset($aResponseSnippet->url)) {
            $this->sUrl = $aResponseSnippet->url;
        }
        
        if(isset($aResponseSnippet->number_of_contacts)) {
            $this->iNumberOfContacts = $aResponseSnippet->number_of_contacts;
        }
        
        if(isset($aResponseSnippet->number_of_uploads)) {
            $this->iNumberOfUploads = $aResponseSnippet->number_of_uploads;
        }
        
        if(isset($aResponseSnippet->number_of_likes)) {
            $this->iNumberOfLikes = $aResponseSnippet->number_of_likes;
        }
        
        if(isset($aResponseSnippet->number_of_videos)) {
            $this->iNumberOfVideos = $aResponseSnippet->number_of_videos;
        }
        
        if(isset($aResponseSnippet->number_of_videos_appears_in)) {
            $this->iNumberOfVideosAppearsIn = $aResponseSnippet->number_of_videos_appears_in;
        }
        
        if(isset($aResponseSnippet->profileurl)) {
            $this->sProfileUrl = $aResponseSnippet->profileurl;
        }

        if(isset($aResponseSnippet->videosurl)) {
            $this->sVideosUrl = $aResponseSnippet->videosurl;
        }
    }
    
    public function getNsID() {
        return $this->iUserNsId;
    }

    public function getID() {
        return $this->iUserId;
    }
    
    public function getUsername() {
        return $this->sUsername;
    }
    
    public function getFullname() {
        return $this->sFullname;
    }
    
    public function getLocation() {
        return $this->sLocation;
    }
    
    public function getUrl() {
        return $this->sUrl;
    }
    
    public function getNumberOfContacts() {
        return $this->iNumberOfContacts;
    }
    
    public function getNumberOfUploads() {
        return $this->iNumberOfUploads;
    }
    
    public function getNumberOfLikes() {
        return $this->iNumberOfLikes;
    }
    
    public function getNumberOfVideos() {
        return $this->iNumberOfVideos;
    }
    
    public function getNumberOfVideosAppearsIn() {
        return $this->iNumberOfVideosAppearsIn;
    }
    
    public function getProfileUrl() {
        return $this->sProfileUrl;
    }
    
    public function getVideosUrl() {
        return $this->sVideosUrl;
    }
}

/**
* Vimeo API video entity class
*
* Implements API delivered video into an PHP 5 object with given result parameters.
* 
* @package     SimpleVimeo
* @subpackage  Entities
*/

class VimeoVideoEntity {
    private $iID = false;
    private $ePrivacy = false;
    private $bIsUploading = false;
    private $bIsTranscoding = false;
    private $bIsHD = false;
    
    private $sTitle = false;
    private $sCaption = false;
    private $iUploadTime = false;
    private $iNumberOfLikes = false;
    private $iNumberOfPlays = false;
    private $iNumberOfComments = false;

    private $sUrl = false;
        
    private $iWidth = false;
    private $iHeight = false;
    private $oOwner = false;
    
    private $oTagList = false;
    
    private $oThumbnailList = false;
    
    public function __construct($aResponseSnippet = false) {
        if($aResponseSnippet) {
            // Set basic information
            $this->iID = $aResponseSnippet->id;
            $this->ePrivacy = $aResponseSnippet->privacy;
            $this->bIsUploading = $aResponseSnippet->is_uploading;
            $this->bIsTranscoding = $aResponseSnippet->is_transcoding;
            $this->bIsHD = $aResponseSnippet->is_hd;
            
            $this->sTitle = $aResponseSnippet->title;
            $this->sCaption = $aResponseSnippet->caption;
            $this->iUploadTime = strtotime($aResponseSnippet->upload_date);
            $this->iNumberOfLikes = (int) $aResponseSnippet->number_of_likes;
            $this->iNumberOfPlays = (int) $aResponseSnippet->number_of_plays;
            $this->iNumberOfComments = (int) $aResponseSnippet->number_of_comments;
            
            $this->sUrl = $aResponseSnippet->urls->url->_content;
            
            $this->iWidth = (int) $aResponseSnippet->width;
            $this->iHeight = (int) $aResponseSnippet->height;
            
            $this->oOwner = new VimeoUserEntity($aResponseSnippet->owner);
            
            // Parse Tags
            $this->oTagList = new VimeoTagList();
            if(isset($aResponseSnippet->tags->tag)) {
                foreach($aResponseSnippet->tags->tag as $aTagInformation) {
                    $oTag = new VimeoTagEntity($aTagInformation);
                    $this->oTagList->add($oTag, $oTag->getID());
                }
            }
            
            // Parse Thumbnails
            $this->oThumbnailList = new VimeoThumbnailList();
            if(isset($aResponseSnippet->thumbnails->thumbnail)) {
                foreach($aResponseSnippet->thumbnails->thumbnail as $aThumbnailInformation) {
                    $oThumbnail = new VimeoThumbnailEntity($aThumbnailInformation);
                    $this->oThumbnailList->add($oThumbnail, ($oThumbnail->getWidth() * $oThumbnail->getHeight()));
                }
            }
        }
    }
    
    public function getID() {
        return $this->iID;
    }
    
    public function getPrivacy() {
        return $this->ePrivacy;
    }
    
    public function isUploading() {
        return $this->bIsUploading;
    }
    
    public function isTranscoding() {
        return $this->bIsTranscoding;
    }
    
    public function isHD() {
        return $this->bIsHD;
    }
    
    public function getTitle() {
        return $this->sTitle;
    }
    
    public function getCaption() {
        return $this->sCaption;
    }
    
    public function getUploadTimestamp() {
        return $this->iUploadTime;
    }
    
    public function getNumberOfLikes() {
        return (int) $this->iNumberOfLikes;
    }
    
    public function getNumberOfPlays() {
        return (int) $this->iNumberOfPlays;
    }
    
    public function getNumberOfComments() {
        return (int) $this->iNumberOfComments;
    }
    
    public function getWidth() {
        return (int) $this->iWidth;
    }
    
    public function getHeight() {
        return (int) $this->iHeight;
    }
    
    public function getOwner() {
        return $this->oOwner;
    }
    
    public function getTags() {
        return $this->oTagList;
    }
    
    public function getUrl() {
        return $this->sUrl;
    }
    
    public function getThumbnails() {
        return $this->oThumbnailList;
    }
}

/**
* Vimeo API video list class
*
* Implements API delivered video list entities into an PHP 5 array of objects.
* 
* @package     SimpleVimeo
* @subpackage  Lists
*/

class VimeoVideoList extends VimeoObjectList {}

/**
* Vimeo API tag entity class
*
* Implements API delivered tag entities into an PHP 5 object with given result parameters.
* 
* @package     SimpleVimeo
* @subpackage  Entities
*/

class VimeoTagEntity {
    private $iID = false;
    private $sContent = false;
    
    public function __construct($aResponseSnippet = false) {
        if($aResponseSnippet) {
            $this->iID = $aResponseSnippet->id;
            $this->sContent = $aResponseSnippet->_content;
        }
    }
    
    public function getID() {
        return $this->iID;
    }
    
    public function getTag() {
        return $this->sContent;
    }
}

/**
* Vimeo API tag list class
*
* Implements API delivered tag list entities into an PHP 5 array of objects.
* 
* @package     SimpleVimeo
* @subpackage  Lists
*/

class VimeoTagList extends VimeoObjectList {}

/**
* Vimeo API thumbnail entity class
*
* Implements API delivered thumbnail entities into an PHP 5 object with given result parameters.
* 
* @package     SimpleVimeo
* @subpackage  Entities
*/

class VimeoThumbnailEntity {
    private $iWidth = false;
    private $iHeight = false;
    private $sContent = false;
    
    public function __construct($aResponseSnippet = false) {
        if($aResponseSnippet) {
            $this->iWidth = (int) $aResponseSnippet->width;
            $this->iHeight = (int) $aResponseSnippet->height;
            $this->sContent = $aResponseSnippet->_content;
        }
    }
    
    public function getWidth() {
        return (int) $this->iWidth;
    }
    
    public function getHeight() {
        return (int) $this->iHeight;
    }
    
    public function getImageContent() {
        return $this->sContent;
    }
}

/**
* Vimeo API thumbnail list class
*
* Implements API delivered thumbnail list entities into an PHP 5 array of objects.
* 
* @package     SimpleVimeo
* @subpackage  Lists
*/

class VimeoThumbnailList extends VimeoObjectList {
    public function getByWidth($iWidth, $bAlsoLower = false) {
        /**
        * @todo
        */
    }
    
    public function getByHeight($iHeight, $bAlsoLower = false) {
        /**
        * @todo
        */
    }
    
    public function getByWidthAndHeight($iWidth, $iHeight, $bAlsoLower = false) {
        /**
        * @todo
        */
    }
}


/*
* vimeo.test.* methods
*/

/**
* Vimeo Test request handler class
*
* Implements all API queries in the vimeo.test.* category
* 
* @package     SimpleVimeo
* @subpackage  ApiRequest
*/

class VimeoTestRequest extends VimeoRequest {
    
    /**
    * Is the user logged in?
    * 
    * @access   public
    * @return   VimeoTestLoginResponse 
    */
    
    public function login() {
        return VimeoBase::executeRemoteCall('vimeo.test.login');
    }
    
    /**
    * This will just repeat back any parameters that you send.
    * 
    * @access   public
    * @param    array       Additional arguments that need to be passed to the API
    * @return   VimeoTestEchoResponse
    */
    
    public function echoback($aArgs) {
        return VimeoBase::executeRemoteCall('vimeo.test.echo', $aArgs);
    }
    
    /**
    * This is just a simple null/ping test...
    * 
    * @access   public
    * @return   VimeoTestNullResponse 
    */
    
    public function ping() {
        return VimeoBase::executeRemoteCall('vimeo.test.null');
    }
}

/**
* Vimeo Test Login response handler class
*
* Handles the API response for vimeo.test.login queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoTestLoginResponse extends VimeoResponse {}

/**
* Vimeo Test Login exception handler class
*
* Handles exceptions caused by API response for vimeo.test.login queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoTestLoginException extends VimeoException {}

/**
* Vimeo Test Echo response handler class
*
* Handles the API response for vimeo.test.echo queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoTestEchoResponse extends VimeoResponse {
    private $aArgs = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->aArgs = get_object_vars($aResponse);
        
        // Unset default response stuff
        if(isset($this->aArgs['stat'])) unset($this->aArgs['stat']);
        if(isset($this->aArgs['generated_in'])) unset($this->aArgs['generated_in']);
    }
    
    /**
    * Returns an array of variables the request bounced back
    * 
    * @access   public
    * @return   array       Echoed variables
    */
    public function getResponseArray() {
        return $this->aArgs;
    }
}

/**
* Vimeo Test Echo exception handler class
*
* Handles exceptions caused by API response for vimeo.test.echo queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoTestEchoException extends VimeoException {}

/**
* Vimeo Test Null response handler class
*
* Handles the API response for vimeo.test.null queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoTestNullResponse extends VimeoResponse {}

/**
* Vimeo Test Null exception handler class
*
* Handles exceptions caused by API response for vimeo.test.null queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoTestNullException extends VimeoException {}

/*
* vimeo.auth.* methods
*/

/**
* Vimeo Auth request handler class
*
* Implements all API queries in the vimeo.auth.* category
* 
* @package     SimpleVimeo
* @subpackage  ApiRequest
*/

class VimeoAuthRequest extends VimeoRequest {
    
    /**
    * Get Token
    * 
    * @access   public
    * @param    string      Frob taken from the vimeo authentication
    * @return   VimeoAuthGetTokenResponse
    */
    public function getToken($sFrob) {
        $aArgs = array(
            'frob' => $sFrob
        );
        
        return VimeoBase::executeRemoteCall('vimeo.auth.getToken', $aArgs);
    }
    
    /**
    * Check Token
    * 
    * Checks the validity of the token. Returns the user associated with it.
    * Returns the same as vimeo.auth.getToken
    * 
    * @access   public
    * @param    string      Authentication token
    * @return   VimeoAuthCheckTokenResponse
    */
    public function checkToken($sToken = false) {
        if(!$sToken) $sToken = VimeoBase::getToken();
        
        $aArgs = array(
            'auth_token' => $sToken
        );
        
        return VimeoBase::executeRemoteCall('vimeo.auth.checkToken', $aArgs);
    }
    
    /**
    * Get Frob
    * 
    * This is generally used by desktop applications. If the user doesn't already have
    * a token, you'll need to get the frob, send it to us at /services/auth. Then,
    * after the user, clicks continue on your app, you call vimeo.auth.getToken($frob)
    * and we give you the actual token. 
    * 
    * @access   public
    * @return   VimeoAuthGetFrobResponse
    */
    public function getFrob() {
        return VimeoBase::executeRemoteCall('vimeo.auth.getFrob');
    } 
}

/**
* Vimeo Auth GetToken response handler class
*
* Handles the API response for vimeo.auth.getToken queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoAuthGetTokenResponse extends VimeoResponse {
    
    private $sToken = false;
    private $ePermission = false;
    private $oUser = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse) {
        parent::__construct($aResponse);
        
        $this->sToken = $aResponse->auth->token;
        $this->ePermission = $aResponse->auth->perms;
        
        $this->oUser = new VimeoUserEntity($aResponse->auth->user);
    }
    
    /**
    * Get token value
    * 
    * @access   public
    * @return   token
    */
    public function getToken() {
        return $this->sToken;
    }
    
    /**
    * Get permission value
    * 
    * @access   public
    * @return   permission
    */
    
    public function getPermission() {
        return $this->ePermission;
    }
    
    /**
    * Get user information object
    * 
    * @access   public
    * @return VimeoUserEntity
    */
    public function getUser() {
        return $this->oUser;
    }
}

/**
* Vimeo Auth GetToken exception handler class
*
* Handles exceptions caused by API response for vimeo.auth.getToken queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoAuthGetTokenException extends Exception {}

/**
* Vimeo Auth CheckToken response handler class
*
* Handles the API response for vimeo.auth.checkToken queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoAuthCheckTokenResponse extends VimeoAuthGetTokenResponse {}

/**
* Vimeo Auth CheckToken exception handler class
*
* Handles exceptions caused by API response for vimeo.auth.checkToken queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoAuthCheckTokenException extends VimeoAuthGetTokenException {}

/**
* Vimeo Auth GetFrob response handler class
*
* Handles the API response for vimeo.auth.getFrob queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoAuthGetFrobResponse extends VimeoResponse {
    private $sFrob = false;
    
    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse) {
        parent::__construct($aResponse);
        
        $this->sFrob = $aResponse->frob;
    }
    
    /**
    * Get Frob value
    * 
    * @access   public
    * @return   frob
    */
    public function getFrob() {
        return $this->sFrob;
    }
}

/**
* Vimeo Auth GetFrob exception handler class
*
* Handles exceptions caused by API response for vimeo.auth.getFrob queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoAuthGetFrobException extends VimeoException {}

/**
* vimeo.videos.* methods
*/

/**
* Vimeo Videos request handler class
*
* Implements all API queries in the vimeo.videos.* category
* 
* @package     SimpleVimeo
* @subpackage  ApiRequest
*/

class VimeoVideosRequest extends VimeoRequest {

    const PRIVACY_ANYBODY = 'anybody';
    const PRIVACY_CONTACTS = 'contacts';
    const PRIVACY_NOBODY = 'nobody';
    const PRIVACY_USERS = 'users';
    
    /**
    * Search videos! 
    * 
    * If the calling user is logged in, this will return information that calling user
    * has access to (including private videos). If the calling user is not authenticated,
    * this will only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    string      Search query
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    boolean     If TRUE, we'll only search the users contacts. If this is set, you must specifiy a User ID. Otherwise it will be ignored without error.
    * @param    integer     ow many results per page?
    * @return VimeoVideosSearchResponse  
    */
    public function search($sQuery, $iUserID = false, $bContactsOnly = false, $iItemsPerPage = false) {
        
        // Pass query (required)
        $aArgs = array(
            'query' => $sQuery
        );
        
        // Pass user
        if($iUserID) {
            $aArgs['user_id'] = $iUserID;
        }
        
        // Pass contacts
        if($bContactsOnly) {
            $aArgs['contacts_only'] = $bContactsOnly;
        }
        
        // Pass items
        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.search', $aArgs);
    }
    
    /**
    * This gets a list of videos for the specified user.
    * 
    * This is the functionality of "My Videos" or "Ted's Videos." At the moment, this is the same list
    * as vimeo.videos.getAppearsInList. If you need uploaded or appears in, those are available too.
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetListResponse
    */
    public function getList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getList', $aArgs);
    }
    
    /**
    * This gets a list of videos uploaded by the specified user.
    * 
    * If the calling user is logged in, this will return information that calling user has access to
    * (including private videos). If the calling user is not authenticated, this will only return
    * public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetUploadedListResponse
    */
    public function getUploadedList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getUploadedList', $aArgs);
    }
    
    /**
    * This gets a list of videos that the specified user appears in. 
    * 
    * If the calling user is logged in, this will return information that calling user has access
    * to (including private videos). If the calling user is not authenticated, this will only return
    * public information, or a permission denied error if none is available. 
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetAppearsInListResponse
    */
    public function getAppearsInList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getAppearsInList', $aArgs);
    }
    
    /**
    * This gets a list of subscribed videos for a particular user.  
    * 
    * If the calling user is logged in, this will return information that calling user
    * has access to (including private videos). If the calling user is not authenticated,
    * this will only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetSubscriptionsListResponse
    */
    public function getSubscriptionsList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getSubscriptionsList', $aArgs);
    }

    /**
    * This gets a list of videos by tag    
    * 
    * If you specify a user_id, we'll only get video uploaded by that user with the specified tag.
    * If the calling user is logged in, this will return information that calling user has access
    * to (including private videos). If the calling user is not authenticated, this will only
    * return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    string      A single tag: "cat" "new york" "cheese" 
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetListByTagResponse
    */
    public function getListByTag($sTag, $iUserID = false, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'tag'       => $sTag
        );
        
        if($iUserID) {
            $aArgs['user_id'] = $iUserID;
        }
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getListByTag', $aArgs);
    }

    /**
    * Get a list of videos that the specified user likes.   
    * 
    * If the calling user is logged in, this will return information that calling user has
    * access to (including private videos). If the calling user is not authenticated, this will
    * only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetLikeListResponse
    */
    public function getLikeList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getLikeList', $aArgs);
    }
    
    /**
    * Get a list of videos made by the contacts of a specific user.
    * 
    * If the calling user is logged in, this will return information that calling user has
    * access to (including private videos). If the calling user is not authenticated, this will
    * only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetContactsListResponse
    */
    public function getContactsList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getContactsList', $aArgs);
    }
    
    /**
    * Get a list of videos that the specified users contacts like.
    * 
    * If the calling user is logged in, this will return information that calling user has
    * access to (including private videos). If the calling user is not authenticated, this will
    * only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     User ID, this can be the ID number (151542) or the username (ted)
    * @param    integer     Which page to show.
    * @param    integer     How many results per page?
    * @return   VimeoVideosGetContactsLikeListResponse
    */
    public function getContactsLikeList($iUserID, $iPage = false, $iItemsPerPage = false) {
        // Extend query
        $aArgs = array(
            'user_id'       => $iUserID
        );
        
        if($iPage) {
            $aArgs['page'] =    $iPage;
        }

        if($iItemsPerPage) {
            $aArgs['per_page'] = $iItemsPerPage;
        }
        
        // Please deliver full response so we can handle videos with unified classes
        $aArgs['fullResponse'] = 1;
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getContactsLikeList', $aArgs);
    }
    
    /**
    * Get all kinds of information about a photo.
    * 
    * If the calling user is logged in, this will return information that calling user has
    * access to (including private videos). If the calling user is not authenticated, this will
    * only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     Video ID
    * @return   VimeoVideosGetInfoResponse
    */
    public function getInfo($iVideoID) {
        // Extend query
        $aArgs = array(
            'video_id'      => $iVideoID
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.getInfo', $aArgs);
    }
    
    /**
    * Generate a new upload Ticket.
    * 
    * You'll need to pass this to the uploader. It's only good for one upload, only good for one user.
    * 
    * @access   public
    * @return   VimeoVideosGetUploadTicketResponse
    */
    public function getUploadTicket() {
        return VimeoBase::executeRemoteCall('vimeo.videos.getUploadTicket');
    }
    
    /**
    * Check the status of an upload started via the API  
    * 
    * This is how you get the video_id of a clip uploaded from the API
    * If you never call this to check in, we assume it was abandoned and don't process it
    * 
    * @access   public
    * @param    string      The ticket number of the upload
    * @return   VimeoVideosCheckUploadStatusResponse
    */
    public function checkUploadStatus($sTicket) {
        $aArgs = array(
            'ticket_id' => $sTicket
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.checkUploadStatus', $aArgs);
    }
    
    /**
    * Simple video upload
    * 
    * @access   public
    * @param    string      Absolute path to file
    * @param    string      Existing ticket or false to generate a new one
    * @return   VimeoVideosCheckUploadStatusResponse
    */
    public function doUpload($sFilename, $sTicket = false) {
        return VimeoBase::executeVideopostCall($sFilename, $sTicket);
    }
    
    /**
    * Delete a video
    * 
    * The authenticated user must own the video and have granted delete permission
    * 
    * @access   public
    * @param    integer     Video ID
    * @return   VimeoVideosDeleteResponse 
    */
    public function delete($iVideoID) {
        $aArgs = array(
            'video_id' => $iVideoID
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.delete', $aArgs);
    }
    
    /**
    * Set the title of a video (overwrites previous title)
    * 
    * @access   public
    * @param    integer     Video ID
    * @param    string      Title
    * @return   VimeoVideosSetTitleResponse
    */
    public function setTitle($iVideoID, $sVideoTitle) {
        $aArgs = array(
            'video_id' => $iVideoID,
            'title' => $sVideoTitle
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.setTitle', $aArgs);
    }
    
    /**
    * Set a new caption for a video (overwrites previous caption)
    * 
    * @access   public
    * @param    integer     Video ID
    * @param    string      Caption
    * @return   VimeoVideosSetCaptionResponse
    */
    public function setCaption($iVideoID, $sVideoCaption) {
        $aArgs = array(
            'video_id' => $iVideoID,
            'caption' => $sVideoCaption
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.setCaption', $aArgs);
    }
    
    /**
    * Set a video as a favorite.
    * 
    * @access   public
    * @param    integer     Video ID
    * @param    boolean     TRUE to favorite, FALSE to return to normal
    * @return   VimeoVideosSetFavoriteResponse
    */
    public function setFavorite($iVideoID, $bFavorite = true) {
        $aArgs = array(
            'video_id' => $iVideoID,
            'favorite' => (int) $bFavorite
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.setFavorite', $aArgs);
    }
    
    /**
    * Add specified tags to the video, this does not replace any tags.
    * 
    * Tags should be comma separated lists. 
    * 
    * If the calling user is logged in, this will return information that calling
    * user has access to (including private videos). If the calling user is not authenticated,
    * this will only return public information, or a permission denied error if none is available.
    * 
    * @access   public
    * @param    integer     Video ID
    * @param    mixed       Array with tags or Comma separated list of tags ("lions, tigers, bears")
    * @return   VimeoVideosAddTagsResponse
    */
    public function addTags($iVideoID, $mTags) {
        // Catch array of tags
        if(is_array($mTags)) {
            $mTags = implode(',', $mTags);
        }
        
        // Prepare arguments
        $aArgs = array(
            'video_id' => $iVideoID,
            'tags' => $mTags
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.addTags', $aArgs);
    }
    
    /**
    * Remove specified tag from the video.
    * 
    * @access   public
    * @param    integer     Video ID
    * @param    integer     Tag ID, this should be a tag id returned by vimeo.videos.getInfo
    * @return   VimeoVideosRemoveTagResponse
    */
    public function removeTag($iVideoID, $iTagID) {
        $aArgs = array(
            'video_id' => $iVideoID,
            'tag_id' => $iTagID
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.removeTag', $aArgs);
    }
    
    /**
    * Remove ALL of the tags from the video
    * 
    * @access   public
    * @param    integer     Video ID
    * @return   VimeoVideosClearTags 
    */
    public function clearTags($iVideoID) {
        $aArgs = array(
            'video_id' => $iVideoID
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.clearTags', $aArgs);
    }
    
    /**
    * Set the privacy of the video
    * 
    * @access   public
    * @param    integer     Video ID
    * @param    integer     Privacy enum see VimeoVideosRequest::PRIVACY_*
    * @param    mixed       Array or comma separated list of users who can view the video. PRIVACY_USERS must be set.
    */
    public function setPrivacy($iVideoID, $ePrivacy, $mUsers = array()) {
        // Catch array of users
        if(is_array($mUsers)) {
            $mUsers = implode(', ', $mUsers);
        }
        
        $aArgs = array(
            'video_id' => $iVideoID,
            'privacy' => $ePrivacy,
            'users' => $mUsers
        );
        
        return VimeoBase::executeRemoteCall('vimeo.videos.setPrivacy', $aArgs);
    }
}

/**
* Vimeo Videos Search response handler class
*
* Handles the API response for vimeo.videos.search queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/                                                 

class VimeoVideosSearchResponse extends VimeoResponse {
    private $iPage = false;
    private $iItemsPerPage = false;
    private $iOnThisPage = false;
    
    private $aoVideos = array();

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse) {
        parent::__construct($aResponse);
        
        // Parse information
        if($aResponse && isset($aResponse->videos) && $this->getStatus()) {
            // Create an video list instance
            $this->aoVideos = new VimeoVideoList();
            
            // Page information
            $this->iPage = $aResponse->videos->page;
            $this->iItemsPerPage = $aResponse->videos->perpage;
            $this->iOnThisPage = $aResponse->videos->on_this_page;
            
            // Parse videos
            if(isset($aResponse->videos->video)) {
            	// We should check if the subelement is an object (single hit) or an result array (multiple hits)
            	if(is_array($aResponse->videos->video)) {
					// We got a couple of results
					$aParseableData = $aResponse->videos->video;
            	} else {
            		// We only got one result
					$aParseableData = array(
						0 => $aResponse->videos->video
					);
            	}

            	// Parse the results
                foreach($aParseableData as $aVideoInformation) {
                    $oVideo = new VimeoVideoEntity($aVideoInformation);

                    $this->aoVideos->add($oVideo, $oVideo->getID());
                }
            }
        }
    }
    
    /**
    * Current page
    * 
    * @access   public
    * @return   integer     Page number
    */
    public function getPage() {
        return $this->iPage;
    }
    
    /**
    * Items per page
    * 
    * @access   public
    * @return   integer     Items per page
    */
    
    public function getItemsPerPage() {
        return $this->iItemsPerPage;
    }
    
    /**
    * Items on the current page
    * 
    * @access   public
    * @return   integer     Items on the current page
    */
    
    public function getOnThisPage() {
        return $this->iOnThisPage;
    }
    
    /**
    * Get array of video objects
    * 
    * @access   public
    * @return   array       Video objects
    */
    
    public function getVideos() {
        return $this->aoVideos;
    }
}

/**
* Vimeo Videos Search exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.search queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosSearchException extends VimeoException {}

/**
* Vimeo Videos GetList response handler class
*
* Handles the API response for vimeo.videos.getList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos Search exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.search queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetListException extends VimeoException {}

/**
* Vimeo Videos GetUploadedList response handler class
*
* Handles the API response for vimeo.videos.getUploadedList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetUploadedListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos GetUploadedList exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getUploadedList queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetUploadedListException extends VimeoException {}

/**
* Vimeo Videos GetAppearsInList response handler class
*
* Handles the API response for vimeo.videos.getAppearsInList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetAppearsInListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos GetAppearsInList exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getAppearsInList queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetAppearsInListException extends VimeoException {}

/**
* Vimeo Videos GetSubscriptionsList response handler class
*
* Handles the API response for vimeo.videos.getSubscriptionsList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetSubscriptionsListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos GetSubscriptionsList exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getSubscriptionsList queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetSubscriptionsListException extends VimeoException {}

/**
* Vimeo Videos GetListByTag response handler class
*
* Handles the API response for vimeo.videos.getListByTag queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetListByTagResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos GetListByTag exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getListByTag queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetListByTagException extends VimeoException {}

/**
* Vimeo Videos GetLikeList response handler class
*
* Handles the API response for vimeo.videos.getLikeList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetLikeListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos GetLikeList exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getLikeList queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetLikeListException extends VimeoException {}

/**
* Vimeo Videos GetContactsList response handler class
*
* Handles the API response for vimeo.videos.getContactsList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetContactsListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos GetContactsList exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getContactsList queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetContactsListException extends VimeoException {}

/**
* Vimeo Videos getContactsLikeList response handler class
*
* Handles the API response for vimeo.videos.getContactsLikeList queries.
* Currently the response is exact the same as vimeo.videos.search
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosgetContactsLikeListResponse extends VimeoVideosSearchResponse {}

/**
* Vimeo Videos getContactsLikeList exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getContactsLikeList queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetContactsLikeListException extends VimeoException {}

/**
* Vimeo Videos GetInfo response handler class
*
* Handles the API response for vimeo.videos.getInfo queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetInfoResponse extends VimeoResponse {
    private $oVideo = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse) {
        parent::__construct($aResponse);
        
        $this->oVideo = new VimeoVideoEntity($aResponse->video);
    }
    
    /**
    * Get video information as object
    * 
    * @access   public
    * @return   VimeoVideoEntity
    */
    public function getVideo() {
        return $this->oVideo;
    }
}

/**
* Vimeo Videos GetInfo exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getInfo queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetInfoException extends VimeoException {}

/**
* Vimeo Videos getUploadTicket response handler class
*
* Handles the API response for vimeo.videos.getUploadTicket queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosGetUploadTicketResponse extends VimeoResponse {
    private $sTicket = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->sTicket = $aResponse->ticket->id;
    }
    
    /**
    * Get generated upload ticket
    * 
    * @access   public
    * @return   string      The ticket number of the upload
    */
    public function getTicket() {
        return $this->sTicket;
    }
}

/**
* Vimeo Videos getUploadTicket exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.getUploadTicket queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosGetUploadTicketException extends VimeoException {}

/**
* Vimeo Videos checkUploadStatus response handler class
*
* Handles the API response for vimeo.videos.checkUploadStatus queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosCheckUploadStatusResponse extends VimeoResponse {
    private $sTicket = false;
    private $iVideoID = false;
    private $bIsUploading = false;
    private $bIsTranscoding = false;
    private $iTranscodingProgress = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->sTicket = $aResponse->ticket->id;
        $this->iVideoID = $aResponse->ticket->video_id;
        $this->bIsUploading = (bool) $aResponse->ticket->is_uploading;
        $this->bIsTranscoding = (bool) $aResponse->ticket->is_transcoding;
        $this->iTranscodingProgress = $aResponse->ticket->transcoding_progress;
    } 
    
    /**
    * Get Ticket
    * 
    * @access   public
    * @return   string      Ticket
    */
    public function getTicket() {
        return $this->sTicket;
    }
    
    /**
    * Get Video ID
    * 
    * @access   public
    * @return   integer     Video ID
    */
    public function getVideoID() {
        return $this->iVideoID;
    }
    
    /**
    * Is the video uploading?
    * 
    * @access   public
    * @return   boolean     TRUE if uploading, FALSE if not
    */
    public function isUploading() {
        return $this->bIsUploading;
    }
    
    /**
    * Is the video transcoding?
    * 
    * Also check getTranscodingProgress() for percentage in transcoding
    * 
    * @access   public
    * @return   boolean     TRUE if uploading, FALSE if not
    */
    public function isTranscoding() {
        return $this->bIsTranscoding;
    }
    
    /**
    * Get the transcoding progress
    * 
    * Should only be called if isTranscoding() returns true
    * 
    * @access   public
    * @return   integer     Percentage
    */
    public function getTranscodingProgress() {
        return $this->iTranscodingProgress;
    }
}

/**
* Vimeo Videos checkUploadStatus exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.checkUploadStatus queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosCheckUploadStatusException extends VimeoException {}

/**
* Vimeo Videos delete response handler class
*
* Handles the API response for vimeo.videos.delete queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosDeleteResponse extends VimeoResponse {}

/**
* Vimeo Videos delete exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.delete queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosDeleteException extends VimeoException {}

/**
* Vimeo Videos setTitle response handler class
*
* Handles the API response for vimeo.videos.setTitle queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosSetTitleResponse extends VimeoResponse {}

/**
* Vimeo Videos setTitle exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.setTitle queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosSetTitleException extends VimeoException {}

/**
* Vimeo Videos setCaption response handler class
*
* Handles the API response for vimeo.videos.setCaption queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosSetCaptionResponse extends VimeoResponse {}

/**
* Vimeo Videos setCaption exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.setCaption queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosSetCaptionException extends VimeoException {}

/**
* Vimeo Videos setFavorite response handler class
*
* Handles the API response for vimeo.videos.setFavorite queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosSetFavoriteResponse extends VimeoResponse {}

/**
* Vimeo Videos setFavorite exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.setFavorite queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosSetFavoriteException extends VimeoException {}

/**
* Vimeo Videos addTags response handler class
*
* Handles the API response for vimeo.videos.addTags queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosAddTagsResponse extends VimeoResponse {}

/**
* Vimeo Videos addTags exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.addTags queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosAddTagsException extends VimeoException {}

/**
* Vimeo Videos removeTag response handler class
*
* Handles the API response for vimeo.videos.removeTag queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosRemoveTagResponse extends VimeoResponse {}

/**
* Vimeo Videos removeTag exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.removeTag queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosRemoveTagException extends VimeoException {}

/**
* Vimeo Videos clearTags response handler class
*
* Handles the API response for vimeo.videos.clearTags queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosClearTagsResponse extends VimeoResponse {}

/**
* Vimeo Videos clearTags exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.clearTags queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosClearTagsException extends VimeoException {}

/**
* Vimeo Videos setPrivacy response handler class
*
* Handles the API response for vimeo.videos.setPrivacy queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoVideosSetPrivacyResponse extends VimeoResponse {}

/**
* Vimeo Videos setPrivacy exception handler class
*
* Handles exceptions caused by API response for vimeo.videos.setPrivacy queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoVideosSetPrivacyException extends VimeoException {}

/**
* vimeo.people.* methods
*/

/**
* Vimeo People request handler class
*
* Implements all API queries in the vimeo.people.* category
* 
* @package     SimpleVimeo
* @subpackage  ApiRequest
*/

class VimeoPeopleRequest extends VimeoRequest {
    const TYPE_LIKES        = 'likes';
    const TYPE_APPEARS      = 'appears';
    const TYPE_BOTH         = 'likes,appears';
    
    /**
    * Get a user id and full/display name with a username.  
    * 
    * You shouldn't need this to get the User ID, we allow you to use the
    * username instead of User ID everywhere, it's much nicer that way.
    * 
    * @access   public
    * @param    string      The username to lookup
    * @return   VimeoPeopleFindByUsernameResponse
    */
    public function findByUsername($sUsername) {
        $aArgs = array(
            'username' => $sUsername
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.findByUserName', $aArgs);
    }
    
    /**
    * Get tons of info about a user.
    * 
    * @access   public
    * @param    integer     The id of the user we want. 
    * @return   VimeoPeopleGetInfoResponse
    */
    public function getInfo($iUserID) {
        $aArgs = array(
            'user_id' => $iUserID
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.getInfo', $aArgs);
    }
    
    /**
    * Get a user id and full/display name via an Email Address.  
    * 
    * You shouldn't need to use this to get the User ID, we allow you
    * to use the username instead of User ID everywhere, it's much nicer that way.
    * 
    * @access   public
    * @param    string      Email
    * @return   VimeoPeopleFindByEmailResponse
    */
    public function findByEmail($sEmail) {
        $aArgs = array(
            'find_email' => $sEmail
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.findByEmail', $aArgs);
    }
    
    /**
    * Get a portrait URL for a given user/size
    * 
    * Portraits are square, so you only need to pass one size parameter.
    * Possible sizes are 20, 24, 28, 30, 40, 50, 60, 75, 100, 140, 278 and 300
    * 
    * @access   public
    * @param    string      The username to lookup
    * @param    integer     The size of the portrait you you want. (defaults to 75)
    * @return   VimeoPeopleGetPortraitUrlResponse
    * 
    * @todo Check functionality. Did not work, god knows why
    */
    public function getPortraitUrl($sUser, $iSize = false) {
        $aArgs = array(
            'user' => $sUser
        );
        
        if($iSize) {
            $aArgs['size'] = $iSize;
        }
        
        return VimeoBase::executeRemoteCall('vimeo.people.getPortraitUrl', $aArgs);
    }
    
    /**
    * Add a user as a contact for the authenticated user.
    * 
    * If Jim is authenticated, and the $user is sally. Sally will be Jim's contact. 
    * It won't work the other way around. Depending on Sally's settings, this may 
    * send her an email notifying her that Jim Added her as a contact. 
    * 
    * @access   public
    * @param    string      The user to add. User ID, this can be the ID number (151542) or the username (ted)
    * @return   VimeoPeopleAddContactResponse
    */
    public function addContact($sUser) {
        $aArgs = array(
            'user' => $sUser
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.addContact', $aArgs);
    }
    
    /**
    * Remove a user as a contact for the authenticated user.
    * 
    * @access   public
    * @param    string      The user to remove. User ID, this can be the ID number (151542) or the username (ted)
    * @return   VimeoPeopleRemoveContactResponse
    */
    public function removeContact($sUser) {
        $aArgs = array(
            'user' => $sUser
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.removeContact', $aArgs);
    }
    
    /**
    * This tells you how much space the user has remaining for uploads.
    * 
    * We provide info in bytes and kilobytes. It probably makes sense for you to use kilobytes. 
    * 
    * @access   public
    * @return   VimeoPeopleGetUploadStatusResponse
    */
    public function getUploadStatus() {
        return VimeoBase::executeRemoteCall('vimeo.people.getUploadStatus');
    }
    
    /**
    * Subscribe to a user's videos.
    * 
    * Just like on the site, you can subscribe to videos a user "appears" in or "likes." Or both!  
    * This will not remove any subscriptions. So if the user is subscribed to a user for both "likes"
    * and "appears," this will not change anything if you only specify one of them. If you want to
    * remove one, you must call vimeo.people.removeSubscription().
    * 
    * @access   public
    * @param    string      User ID, this can be the ID number (151542) or the username (ted)
    * @param    string      with self::TYPE_LIKES or self::TYPE_APPEARS or self::TYPE_BOTH
    * @return   VimeoPeopleAddSubscriptionResponse
    */
    public function addSubscription($sUser, $eType = self::TYPE_BOTH) {
        $aArgs = array(
            'user' => $sUser,
            'type' => $eType
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.addSubscription', $aArgs);
    }
    
    /**
    * Unsubscribe to a user's videos.
    * 
    * @access   public
    * @param    string      User ID, this can be the ID number (151542) or the username (ted)
    * @param    string      with self::TYPE_LIKES or self::TYPE_APPEARS or self::TYPE_BOTH
    * @return   VimeoPeopleRemoveSubscriptionResponse
    */
    public function removeSubscription($sUser, $eType = self::TYPE_BOTH) {
        $aArgs = array(
            'user' => $sUser,
            'type' => $eType
        );
        
        return VimeoBase::executeRemoteCall('vimeo.people.removeSubscription', $aArgs);
    }
}

/**
* Vimeo People FindByUserName response handler class
*
* Handles the API response for vimeo.people.findByUserName queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleFindByUserNameResponse extends VimeoResponse {
    private $oUser = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->oUser = new VimeoUserEntity($aResponse->user);
    }
    
    /**
    * Get user entity object
    * 
    * @access   public
    * @return   VimeoUserEntity
    */
    public function getUser() {
        return $this->oUser;
    }
}

/**
* Vimeo People FindByUserName exception handler class
*
* Handles exceptions caused by API response for vimeo.people.findByUserName queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleFindByUserNameException extends VimeoException {}

/**
* Vimeo People FindByEmail response handler class
*
* Handles the API response for vimeo.people.findByEmail queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleFindByEmailResponse extends VimeoResponse {
    private $oUser = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->oUser = new VimeoUserEntity($aResponse->user);
    }

    /**
    * Get user entity object
    * 
    * @access   public
    * @return   VimeoUserEntity
    */
    public function getUser() {
        return $this->oUser;
    }
}

/**
* Vimeo People FindByEmail exception handler class
*
* Handles exceptions caused by API response for vimeo.people.findByEmail queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleFindByEmailException extends VimeoException {}

/**
* Vimeo People GetInfo response handler class
*
* Handles the API response for vimeo.people.getInfo queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleGetInfoResponse extends VimeoResponse {
    private $oUser = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->oUser = new VimeoUserEntity($aResponse->person);
    }

    /**
    * Get user entity object
    * 
    * @access   public
    * @return   VimeoUserEntity
    */
    public function getUser() {
        return $this->oUser;
    }
}

/**
* Vimeo People GetInfo exception handler class
*
* Handles exceptions caused by API response for vimeo.people.getInfo queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleGetInfoException extends VimeoException {}

/**
* Vimeo People getPortraitUrl response handler class
*
* Handles the API response for vimeo.people.getPortraitUrl queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleGetPortraitUrlResponse extends VimeoResponse {}

/**
* Vimeo People getPortraitUrl exception handler class
*
* Handles exceptions caused by API response for vimeo.people.getPortraitUrl queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleGetPortraitUrlException extends VimeoException {}

/**
* Vimeo People addContact response handler class
*
* Handles the API response for vimeo.people.addContact queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleAddContactResponse extends VimeoResponse {}

/**
* Vimeo People addContact exception handler class
*
* Handles exceptions caused by API response for vimeo.people.addContact queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleAddContactException extends VimeoException {}

/**
* Vimeo People removeContact response handler class
*
* Handles the API response for vimeo.people.removeContact queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleRemoveContactResponse extends VimeoResponse {}

/**
* Vimeo People removeContact exception handler class
*
* Handles exceptions caused by API response for vimeo.people.removeContact queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleRemoveContactException extends VimeoException {}

/**
* Vimeo People getUploadStatus response handler class
*
* Handles the API response for vimeo.people.getUploadStatus queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleGetUploadStatusResponse extends VimeoResponse {
    private $iMaxBytes = false;
    private $iMaxKBytes = false;
    
    private $iUsedBytes = false;
    private $iUsedKBytes = false;
    
    private $iRemainingBytes = false;
    private $iRemainingKBytes = false;

    /**
    * Constructor
    * 
    * Parses the API response
    * 
    * @access   public
    * @param    stdClass    API response
    * @return   void
    */
    public function __construct($aResponse = false) {
        parent::__construct($aResponse);
        
        $this->iMaxBytes = $aResponse->user->bandwidth->maxbytes;
        $this->iMaxKBytes = $aResponse->user->bandwidth->maxkb;
        
        $this->iUsedBytes = $aResponse->user->bandwidth->usedbytes;
        $this->iUsedKBytes = $aResponse->user->bandwidth->usedkb;
        
        $this->iRemainingBytes = $aResponse->user->bandwidth->remainingbytes;
        $this->iRemainingKBytes = $aResponse->user->bandwidth->remainingkb;
    }
    
    /**
    * Get maximum upload for this week in BYTES
    * 
    * @access   public
    * @return   integer     Maximum bytes this week
    */
    public function getMaxBytes() {
        return $this->iMaxBytes;
    }
    
    /**
    * Get maximum upload for this week in KILOBYTES
    * 
    * @access   public
    * @return   integer     Maximum kbytes this week
    */
    public function getMaxKiloBytes() {
        return $this->iMaxKBytes;
    }
    
    /**
    * Get used upload for this week in BYTES
    * 
    * @access   public
    * @return   integer     Used bytes this week
    */
    public function getUsedBytes() {
        return $this->iUsedBytes;
    }
    
    /**
    * Get used upload for this week in KILOBYTES
    * 
    * @access   public
    * @return   integer     Used kbytes this week
    */
    public function getUsedKiloBytes() {
        return $this->iUsedKBytes;
    }
    
    /**
    * Get remaining upload for this week in BYTES
    * 
    * @access   public
    * @return   integer     Remaining bytes this week
    */
    public function getRemainingBytes() {
        return $this->iRemainingBytes;
    }
    
    /**
    * Get remaining upload for this week in KILOBYTES
    * 
    * @access   public
    * @return   integer     Remaining kbytes this week
    */
    public function getRemainingKiloBytes() {
        return $this->iRemainingKBytes;
    }
}

/**
* Vimeo People getUploadStatus exception handler class
*
* Handles exceptions caused by API response for vimeo.people.getUploadStatus queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleGetUploadStatusException extends VimeoException {}

/**
* Vimeo People addSubscription response handler class
*
* Handles the API response for vimeo.people.addSubscription queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleAddSubscriptionResponse extends VimeoResponse {}

/**
* Vimeo People addSubscription exception handler class
*
* Handles exceptions caused by API response for vimeo.people.addSubscription queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleAddSubscriptionException extends VimeoException {}

/**
* Vimeo People removeSubscription response handler class
*
* Handles the API response for vimeo.people.removeSubscription queries.
* 
* @package     SimpleVimeo
* @subpackage  ApiResponse
*/

class VimeoPeopleRemoveSubscriptionResponse extends VimeoResponse {}

/**
* Vimeo People removeSubscription exception handler class
*
* Handles exceptions caused by API response for vimeo.people.removeSubscription queries.
* 
* @package     SimpleVimeo
* @subpackage  Exceptions
*/

class VimeoPeopleRemoveSubscriptionException extends VimeoException {}

?>