Returns an array with all required input.

@return array
977771
protected function collectInput()
    {
        $password = $this->generateRandomPassword();

        return [
            'name' => $this->argument('name') ? $this->argument('name') : '',
            'email' => $this->argument('email'),
            'password' => $password,
            'password_confirmation' => $password,
        ];
    }
211490
public function toArray() {
		return [
			'key' => $this->key(),
			'url' => $this->url(),
			'formData' => $this->formData(),
			'cacheControl' => $this->cacheControl(),
			'expires' => $this->expires(),
			'acl' => $this->acl()
		];
	}
815247
public function getInputSpecification() : array
    {
        $spec = [
            'name'     => $this->getName(),
            'required' => $this->isRequired(),
        ];

        $filters = $this->getFilters();

        if ($this->node->hasAttribute('data-filters')) {
            foreach ($this->parseDataAttribute($this->node->getAttribute('data-filters')) as $name => $options) {
                $filters[] = [
                    'name'    => $name,
                    'options' => $options,
                ];
            }
        }

        if (! empty($filters)) {
            $spec['filters'] = $filters;
        }

        $validators = $this->getValidators();

        if ($this->node->hasAttribute('data-validators')) {
            foreach ($this->parseDataAttribute($this->node->getAttribute('data-validators')) as $name => $options) {
                $validators[] = [
                    'name'    => $name,
                    'options' => $options,
                ];
            }
        }

        if (! empty($validators)) {
            $spec['validators'] = $validators;
        }

        return $spec;
    }
1270711
public function getAll(): array
    {
        $this->rewind();
        $allValues = [];
        while ($this->valid()) {
            $allValues[] = $this->getCurrentElement()->getValue();
            $this->next();
        }
        return $allValues;
    }
419377
public function toArray()
    {
        $raw = $this->dsn->toArray();
        $allKeys = array_unique(array_merge(static::$mandatoryKeys, array_keys($raw)));
        $return = [];

        foreach ($allKeys as $key) {
            if (isset($this->keyMap[$key])) {
                $key = $this->keyMap[$key];
                if (!$key) {
                    continue;
                }
            }

            $val = $this->$key;
            if ($val !== null) {
                $return[$key] = $val;
            }
        }

        return $return;
    }
271179
private function getInputs()
    {
        // If defined, return the inputs array
        if ($this->inputs) {
            return $this->inputs;
        }

        // Check for JSON data
        if (isset($_SERVER['CONTENT_TYPE']) && strpos($_SERVER['CONTENT_TYPE'], 'application/json') === 0) {
            $input = file_get_contents('php://input');
            $decoded = json_decode($input, true);
            if ($decoded) {
                $this->inputs = $decoded;
                return $this->inputs;
            }
        }

        // Check by request method
        switch ($_SERVER['REQUEST_METHOD']) {

            // Get PUT inputs
            case 'PUT':
                parse_str(file_get_contents("php://input"), $this->inputs);
                break;

            // Get POST inputs
            case 'POST':
                $this->inputs = filter_input_array(INPUT_POST, FILTER_SANITIZE_STRING);
                break;

            // Get GET inputs
            default:
                $this->inputs = filter_input_array(INPUT_GET, FILTER_SANITIZE_STRING);
                break;
        }

        // Return array of inputs
        return $this->inputs ? : [];
    }
1078957
public function toArray()
    {
        return [
            'text' => $this->getText($this->getModel()),
            'attributes' => $this->getConditionAttributes($this->model)->htmlAttributesToString(),
            'url' => $this->getUrl($this->getModel()),
            'position' => $this->getPosition(),
            'icon' => $this->getIcon(),
            'hideText' => $this->hideText,
        ];
    }
453468
public function toArray(): array
    {
        return  [
            'countryCode' => $this->getCountryCode(),
            'vatNumber'   => $this->getVatNumber(),
            'requestDate' => $this->getRequestDate()->format('Y-m-d'),
            'valid'       => $this->isValid(),
            'name'        => $this->getName(),
            'address'     => $this->getAddress(),
            'identifier'  => $this->getIdentifier(),
            'nameMatch'   => $this->getNameMatch(),
            'companyTypeMatch' => $this->getCompanyTypeMatch(),
            'streetMatch' => $this->getStreetMatch(),
            'postcodeMatch' => $this->getPostcodeMatch(),
            'cityMatch' => $this->getCityMatch(),
        ];
    }
320933
public function toArray()
	{
		$array = array();
		for( $i=$this->interval->getStart(); $i<$this->interval->getEnd(); $i++ )
		{
			$value = $this->getPartialSum( $this->interval->getStart(), $i );
			$array[$i] = $value;
		}
		return $array;
	}
856004
public function toArray()
	{
		$result = [];
		
		foreach (get_class_methods($this) as $method)
		{
			if (stripos($method, 'get') === 0)
			{
				$result[strtolower(substr($method, 3))] = $this->{$method}();
			}
		}
		
		return $result;
	}
612983
public function getInput()
    {
        $data = $this->getRequest()->getParsedBody();
        
        if (is_array($data)) {
            $files = $this->getRequest()->getUploadedFiles();
            $data = array_replace_recursive($data, (array)$files);
        }
        
        return $data;
    }
763420
public function getAll()
    {
        $all = parent::getAll();
        $res = [];
        foreach ($all as $key => $raw) {
            $res[$key] = $raw['value'];
        }

        return $res;
    }
681122
public static function all(): array
    {
        $class = get_called_class();

        if (isset(self::$items[$class])) {
            return self::$items[$class];
        }

        $constants = static::constants();

        $items = [];

        foreach ($constants as $key => $value) {
            $items[$value] = new $class($key, $value);
        }

        return self::$items[$class] = $items;
    }
705941
public static function getAll(): array
    {
        return [
            self::GET,
            self::HEAD,
            self::POST,
            self::PUT,
            self::DELETE,
            self::CONNECT,
            self::OPTIONS,
            self::TRACE,
            self::PATCH,
        ];
    }
1152394
protected function getFormValues() {
    $input = array();
    foreach ($this->getInputParameters() as $parameter) {
      if (isset($_POST[$parameter['name']])) {
        $input[$parameter['name']] = $_POST[$parameter['name']];
      }
    }
    return $input;
  }
1245069
public function toArray()
    {
        return array_merge([
            'user' => $this->key,
            'device' => implode(',', $this->devices),
        ], $this->token ? ['token' => $this->token] : []);
    }
316560
public function toArray()
    {
        $arr = array();
        foreach ($this as $key => $value) {
            $method = 'get' . $key;
            if (method_exists($this, $method)) {
                $arr[$key] = $this->$method();
            }
        }

        return $arr;
    }