Returns array request methods

@return array
333206
public function getMethods()
    {
        return array_reduce(
            $this->_models,
            function ($result, $item) {
                $result[$item['method']] = $item['method'];
                return $result;
            },
            []
        );
    }
1193380
public function getPaymentMethods()
    {
        $paymentMethods = array();

        foreach ($this->data['data'] as $method) {
            $paymentMethods[] = new PaymentMethod(
                $method['id'],
                $method['description']
            );
        }

        return $paymentMethods;
    }
715001
public function getMethods()
    {
        $methods = parent::getMethods();
        $methods = array_diff($methods, $this->_exclude_actions);

        return $methods;
    }
808706
public function getParams(): array
    {
        $params = array();
        $args = $this->args;

        $params['apikey'] = $this->apiKey;

        $methods = Client::getMethods();

        foreach ($methods[$this->method] as $key => $paramName) {
            if (isset($args[$key])) {
                $params[$paramName] = $args[$key];
            }
        }

        return $params;
    }
627125
private function _request()
    {
        $res = $this->_client->request(
            $this->_method,
            $this->_endpoint . '?' . $this->_query_parameters,
            [
                'headers' => $this->_headers,
                'http_errors' => false
            ]
        );
        return array(
            'code' => $res->getStatusCode(),
            'body' => new SimpleXMLElement($res->getBody())
        );
    }
678498
public function getActions() {
        $actions = array();
        foreach ($this->class->getMethods(ReflectionMethod::IS_PUBLIC) as $m) {
            if ($m->isConstructor() || $m->isDestructor() || in_array($m->name, self::$BLACK_LIST)) {
                continue;
            }

            if (is_subclass_of($m->class, 'Module') || is_subclass_of($m->class, Controller::class)) {
                $actions[] = new ActionDescription($m);
            }
        }
        return $actions;
    }
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;
	}
552711
public function toSoapRequestArray(): array
	{
		$configArray = $this->configArray();
		$data = parent::toArray();
		$withConfig = array_merge($configArray, $data);

		return DateTimeDeflater::processWithPaths(
			$withConfig,
			static::$dateTimePaths
		);
	}
1340501
public function resolveGetterMethods()
    {
        $resolved = [];
        $methods = get_class_methods($this);
        
        if (!$methods) {
            return [];
        }
        
        foreach ($methods as $method) {
            if (StringHelper::startsWith($method, 'get', true)) {
                $resolved[] = lcfirst(StringHelper::replaceFirst('get', '', $method));
            }
        }
        
        asort($resolved);
        
        return $resolved;
    }
733556
public function getFunctions()
    {
        return [
            'isCurrent' => new \Twig_Function_Method($this, 'isCurrent'),
            'file_exists' => new \Twig_Function_Method($this, 'functionFileExists'),
            'clean_string' => new \Twig_Function_Method($this, 'functionCleanString'),
            'asset' => new \Twig_Function_Method($this, 'functionGetAsset'),
            'url' => new \Twig_Function_Method($this, 'functionGetUrl'),
            'share_link' => new \Twig_Function_Method($this, 'functionShareLink', ['is_safe' => ['twig', 'html']]),
            'editButton' => new \Twig_Function_Method($this, 'functionEditButton', [
                'needs_environment' => true,
                'is_safe' => ['twig', 'html']
            ]),
        ];
    }
89646
protected function getRequestData()
    {
        return [
            'request'  => $this->request->toArray(),
            'response' => [
                'content'      => null,
                'content_type' => null,
                'status_code'  => ServiceResponseInterface::HTTP_OK
            ],
            'resource' => $this->resourcePath
        ];
    }
96094
public function getAllowedMethods(): ?array
    {
        if ($this->isSuccess()) {
            return $this->route
                ? $this->route->getAllowedMethods()
                : [];
        }

        return $this->allowedMethods;
    }
881960
public function getListFunctions() {
		if($this->listFunctions) return $this->listFunctions;

		$list = array ();
		foreach(ClassInfo::implementorsOf('SS_List') as $class) {
			$r = new ReflectionClass($class);			
			$methods = $r->getMethods();
			if($methods) {
				foreach($methods as $m) {
					$name = $m->getName();					
					if(preg_match("/[A-Z]/",$name[0])) {
						$list[] = strtolower($name);
					}											
				}
			}
		}

		return $this->listFunctions = $list;
	}
635187
final public function getActions() {
        $return = array();
        foreach (get_class_methods($this) as $method) {
            if (substr($method, strlen($method) - 6) === 'Action')
                $return[] = substr($method, 0, strlen($method) - 6);
        }
        return $return;
    }
1242130
public function actions()
    {
        $flag = [
            'actions',
            '__construct',
            '__toString',
            '__invoke',
            '__call',
            'offsetExists',
            'offsetGet',
            'offsetSet',
            'offsetUnset',
            '__get',
            '__set',
            '__isset',
            '__unset',
            'normalizeKey',
            'set',
            'get',
            'replace',
            'has',
            'remove',
            'getIterator',
        ];

        return [
            'classname' => get_class($this),
            'methods' => array_diff(get_class_methods($this), $flag),
            '_methods' => array_intersect(get_class_methods($this), $flag),
            '_sys' => array_intersect(get_class_methods($this), [
                'actions',
                'clear',
                'count',
                'all',
                'keys',
                'load'
            ]),
            '_config' => $class_vars = get_class_vars(get_class($this)),
        ];
    }
320598
public function method()
    {
        if (isset($this->parameters->post()['_method'])) {
            $method = strtoupper($this->parameters->post()['_method']);
            if (in_array($method, self::$allowedHackMethods)) {
                return $method;
            }
        }
        return $this->getParam('REQUEST_METHOD');
    }
684480
private function getClassMethods(): array
    {
        if (null !== $this->reflectionMethods) {
            return $this->reflectionMethods;
        }

        $this->reflectionMethods = [];

        $class = $this->reflectionClass;

        do {
            $this->reflectionMethods = \array_merge(
                $this->reflectionMethods,
                $class->getMethods()
            );
        } while ($class = $class->getParentClass());

        return $this->reflectionMethods;
    }