/ide/0.4.1/inspector.php

Large files files are truncated, but you can click here to view the full file

<?php if(!extension_loaded("phalcon")){

/**
 * Phalcon_Acl
 *
 * This component allows to manage ACL lists. An access control list (ACL) is a list
 * of permissions attached to an object. An ACL specifies which users or system processes
 * are granted access to objects, as well as what operations are allowed on given objects.
 *
 *<code>
 *$acl = new Phalcon_Acl('Memory');
 *
 * //Default action is deny access
 *$acl->setDefaultAction(Phalcon_Acl::DENY);
 *
 * //Create some roles
 *$roleAdmins = new Phalcon_Acl_Role('Administrators', 'Super-User role');
 *$roleGuests = new Phalcon_Acl_Role('Guests');
 *
 * //Add "Guests" role to acl
 *acl->addRole($roleGuests);
 *
 * //Add "Designers" role to acl
 *$acl->addRole('Designers'));
 *
 * //Define the "Customers" resource
 *$customersResource = new Phalcon_Acl_Resource('Customers', 'Customers management');
 *
 * //Add "customers" resource with a couple of operations
 *$acl->addResource($customersResource, 'search');
 *$acl->addResource($customersResource, array('create', 'update'));
 *
 * //Set access level for roles into resources
 *$acl->allow('Guests', 'Customers', 'search');
 *$acl->allow('Guests', 'Customers', 'create');
 *$acl->deny('Guests', 'Customers', 'update');
 *
 * //Check whether role has access to the operations
 *$acl->isAllowed('Guests', 'Customers', 'edit') //Returns 0
 *$acl->isAllowed('Guests', 'Customers', 'search'); //Returns 1
 *$acl->isAllowed('Guests', 'Customers', 'create'); //Returns 1
 *</code>
 */
class Phalcon_Acl
{
	const ALLOW = 1;
	const DENY = 0;
	/**
	 * Phalcon_Acl Constructor
	 *
	 * @param string $adapterName
	 * @param array $options
	 */
	public function __construct($adapterName='Memory', $options=array ()){
	}

	/**
	 * Pass any call to the internal adapter object
	 *
	 * @param  string $method
	 * @param  array $arguments
	 * @return mixed
	 */
	public function __call($method, $arguments=array ()){
	}

}

/**
 * Phalcon_Cache
 *
 * Phalcon_Cache can be used to cache output fragments to improve performance
 *
 *<code>
 * //Cache the file for 2 days
 *$frontendOptions = array(
 *  'lifetime' => 172800
 *);
 *
 * //Set the cache directory
 *$backendOptions = array(
 *  'cacheDir' => '../app/cache/'
 *);
 *
 *$cache = Phalcon_Cache::factory('Output', 'File', $frontendOptions, $backendOptions);
 *
 *$content = $cache->start('my-cache');
 *if($content===null){
 *  echo time();
 *  $cache->save();
 *} else {
 *  echo $content;
 *}
 *</code>
 */
class Phalcon_Cache
{
	/**
	 * Factories different caches backends from its adapters
	 *
	 * @param	string $frontendAdapter
	 * @param	string $backendAdapter
	 * @param	array $frontendOptions
	 * @param	array $backendOptions
	 * @return  Phalcon_Cache_Backend_File
	 * @static
	 */
	public static function factory($frontendAdapter, $backendAdapter, $frontendOptions=array (), $backendOptions=array ()){
	}

}

/**
 * Phalcon_Config
 *
 * Phalcon_Config is designed to simplify the access to, and the use of, configuration data within applications.
 * It provides a nested object property based user interface for accessing this configuration data within
 * application code.
 *
 * <code>$config = new Phalcon_Config(array(
 *  "database" => array(
 *    "adapter" => "Mysql",
 *    "host" => "localhost",
 *    "username" => "scott",
 *    "password" => "cheetah",
 *    "name" => "test_db"
 *  ),
 *  "phalcon" => array(
 *    "controllersDir" => "../app/controllers/",
 *    "modelsDir" => "../app/models/",
 *    "viewsDir" => "../app/views/"
 *  )
 * ));</code>
 *
 */
class Phalcon_Config
{
	/**
	 * Phalcon_Config constructor
	 *
	 * @param	array $arrayConfig
	 * @return	Phalcon_Config
	 */
	public function __construct($arrayConfig=array ()){
	}

}

/**
 * Phalcon_Controller
 *
 * Every application controller should extend this class that encapsulates all the controller functionality
 *
 * The controllers provide the “flow” between models and views. Controllers are responsible
 * for processing the incoming requests from the web browser, interrogating the models for data,
 * and passing that data on to the views for presentation.
 *
 *<code>
 *
 *
 * class PeopleController extends Phalcon_Controller 
 *{
 *
 *  //This action will be executed by default
 *  public function indexAction()
 *  {
 *
 *  }
 *
 *  public function findAction()
 *  {
 *
 *  }
 *
 *  public function saveAction()
 *  {
 *   //Forwards flow to the index action
 *   return $this->_forward('people/index');
 *  }
 *
 *  //This action will be executed when a non existent action is requested
 *  public function notFoundAction()
 *  {
 *
 *  }
 *
 * }
 *
 *</code>
 */
class Phalcon_Controller
{
	/**
	 * @var Phalcon_Dispatcher
	 */
	public $dispatcher;

	/**
	 * @var Phalcon_Request
	 */
	public $request;

	/**
	 * @var Phalcon_Response
	 */
	public $response;

	/**
	 * @var Phalcon_View
	 */
	public $view;

	/**
	 * @var Phalcon_Model_Manager
	 */
	public $model;

	/**
	 * Constructor for Phalcon_Controller
	 *
	 * @param Phalcon_Dispatcher $dispatcher
	 * @param Phalcon_Request $request
	 * @param Phalcon_Response $response
	 * @param Phalcon_View $view
	 * @param Phalcon_Model_Manager $model
	 */
	final public function __construct($dispatcher, $request, $response, $view=NULL, $model=NULL){
	}

	/**
	 * Forwards execution flow to another controller/action.
	 *
	 * @param string $uri
	 */
	protected function _forward($uri){
	}

	/**
	 * Returns a param from the dispatching params
	 *
	 * @param mixed $index
	 */
	protected function _getParam($index){
	}

	/**
	 * Set a dispatching parameter
	 *
	 * @param mixed $index
	 * @param mixed $value
	 */
	protected function _setParam($index, $value){
	}

	/**
	 * Magic method __get
	 *
	 * @param string $propertyName
	 */
	public function __get($propertyName){
	}

}

/**
 * Phalcon_Db
 *
 * Phalcon_Db and its related classes provide a simple SQL database interface for Phalcon Framework.
 * The Phalcon_Db is the basic class you use to connect your PHP application to an RDBMS.
 * There is a different adapter class for each brand of RDBMS.
 *
 * This component is intended to lower level database operations. If you want to interact with databases using
 * high level abstraction use Phalcon_Model.
 *
 * Phalcon_Db is an abstract class. You only can use it with a database adapter like Phalcon_Db_Adapter_Mysql
 *
 * <code>
 *
 *$config = new stdClass();
 *$config->host = 'localhost';
 *$config->username = 'machine';
 *$config->password = 'sigma';
 *$config->name = 'swarm';
 *
 *try {
 *
 *  $connection = Phalcon_Db::factory('Mysql', $config);
 *
 *  $result = $connection->query("SELECT * FROM robots LIMIT 5");
 *  $result->setFetchMode(Phalcon_Db::DB_NUM);
 *  while($robot = $result->fetchArray()){
 *    print_r($robot);
 *  }
 *
 *} catch(Phalcon_Db_Exception $e){
 *	echo $e->getMessage(), PHP_EOL;
 *}
 *
 * </code>
 */
abstract class Phalcon_Db
{
	const DB_ASSOC = 1;
	const DB_BOTH = 2;
	const DB_NUM = 3;
	/**
	 * Phalcon_Db constructor, this method should not be called directly. Use Phalcon_Db::factory instead
	 *
	 * @param stdClass $descriptor
	 */
	protected function __construct($descriptor){
	}

	/**
	 * Sets a logger class to log all SQL operations sent to database server
	 *
	 * @param Phalcon_Logger $logger
	 */
	public function setLogger($logger){
	}

	/**
	 * Returns the active logger
	 *
	 * @return Phalcon_Logger
	 */
	public function getLogger(){
	}

	/**
	 * Sends arbitrary text to a related logger in the instance
	 *
	 * @param string $sqlStatement
	 * @param int $type
	 */
	protected function log($sqlStatement, $type){
	}

	/**
	 * Sets a database profiler to the connection
	 *
	 * @param Phalcon_Db_Profiler $profiler
	 */
	public function setProfiler($profiler){
	}

	/**
	 * Returns the first row in a SQL query result
	 *
	 * <code>
	 * //Getting first robot
	 * $robot = $connection->fecthOne("SELECT * FROM robots");
	 * print_r($robot);
     *
	 * //Getting first robot with associative indexes only
	 * $robot = $connection->fecthOne("SELECT * FROM robots", Phalcon_Db_Result::DB_ASSOC);
	 * print_r($robot);
	 * </code>
	 *
	 * @param string $sqlQuery
	 * @param int $fetchMode
	 * @return array
	 */
	public function fetchOne($sqlQuery, $fetchMode=2){
	}

	/**
	 * Dumps the complete result of a query into an array
	 *
	 * <code>
	 * //Getting all robots
	 * $robots = $connection->fetchAll("SELECT * FROM robots");
	 * foreach($robots as $robot){
	 *    print_r($robot);
	 * }
	 *
	 * //Getting all robots with associative indexes only
	 * $robots = $connection->fetchAll("SELECT * FROM robots", Phalcon_Db_Result::DB_ASSOC);
	 * foreach($robots as $robot){
	 *    print_r($robot);
	 * }
	 * </code>
	 *
	 * @param string $sqlQuery
	 * @param int $fetchMode
	 * @return array
	 */
	public function fetchAll($sqlQuery, $fetchMode=2){
	}

	/**
	 * Inserts data into a table using custom RBDM SQL syntax
	 *
	 * <code>
	 * //Inserting a new robot
	 * $success = $connection->insert(
	 *     "robots",
	 *     array("Astro Boy", 1952),
	 *     array("name", "year")
	 * );
	 *
	 * //Next SQL sentence is sent to the database system
	 * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
	 * </code>
	 *
	 * @param string $table
	 * @param array $values
	 * @param array $fields
	 * @param boolean $automaticQuotes
	 * @return boolean
	 */
	public function insert($table, $values, $fields=NULL, $automaticQuotes=false){
	}

	/**
	 * Updates data on a table using custom RBDM SQL syntax
	 *
	 * <code>
	 * //Updating existing robot
	 * $success = $connection->update(
	 *     "robots",
	 *     array("name")
	 *     array("New Astro Boy"),
	 *     "id = 101"
	 * );
	 *
	 * //Next SQL sentence is sent to the database system
	 * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
	 * </code>
	 *
	 * @param string $table
	 * @param array $fields
	 * @param array $values
	 * @param string $whereCondition
	 * @param boolean $automaticQuotes
	 * @return boolean
	 */
	public function update($table, $fields, $values, $whereCondition=NULL, $automaticQuotes=false){
	}

	/**
	 * Deletes data from a table using custom RBDM SQL syntax
	 *
	 * <code>
	 * //Deleting existing robot
	 * $success = $connection->delete(
	 *     "robots",
	 *     "id = 101"
	 * );
	 *
	 * //Next SQL sentence is generated
	 * DELETE FROM `robots` WHERE id = 101
	 * </code>
	 *
	 * @param string $table
	 * @param string $whereCondition
	 * @return boolean
	 */
	public function delete($table, $whereCondition=''){
	}

	/**
     * Starts a transaction in the connection
     *
     * @return boolean
     */
	public function begin(){
	}

	/**
     * Rollbacks the active transaction in the connection
     *
     * @return boolean
     */
	public function rollback(){
	}

	/**
     * Commits the active transaction in the connection
     *
     * @return boolean
     */
	public function commit(){
	}

	/**
	 * Manually sets a "under transaction" state for the connection
	 *
	 * @param boolean $underTransaction
	 */
	protected function setUnderTransaction($underTransaction){
	}

	/**
	 * Checks whether connection is under database transaction
	 *
	 * @return boolean
	 */
	public function isUnderTransaction(){
	}

	/**
	 * Checks whether connection have auto commit
	 *
	 * @return boolean
	 */
	public function getHaveAutoCommit(){
	}

	/**
	 * Returns database name in the internal connection
	 *
	 * @return string
	 */
	public function getDatabaseName(){
	}

	/**
	 * Returns active schema name in the internal connection
	 *
	 * @return string
	 */
	public function getDefaultSchema(){
	}

	/**
	 * Returns the username which has connected to the database
	 *
	 * @return string
	 */
	public function getUsername(){
	}

	/**
	 * Returns the username which has connected to the database
     *
	 * @return string
	 */
	public function getHostName(){
	}

	/**
	 * This method is executed before every SQL statement sent to the database system
	 *
	 * @param string $sqlStatement
	 */
	protected function _beforeQuery($sqlStatement){
	}

	/**
	 * This method is executed after every SQL statement sent to the database system
	 *
	 * @param string $sqlStatement
	 */
	protected function _afterQuery($sqlStatement){
	}

	/**
	 * Instantiates Phalcon_Db adapter using given parameters
	 *
	 * @param string $adapterName
	 * @param stdClass $options
	 * @return Phalcon_Db_Adapter_Mysql|Phalcon_Db_Adapter_Postgresql
	 */
	public static function factory($adapterName, $options){
	}

}

/**
 * Phalcon_Dispatcher
 *
 * Dispatching is the process of taking the request object, extracting the module name,
 * controller name, action name, and optional parameters contained in it, and then
 * instantiating a controller and calling an action of that controller.
 *
 * <code>
 *
 *$dispatcher = new Phalcon_Dispatcher();
 *
 *$request = Phalcon_Request::getInstance();
 *$response = Phalcon_Response::getInstance();
 *
 *$dispatcher->setBasePath('./');
 *$dispatcher->setControllersDir('tests/controllers/');
 *
 *$dispatcher->setControllerName('posts');
 *$dispatcher->setActionName('index');
 *$dispatcher->setParams(array());
 *$controller = $dispatcher->dispatch($request, $response);
 *
 *</code>
 */
class Phalcon_Dispatcher
{
	/**
	 * Sets default controllers directory. Depending of your platform, always add a trailing slash or backslash
	 *
	 * @param string $controllersDir
	 */
	public function setControllersDir($controllersDir){
	}

	/**
	 * Gets active controllers directory
	 *
	 * @return string
	 */
	public function getControllersDir(){
	}

	/**
	 * Sets base path for controllers dir. Depending of your platform, always add a trailing slash or backslash
	 *
	 * @param string $basePath
	 */
	public function setBasePath($basePath){
	}

	/**
	 * Gets base path for controllers dir
	 *
	 * @return string
	 */
	public function getBasePath(){
	}

	/**
	 * Sets the default controller name
     *
	 * @param string $controllerName
	 */
	public function setDefaultController($controllerName){
	}

	/**
	 * Sets the default action name
     *
	 * @param string $actionName
	 */
	public function setDefaultAction($actionName){
	}

	/**
	 * Sets the controller name to be dispatched
	 *
	 * @param string $controllerName
	 */
	public function setControllerName($controllerName){
	}

	/**
	 * Gets last dispatched controller name
	 *
	 * @return string
	 */
	public function getControllerName(){
	}

	/**
	 * Sets the action name to be dispatched
	 *
	 * @param string $actionName
	 */
	public function setActionName($actionName){
	}

	/**
	 * Gets last dispatched action name
	 *
	 * @return string
	 */
	public function getActionName(){
	}

	/**
	 * Sets action params to be dispatched
	 *
	 * @param array $params
	 */
	public function setParams($params){
	}

	/**
	 * Gets action params
	 *
	 * @return array
	 */
	public function getParams(){
	}

	/**
	 * Set a param by its name or numeric index
     *
     * @param  mixed $param
     * @param  mixed $value	 
	 */
	public function setParam($param, $value){
	}

	/**
	 * Gets a param by its name or numeric index
     *
     * @param  mixed $param
	 * @return mixed
	 */
	public function getParam($param){
	}

	/**
	 * Dispatches a controller action taking into account the routing parameters
	 *
	 * @param Phalcon_Request $request
	 * @param Phalcon_Response $response
	 * @param Phalcon_View $view
	 * @param Phalcon_Model_Manager $model
	 * @return Phalcon_Controller
	 */
	public function dispatch($request, $response, $view=NULL, $model=NULL){
	}

	/**
	 * Throws an internal exception
	 *
	 * @param Phalcon_Response $response
	 * @param string $message
	 */
	protected function _throwDispatchException($response, $message){
	}

	/**
	 * Routes to a controller/action using a string or array uri
	 *
	 * @param string $uri
	 */
	public function forward($uri){
	}

	/**
	 * Checks if the dispatch loop is finished or have more pendent controller to disptach
	 *
	 * @return boolean
	 */
	public function isFinished(){
	}

	/**
	 * Returns all instantiated controllers whitin the dispatcher
	 *
	 * @return array
	 */
	public function getControllers(){
	}

	/**
	 * Returns last dispatched controller
	 *
	 * @return Phalcon_Controller
	 */
	public function getLastController(){
	}

	/**
	 * Returns value returned by last dispacthed action
	 *
	 * @return mixed
	 */
	public function getReturnedValue(){
	}

}

/**
 * Phalcon_Exception
 *
 * All framework exceptions should use this exception
 */
class Phalcon_Exception extends Exception
{
	
	final private function __clone(){
	}

	
	public function __construct($message, $code, $previous){
	}

	
	final public function getMessage(){
	}

	
	final public function getCode(){
	}

	
	final public function getFile(){
	}

	
	final public function getLine(){
	}

	
	final public function getTrace(){
	}

	
	final public function getPrevious(){
	}

	
	final public function getTraceAsString(){
	}

	
	public function __toString(){
	}

}

/**
 * Phalcon_Filter
 *
 * The Phalcon_Filter component provides a set of commonly needed data filters. It provides
 * object oriented wrappers to the php filter extension
 *
 *<code>
 *$filter = new Phalcon_Filter();
 *$filter->sanitize("some(one)@exa\\mple.com", "email"); // returns "someone@example.com"
 *$filter->sanitize("hello<<", "string"); // returns "hello"
 *$filter->sanitize("!100a019", "int"); // returns "100019"
 *$filter->sanitize("!100a019.01a", "float"); // returns "100019.01"
 *</code>
 *
 */
class Phalcon_Filter
{
	/**
	 * Sanizites a value with a specified single or set of filters
	 *
	 * @param  mixed $value
	 * @param  mixed $filters
	 * @param  boolean $silent
	 * @return mixed
	 */
	public function sanitize($value, $filters, $silent=false){
	}

	/**
	 * Filters a value with a specified single or set of filters
	 *
	 * @param  mixed $value
	 * @param  array $filters
	 * @param  boolean $silent
	 * @return mixed
	 */
	public function filter($value, $filters, $silent=false){
	}

	/**
	 * Sanitize and Filter a value with a specified single or set of filters
	 *
	 * @param  mixed $value
	 * @param  array $filters
	 * @return mixed
	 */
	public function sanitizeAndFilter($value, $filters){
	}

	/**
	 * Internal sanizite wrapper to filter_var
	 *
	 * @param  mixed $value
	 * @param  string $filter
	 * @param  boolean $silent
	 * @return mixed
	 */
	protected function _sanitize($value, $filter, $silent=false){
	}

	/**
	 * Internal filter function
	 *
	 * @param	mixed $value
	 * @param  string $filter
	 * @param  boolean $silent
	 * @return	mixed
	 */
	protected function _filter($value, $filter, $silent=false){
	}

}

/**
 * Phalcon_Flash
 *
 * Shows HTML notifications related to different circumstances. Classes can be stylized using CSS
 *
 *<code>
 *Phalcon_Flash::success("The record was successfully deleted");
 *Phalcon_Flash::error("Cannot open the file");
 *Phalcon_Flash::error("Cannot open the file", "alert alert-error");
 *</code>
 */
abstract class Phalcon_Flash
{
	
	private static function _showMessage($message, $classes){
	}

	/**
	 * Shows a HTML error message
	 *
	 * <code>Phalcon_Flash::error('This is an error'); </code>
	 *
	 * @param string $message
	 * @param string $classes
	 * @return string
	 */
	public static function error($message, $classes='errorMessage'){
	}

	/**
	 * Shows a HTML notice/information message
	 *
     * <code>Phalcon_Flash::notice('This is an information'); </code>
	 *
	 * @param string $message
	 * @param string $classes
	 * @return string
	 */
	public static function notice($message, $classes='noticeMessage'){
	}

	/**
	 * Shows a HTML success message
	 *
	 * <code>Phalcon_Flash::success('The process was finished successfully'); </code>
	 *
	 * @param string $message
	 * @param string $classes
	 * @return string
	 */
	public static function success($message, $classes='successMessage'){
	}

	/**
	 * Shows a HTML warning message
	 *
	 * <code>Phalcon_Flash::warning('Hey, this is important'); </code>
	 * <code>Phalcon_Flash::warning('Hey, this is important', 'alert alert-warning'); </code>
	 *
	 * @param string $message
	 * @param string $classes
	 * @return string
	 */
	public static function warning($message, $classes='warningMessage'){
	}

}

/**
 * Phalcon_Loader
 *
 * This component helps to load your project classes automatically based on some conventions
 *
 *<code>
 * //Creates the autoloader
 * $loader = new Phalcon_Loader();
 *
 * //Register some namespaces
 * $loader->registerNamespaces(array(
 *   'Example\\Base' => 'vendor/example/base/',
 *   'Example\\Adapter' => 'vendor/example/adapter/'
 *   'Example' => 'vendor/example/'
 * ));
 *
 * //register autoloader
 * $loader->register();
 *
 * //Requiring class will automatically include file vendor/example/adapter/Some.php
 * $adapter = Example\Adapter\Some();
 *</code>
 */
class Phalcon_Loader
{
	/**
	 * Register namespaces and their related directories
	 *
	 * @param array $namespaces
	 */
	public function registerNamespaces($namespaces){
	}

	/**
	 * Register directories on which "not found" classes could be found
	 *
	 * @param array $directories
	 */
	public function registerDirs($directories){
	}

	/**
	 * Register classes and their locations
	 *
	 * @param array $directories
	 */
	public function registerClasses($classes){
	}

	/**
	 * Register the autoload method
	 */
	public function register(){
	}

	/**
	 * Makes the work of autoload registered classes
	 *
	 * @param string $className
	 */
	public function autoLoad($className){
	}

}

/**
 * Phalcon_Logger
 *
 * Phalcon_Logger is a component whose purpose is to create logs using
 * different backends via adapters, generating options, formats and filters
 * also implementing transactions.
 *
 *<code>
 *$logger = new Phalcon_Logger("File", "app/logs/test.log");
 *$logger->log("This is a message");
 *$logger->log("This is an error", Phalcon_Logger::ERROR);
 *$logger->error("This is another error");
 *$logger->close();
 * </code>
 */
class Phalcon_Logger
{
	const SPECIAL = 9;
	const CUSTOM = 8;
	const DEBUG = 7;
	const INFO = 6;
	const NOTICE = 5;
	const WARNING = 4;
	const ERROR = 3;
	const ALERT = 2;
	const CRITICAL = 1;
	const EMERGENCE = 0;
	/**
	 * Phalcon_Logger constructor
	 *
	 * @param string $adapter
	 * @param string $name
	 * @param array $options
	 */
	public function __construct($adapter='File', $name=NULL, $options=array ()){
	}

	/**
 	 * Sends/Writes a message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function log($message, $type=7){
	}

	/**
 	 * Sends/Writes a debug message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function debug($message){
	}

	/**
 	 * Sends/Writes an error message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function error($message){
	}

	/**
 	 * Sends/Writes an info message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function info($message){
	}

	/**
 	 * Sends/Writes a notice message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function notice($message){
	}

	/**
 	 * Sends/Writes a warning message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function warning($message){
	}

	/**
 	 * Sends/Writes an alert message to the log
 	 *
 	 * @param string $message
 	 * @param ing $type
 	 */
	public function alert($message){
	}

	/**
	 * Pass any call to the internal adapter object
	 *
	 * @param  string $method
	 * @param  array $arguments
	 * @return mixed
	 */
	public function __call($method, $arguments=array ()){
	}

}

/**
 * Phalcon_Paginator
 *
 * Phalcon_Paginator is designed to simplify building of pagination on views
 *
 * <code>
 *
 * 
 * //Use an alias for Phalcon_Tag
 * use Tag as Phalcon_Tag;
 *
 * //Gets the active page number
 * $numberPage = (int) $_GET['page'];
 *
 * //Create a Model paginator
 * $paginator = Phalcon_Paginator::factory('Model', array(
 *   'data' => $robots,
 *   'limit' => 10,
 *   'page' => $numberPage
 * ));
 *
 * //Get the active page
 * $page = $paginator->getPaginate();
 *
 *?>
 *
 *<table>
 * <tr>
 *   <th>Id</th>
 *   <th>Name</th>
 *   <th>Type</th>
 * </tr>
 *  foreach($page->items as $item){ ?>
 *  <tr>
 *   <td> echo $item->id ?></td>
 *   <td> echo $item->name ?></td>
 *   <td> echo $item->type ?></td>
 *  </tr>
 *  } ?>
 *</table>
 *
 *<table>
 *  <tr>
 *    <td><?= Tag::linkTo("robots/search", "First") ?></td>
 *    <td><?= Tag::linkTo("robots/search?page=".$page->before, "Previous") ?></td>
 *    <td><?= Tag::linkTo("robots/search?page=".$page->next, "Next") ?></td>
 *    <td><?= Tag::linkTo("robots/search?page=".$page->last, "Last") ?></td>
 *    <td> echo $page->current, "/", $page->total_pages ?></td>
 *  </tr>
 * </table>
 * </code>
 *
 */
abstract class Phalcon_Paginator
{
	/**
     * Factories a paginator adapter
     *
     * @param   string $adapterName
     * @param   array $options
     * @return  Object
     */
	public static function factory($adapterName, $options=array ()){
	}

}

/**
 * Phalcon_Request
 *
 * <p>Encapsulates request information for easy and secure access from application controllers.</p>
 *
 * <p>The request object is a simple value object that is passed between the dispatcher and controller classes.
 * It packages the HTTP request environment.</p>
 *
 * <code>
 *$request = Phalcon_Request::getInstance();
 *if ($request->isPost() == true) {
 * if ($request->isAjax() == true) {
 *   echo 'Request was made using POST and AJAX';
 * }
 *}
 * </code>
 *
 */
class Phalcon_Request
{
	/**
	 * Gets the singleton instance of Phalcon_Request
	 *
	 * @return Phalcon_Request
	 */
	public static function getInstance(){
	}

	/**
	 * Overwrites Phalcon_Filter object used to sanitize input data
     *
	 *<code>	 
	 * $request->setFilter($myFilter);
	 *</code>
	 *
	 * @param Phalcon_Filter $filter
	 */
	public function setFilter($filter){
	}

	/**
	 * Returns the active filter object used to sanitize input data
	 *
	 *<code>
	 * // returns "100019.01"
	 * echo $request->getFilter()->sanitize("!100a019.01a", "float");
	 *</code>
	 *
	 * @return Phalcon_Filter
	 */
	protected function getFilter(){
	}

	/**
	 * Gets variable from $_POST superglobal applying filters if needed
	 *
	 *<code>
	 * //Returns value from $_POST["user_email"] without sanitizing
	 * $userEmail = $request->getPost("user_email");
	 *
	 * //Returns value from $_POST["user_email"] with sanitizing
	 * $userEmail = $request->getPost("user_email", "email");
	 *</code>
	 *
	 * @param string $name
	 * @param string|array $filters
	 * @return mixed
	 */
	public function getPost($name, $filters=NULL){
	}

	/**
	 * Gets variable from $_GET superglobal applying filters if needed
     *
	 *<code>
	 * //Returns value from $_GET["id"] without sanitizing
	 * $id = $request->getQuery("id");
	 *
	 * //Returns value from $_GET["id"] with sanitizing
	 * $id = $request->getQuery("id", "int");
	 *</code>
	 *
	 * @param string $name
	 * @param string|array $filters
	 * @return mixed
	 */
	public function getQuery($name, $filters=NULL){
	}

	/**
	 * Gets variable from $_SERVER superglobal
	 *
	 * @param string $name
	 * @return mixed
	 */
	public function getServer($name){
	}

	/**
	 * Checks whether $_POST superglobal has certain index
	 *
	 * @param string $name
	 * @return boolean
	 */
	public function hasPost($name){
	}

	/**
	 * Checks whether $_SERVER superglobal has certain index
	 *
	 * @param string $name
	 * @return boolean
	 */
	public function hasQuery($name){
	}

	/**
	 * Checks whether $_SERVER superglobal has certain index
	 *
	 * @param string $name
	 * @return mixed
	 */
	public function hasServer($name){
	}

	/**
	 * Gets HTTP header from request data
	 *
	 * @param string $header
	 * @return string
	 */
	public function getHeader($header){
	}

	/**
	 * Gets HTTP schema (http/https)
	 *
	 * @return string
	 */
	public function getScheme(){
	}

	/**
	 * Checks whether request has been made using ajax
	 *
	 * @return boolean
	 */
	public function isAjax(){
	}

	/**
	 * Checks whether request has been made using SOAP
	 *
	 * @return boolean
	 */
	public function isSoapRequested(){
	}

	/**
	 * Checks whether request has been made using any secure layer
	 *
	 * @return boolean
	 */
	public function isSecureRequest(){
	}

	/**
	 * Gets HTTP raws request body
	 *
	 * @return string
	 */
	public function getRawBody(){
	}

	/**
	 * Gets active server address IP
	 *
	 * @return string
	 */
	public function getServerAddress(){
	}

	/**
	 * Gets active server name
	 *
	 * @return string
	 */
	public function getServerName(){
	}

	/**
	 * Gets information about schema, host and port used by the request
	 *
	 * @return string
	 */
	public function getHttpHost(){
	}

	/**
	 * Gets most possibly client IPv4 Address. This methods search in $_SERVER['HTTP_X_FORWARDED_FOR'] and $_SERVER['REMOTE_ADDR']
	 *
	 * @return string
	 */
	public function getClientAddress(){
	}

	/**
	 * Gets HTTP method which request has been made
	 *
	 * @return string
	 */
	public function getMethod(){
	}

	/**
	 * Gets HTTP user agent used to made the request
	 *
	 * @return string
	 */
	public function getUserAgent(){
	}

	/**
	 * Checks whether HTTP method is POST. if $_SERVER['REQUEST_METHOD']=='POST'
	 *
	 * @return boolean
	 */
	public function isPost(){
	}

	/**
	 *
	 * Checks whether HTTP method is GET. if $_SERVER['REQUEST_METHOD']=='GET'
	 *
	 * @return boolean
	 */
	public function isGet(){
	}

	/**
	 * Checks whether HTTP method is PUT. if $_SERVER['REQUEST_METHOD']=='PUT'
	 *
	 * @return boolean
	 */
	public function isPut(){
	}

	/**
	 * Checks whether HTTP method is HEAD. if $_SERVER['REQUEST_METHOD']=='HEAD'
	 *
	 * @return boolean
	 */
	public function isHead(){
	}

	/**
	 * Checks whether HTTP method is DELETE. if $_SERVER['REQUEST_METHOD']=='DELETE'
	 *
	 * @return boolean
	 */
	public function isDelete(){
	}

	/**
	 * Checks whether HTTP method is OPTIONS. if $_SERVER['REQUEST_METHOD']=='OPTIONS'
	 *
	 * @return boolean
	 */
	public function isOptions(){
	}

	/**
	 * Checks whether request include attached files
	 *
	 * @return boolean
	 */
	public function hasFiles(){
	}

	/**
	 * Gets attached files as Phalcon_Request_File instances
	 *
	 * @return Phalcon_Request_File[]
	 */
	public function getUploadedFiles(){
	}

	/**
	 * Gets web page that refers active request. ie: http://www.google.com
	 *
	 * @return string
	 */
	public function getHTTPReferer(){
	}

	/**
	 * Process a request header and return an array of values with their qualities
	 *
	 * @param string $serverIndex
	 * @param string $name
	 * @return array
	 */
	protected function _getQualityHeader($serverIndex, $name){
	}

	/**
	 * Process a request header and return the one with best quality
	 *
	 * @param array $qualityParts
	 * @param string $name
	 * @return string
	 */
	protected function _getBestQuality($qualityParts, $name){
	}

	/**
	 * Gets array with mime/types and their quality accepted by the browser/client from $_SERVER['HTTP_ACCEPT']
	 *
	 * @return array
	 */
	public function getAcceptableContent(){
	}

	/**
	 * Gets best mime/type accepted by the browser/client from $_SERVER['HTTP_ACCEPT']
	 *
	 * @return array
	 */
	public function getBestAccept(){
	}

	/**
	 * Gets charsets array and their quality accepted by the browser/client from $_SERVER['HTTP_ACCEPT_CHARSET']
	 *
	 * @return array
	 */
	public function getClientCharsets(){
	}

	/**
	 * Gets best charset accepted by the browser/client from $_SERVER['HTTP_ACCEPT_CHARSET']
	 *
	 * @return string
	 */
	public function getBestCharset(){
	}

	/**
	 * Gets languages array and their quality accepted by the browser/client from $_SERVER['HTTP_ACCEPT_LANGUAGE']
	 *
	 * @return array
	 */
	public function getLanguages(){
	}

	/**
	 * Gets best language accepted by the browser/client from $_SERVER['HTTP_ACCEPT_LANGUAGE']
	 *
	 * @return string
	 */
	public function getBestLanguage(){
	}

	/**
	 * Resets the internal singleton
	 */
	public static function reset(){
	}

}

/**
 * Phalcon_Response
 *
 * Encapsulates the HTTP response message.
 *
 *<code>
 *$response = Phalcon_Response::getInstance();
 *$response->setStatusCode(200, "OK");
 *$response->setContent("<html><body>Hello</body></html>");
 *$response->send();
 *</code>
 */
class Phalcon_Response
{
	/**
	 * Returns singleton Phalcon_Response instance
	 *
	 * @return Phalcon_Response
	 */
	public static function getInstance(){
	}

	/**
	 * Sets the HTTP response code
	 *
	 * @param int $code
	 * @param strign $message
	 */
	public function setStatusCode($code, $message){
	}

	/**
	 * Overwrites a header in the response
	 *
	 *<code>
	 *$response->setHeader("Content-Type", "text/plain");
	 *</code>
	 *
	 * @param string $name
	 * @param string $value
	 */
	public function setHeader($name, $value){
	}

	/**
	 * Send a raw header to the response
	 *
	 *<code>
	 *$response->setRawHeader("HTTP/1.1 404 Not Found");
	 *</code>
	 */
	public function setRawHeader($header){
	}

	/**
	 *  Redirect by HTTP to another action or URL
	 *
	 *<code>
	 *$response->redirect("posts/index");
	 *$response->redirect("http://en.wikipedia.org", true);
	 *</code>
	 *
	 * @param string $location
	 * @param boolean $full
	 */
	public function redirect($location, $full=false){
	}

	/**
	 * Sets HTTP response body
     *
	 *<code>
	 *$response->setContent("<h1>Hello!</h1>");
	 *</code>
	 *
	 * @param string $content
	 */
	public function setContent($content){
	}

	/**
	 * Appends a string to the HTTP response body
	 *
	 * @param string $content
	 */
	public function appendContent($content){
	}

	/**
	 * Gets HTTP response body
	 *
	 * @return string
	 */
	public function getContent(){
	}

	/**
	 * Prints out HTTP response to the client
	 *
	 */
	public function send(){
	}

	/**
	 * Resets the internal singleton
	 */
	public static function reset(){
	}

}

/**
 * Phalcon_Session
 *
 * Session client-server persistent state data management. This component
 * allow you to separate your session data between application or modules.
 * With this, it's possible to use the same index to refer a variable
 * but they can be in different applications.
 *
 * <code>
 * Phalcon_Session::start(array(
 *    'uniqueId' => 'my-private-app'
 * ));
 *
 * Phalcon_Session::set('var', 'some-value');
 *
 * echo Phalcon_Session::set('var');
 * </code>
 */
abstract class Phalcon_Session
{
	/**
	 * Starts session, optionally using an adapter
	 *
	 * @param array $options
	 */
	public static function start($options=array ()){
	}

	/**
	 * Sets session options
	 *
	 * @param array $options
	 */
	public static function setOptions($options){
	}

	/**
	 * Gets a session variable from an application context
	 *
	 * @param string $index
	 */
	public static function get($index){
	}

	/**
	 * Sets a session variable in an application context
	 *
	 * @param string $index
	 * @param string $value
	 */
	public static function set($index, $value){
	}

	/**
	 * Check whether a session variable is set in an application context
	 *
	 * @param string $index
	 */
	public static function has($index){
	}

	/**
	 * Removes a session variable from an application context
	 *
	 * @param string $index
	 */
	public static function remove($index){
	}

	/**
	 * Returns active session id
	 *
	 * @return string
	 */
	public static function getId(){
	}

}

/**
 * Phalcon_Tag
 *
 * Phalcon_Tag is designed to simplify building of HTML tags.
 * It provides a set of helpers to generate HTML in a dynamic way.
 * This component is an abstract class that you can extend to add more helpers.
 */
abstract class Phalcon_Tag
{
	/**
	 * Sets the request dispatcher. A valid dispatcher is required to generate absolute paths
	 *
	 * @param Phalcon_Dispatcher $dispatcher
	 */
	public static function setDispatcher($dispatcher){
	}

	/**
	 * Internally gets the request dispatcher
	 *
	 * @return Phalcon_Dispatcher
	 */
	protected static function _getDispatcher(){
	}

	/**
	 * Assigns default values to generated tags by helpers
	 *
	 * <code>
	 * //Assigning "peter" to "name" component
	 * Phalcon_Tag::setDefault("name", "peter");
	 *
	 * //Later in the view
	 * echo Phalcon_Tag::textField("name"); //Will have the value "peter" by default
	 * </code>
	 *
	 * @param string $id
	 * @param string $value
	 */
	public static function setDefault($id, $value){
	}

	/**
	 * Alias of Phalcon_Tag::setDefault
	 *
	 * @param string $id
	 * @param string $value
	 */
	public static function displayTo($id, $value){
	}

	/**
	 * Every helper calls this function to check whether a component has a predefined
	 * value using Phalcon_Tag::displayTo or value from $_POST
	 *
	 * @param string $name
	 * @return mixed
	 */
	public static function getValue($name){
	}

	/**
	 * Resets the request and internal values to avoid those fields will have any default value
	 */
	public static function resetInput(){
	}

	/**
	 * Builds a HTML A tag using framework conventions
	 *
	 * <code>echo Phalcon_Tag::linkTo('signup/register', 'Register Here!')</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function linkTo($parameters, $text=NULL){
	}

	/**
	 * Builds generic INPUT tags
	 *
	 * @param   string $type
	 * @param	array $parameters
	 * @return	string
	 */
	protected static function _inputField($type, $parameters){
	}

	/**
	 * Builds a HTML input[type="text"] tag
	 *
	 * <code>echo Phalcon_Tag::textField(array("name", "size" => 30))</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function textField($parameters){
	}

	/**
	 * Builds a HTML input[type="password"] tag
	 *
	 * <code>echo Phalcon_Tag::passwordField(array("name", "size" => 30))</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function passwordField($parameters){
	}

	/**
	 * Builds a HTML input[type="hidden"] tag
	 *
	 * <code>echo Phalcon_Tag::hiddenField(array("name", "value" => "mike"))</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function hiddenField($parameters){
	}

	/**
	 * Builds a HTML input[type="file"] tag
	 *
	 * <code>echo Phalcon_Tag::fileField("file")</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function fileField($parameters){
	}

	/**
	 * Builds a HTML input[type="check"] tag
	 *
	 * <code>echo Phalcon_Tag::checkField(array("name", "size" => 30))</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function checkField($parameters){
	}

	/**
	 * Builds a HTML input[type="submit"] tag
	 *
	 * <code>echo Phalcon_Tag::submitButton("Save")</code>
	 *
	 * @param	array $params
	 * @return	string
	 */
	public static function submitButton($parameters){
	}

	/**
	 * Builds a HTML SELECT tag using a PHP array for options
	 *
	 * <code>echo Phalcon_Tag::selectStatic("status", array("A" => "Active", "I" => "Inactive"))</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function selectStatic($parameters, $data=NULL){
	}

	/**
	 * Builds a HTML SELECT tag using a Phalcon_Model resultset as options
	 *
	 * <code>echo Phalcon_Tag::selectStatic(array(
	 *	"robotId",
	 *	Robots::find("type = 'mechanical'"),
	 *	"using" => array("id", "name")
	 * ))</code>
	 *
	 * @param	array $params
	 * @return	string
	 */
	public static function select($parameters, $data=NULL){
	}

	/**
	 * Builds a HTML TEXTAREA tag
	 *
	 * <code>echo Phalcon_Tag::textArea(array("comments", "cols" => 10, "rows" => 4))</code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function textArea($parameters){
	}

	/**
	 * Builds a HTML FORM tag
	 *
	 * <code>
	 * echo Phalcon_Tag::form("posts/save");
	 * echo Phalcon_Tag::form(array("posts/save", "method" => "post"));
	 * </code>
	 *
	 * @param	array $parameters
	 * @return	string
	 */
	public static function form($parameters=NULL){
	}

	/**
	 * Builds a HTML close FORM tag
	 *
	 * @return	string
	 */
	public static function endForm(){
	}

	/**
	 * Set the title of view content
	 *
	 * @param string $title
	 */
	public static function setTitle($title){
	}

	/**
	 * Add to title of view content
	 *
	 * @param string $title
	 */
	public static function appendTitle($title){
	}

	/**
	 * Add before the title of view content
	 *
	 * @param string $title
	 */
	public static function prependTitle($title){
	}

	/**
	 * Get the title of view content
	 *
	 * @return string
	 */
	public static function getTitle(){
	}

	/**
	 * Builds a LINK[rel="stylesheet"] tag
	 *
	 * <code>
	 * echo Phalcon_Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
	 * echo Phalcon_Tag::stylesheetLink("css/style.css");
	 * </code>
	 *
	 * @param	array $parameters
	 * @param   boolean $local
	 * @return	string
	 */
	public static function stylesheetLink($parameters=NULL, $local=true){
	}

	/**
	 * Builds a SCRIPT[type="javascript"] tag
	 *
	 * <code>
	 * echo Phalcon_Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
	 * echo Phalcon_Tag::javascriptInclude("javascript/jquery.js");
	 * </code>
	 *
	 * @param	array $parameters
	 * @param   boolean $local
	 * @return	string
	 */
	public static function javascriptInclude($parameters=NULL, $local=true){
	}

	/**
	 * Builds HTML IMG tags
	 *
	 * @param  array $parameters
	 * @return string
	 */
	public static function image($parameters=NULL){
	}

}


class Phalcon_Text
{
	/**
	 * Converts strings to camelize style
	 *
	 * <code>Phalcon_Utils::camelize('coco_bongo'); //CocoBongo</code>
	 *
	 * @param string $str
	 * @return string
	 */
	public static function camelize($str){
	}

	/**
	 * Uncamelize strings which are camelized
	 *
	 * <code>Phalcon_Utils::camelize('CocoBongo'); //coco_bongo</code>
	 *
	 * @param string $str
	 * @return string
	 */
	public static function uncamelize($str){
	}

}

/**
 * Phalcon_Transaction
 *
 * Transactions are protective blocks where SQL statements are only permanent if they can
 * all succeed as one atomic action. Phalcon_Transaction is intended to be used with Phalcon_Model_Base.
 * Phalcon Transactions should be created using Phalcon_Transaction_Manager.
 *
 *<code>
 *try {
 *
 *  $transaction = Phalcon_Transaction_Manager::get();
 *
 *  $robot = new Robots();
 *  $robot->setTransaction($transaction);
 *  $robot->name = 'WALL·E';
 *  $robot->created_at = date('Y-m-d');
 *  if($robot->save()==false){
 *    $transaction->rollback("Can't save robot");
 *  }
 *
 *  $robotPart = new RobotParts();
 *  $robotPart->setTransaction($transaction);
 *  $robotPart->type = 'head';
 *  if($robotPart->save()==false){
 *    $transaction->rollback("Can't save robot part");
 *  }
 *
 *  $transaction->commit();
 *
 *}
 *catch(Phalcon_Transaction_Failed $e){
 *  echo 'Failed, reason: ', $e->getMessage();
 *}
 *
 *</code>
 */
class Phalcon_Transaction
{
	/**
	 * Phalcon_Transaction constructor
	 *
	 * @param boolean $autoBegin
	 */
	public function __construct($autoBegin=false){
	}

	/**
	 * Sets transaction manager related to the transaction
	 *
	 * @param Phalcon_Transaction_Manager $manager
	 */
	public function setTransactionManager($manager){
	}

	/**
	 * Starts the transaction
	 */
	public function begin(){
	}

	/**
	 * Commits the transaction
	 *
	 * @return boolean
	 */
	public function commit(){
	}

	/**
	 * Rollbacks the transaction
	 *
	 * @param  string $rollbackMessage
	 * @param  Phalcon_Model_Base $rollbackRecord
	 * @return boolean
	 */
	public function rollback($rollbackMessage=NULL, $rollbackRecord=NULL){
	}

	/**
	 * Returns connection related to transaction
	 *
	 * @return Phalcon_Db
	 */
	public function getConnection(){
	}

	/**
	 * Sets if is a reused transaction or new once
	 *
	 * @param boolean $isNew
	 */
	public function setIsNewTransaction($isNew){
	}

	/**
	 * Sets flag to rollback on abort the HTTP connection
	 *
	 * @param boolean $rollbackOnAbort
	 */
	public function setRollbackOnAbort($rollbackOnAbort){
	}

	/**
	 * Checks whether transaction is managed by a transaction manager
	 *
	 * @return boolean
	 */
	public function isManaged(){
	}

	/**
	 * Changes dependency internal pointer
	 *
	 * @param int $pointer
	 */
	public function setDependencyPointer($pointer){
	}

	/**
	 * Attaches Phalcon_Model_Base object to the active transaction
	 *
	 * @param int $pointer
	 * @param Phalcon_Model_Base $object
	 */
	public function attachDependency($pointer, $object){
	}

	/**
	 * Make a bulk save on all attached objects
	 *
	 * @return boolean
	 */
	public function save(){
	}

	/**
	 * Returns validations messages from last save try
	 *
	 * @return array
	 */
	public function getMessages(){
	}

	/**
     * Checks whether internal connection is under an active transaction
     *
     * @return boolean
     */
	public function isValid(){
	}

	/**
	 * Sets object which generates rollback action
	 *
	 * @param Phalcon_Model_Base $record
	 */
	public function setRollbackedRecord($record){
	}

}

/**
 * Phalcon_Translate
 *
 * Translate component allows the creation of multi-language applications using
 * different adapters for translation lists.
 */
class Phalcon_Translate implements ArrayAccess
{
	/**
	 * Phalcon_Translate constructor
	 *
	 * @param	string $adapter
	 * @param	array $options
	 */
	public function __construct($adapter, $options){
	}

	/**
	 * Returns the translation string of the given key
	 *
	 * @param	string $translateKey
	 * @param	array $placeholders
	 * @return	string
	 */
	public function _($translateKey, $placeholders=array ()){
	}

	/**
	 * Sets a translation value
	 *
	 * @param 	string $offset
	 * @param 	string $value
	 */
	public function offsetSet($offset, $value){
	}

	/**
     * Check whether a translation key exists
     *
     * @param	string $translateKey
     * @return	boolean
     */
	public function offsetExists($translateKey){
	}

	/**
     * Elimina un indice del diccionario
     *
     * @param	string $offset
     */
	public function offsetUnset($offset){
	}

	/**
	 * Returns the translation related to the given key
	 *
	 * @param	string $traslateKey
	 * @return	string
	 */
	public function offsetGet($traslateKey){
	}

}

/**
 * Phalcon_Utils
 *
 * Implements functionality used widely by the framework
 */
class Phalcon_Utils
{
	/**
	 * This function is now deprecated, use Phalcon_Text::camelize instead
	 *
	 * @param string $str
	 * @return string
	 */
	public static function camelize($str){
	}

	/**
	 * This function is now deprecated, use Phalcon_Text::uncamelize instead
	 *
	 * @param string $str
	 * @return string
	 */
	public static function uncamelize($str){
	}

	/**
	 * Gets public URL to phalcon instance
	 *
	 * @param string $uri
	 * @return string
	 */
	public static function getUrl($uri=NULL){
	}

	/**
	 * Gets path to local file
	 *
	 * @param string $extraPath
	 * @return string
	 */
	public static function getLocalPath($extraPath=NULL){
	}

}

/**
 * Phalcon_View
 *
 * Phalcon_View is a class for working with the "view" portion of the model-view-controller pattern.
 * That is, it exists to help keep the view script separate from the model and controller scripts.
 * It provides a system of helpers, output filters, and variable escaping.
 *
 * <code>
 * //Setting views directory
 * $view = new Phalcon_View();
 * $view->setViewsDir('app/views/');
 *
 * $view->start();
 * //Shows recent posts view (app/views/posts/recent.phtml)
 * $view->render('posts', 'recent');
 * $view->finish();
 *
 * //Printing views output
 * echo $view->getContent();
 * </code>
 */
class Phalcon_View
{
	const LEVEL_MAIN_LAYOUT = 5;
	const LEVEL_AFTER_TEMPLATE = 4;
	const LEVEL_LAYOUT = 3;
	const LEVEL_BEFORE_TEMPLATE = 2;
	const LEVEL_ACTION_VIEW = 1;
	const LEVEL_NO_RENDER = 0;
	/**
	 * Sets views directory. Depending of your platform, always add a trailing slash or backslash
	 *
	 * @param string $viewsDir
	 */
	public function setViewsDir($viewsDir){
	}

	/**
	 * Gets views directory
	 *
	 * @return string
	 */
	public function getViewsDir(){
	}

	/**
	 * Sets base path. Depending of your platform, always add a trailing slash or backslash
	 *
	 * <code>
	 * $view->setBasePath(__DIR__.'/');
	 * </code>
	 *
	 * @param string $basePath
	 */
	public function setBasePath($basePath){
	}

	/**
	 * Sets the render level for the view
	 *
	 * <code>
	 * //Render the view related to the controller only
	 * $this->view->setRenderLevel(Phalcon_View::LEVEL_VIEW);
	 * </code>
	 *
	 * @param string $level
	 */
	public function setRenderLevel($level){
	}

	/**
	 * Sets default view name. Must be a file without extension in the views directory
	 *
	 * <code>
	 * //Renders as main view views-dir/inicio.phtml
	 * $this->view->setMainView('inicio');
	 * </code>
	 *
	 * @param string $name
	 */
	public function setMainView($viewPath){
	}

	/**
	 * Appends template before controller layout
	 *
	 * @param string|array $templateBefore
	 */
	public function setTemplateBefore($templateBefore){
	}

	/**
	 * Resets any template before layouts
	 *
	 */
	public function cleanTemplateBefore(){
	}

	/**
	 * Appends template after controller layout
	 *
	 * @param string|array $templateAfter
	 */
	public function setTemplateAfter($templateAfter){
	}

	/**
	 * Resets any template before layouts
	 *
	 */
	public function cleanTemplateAfter(){
	}

	/**
	 * Adds parameters to views (alias of setVar)
	 *
	 * @param string $key
	 * @param mixed $value
	 */
	public function setParamToView($key, $value){
	}

	/**
	 * Adds parameters to views
	 *
	 * @param string $key
	 * @param mixed $value
	 */
	public function setVar($key, $value){
	}

	/**
	 * Returns parameters to views
	 *
	 * @return array
	 */
	public function getParamsToView(){
	}

	/**
	 * Gets the name of the controller rendered
	 *
	 * @return string
	 */
	public function getControllerName(){
	}

	/**
	 * Gets the name of the action rendered
	 *
	 * @return string
	 */
	public function getActionName(){
	}

	/**
	 * Gets extra parameters of the action rendered
	 */
	public function getParams(){
…

Large files files are truncated, but you can click here to view the full file