List available endoints for a given endpoint technology.

@param string $tech Technology of the endpoints (sip,iax2,...)
@return \phparia\Resources\Endpoint[]
@throws NotFoundException
4295
public function getEndpointsByTech($tech)
    {
        $uri = "endpoints/$tech";
        try {
            $response = $this->client->getEndpoint()->get($uri);
        } catch (RequestException $e) {
            $this->processRequestException($e);
        }

        $endpoints = [];
        foreach (\GuzzleHttp\json_decode($response->getBody()) as $endpoint) {
            $endpoints[] = new Endpoint($this->client, $endpoint);
        }

        return $endpoints;
    }
436416
protected function getEndpoint($method)
    {
        $endpoint = "me/email_verify";
        $nonce = $this->getArgument("nonce");
        if (!is_null($nonce)) {
            $endpoint .= "/$nonce";
            $this->delArgument("nonce");
        }
        return $endpoint;
    }
753543
public function endpoint(ApiEndpoint $endpoint)
    {
        $this->endpointsByName[$endpoint->getName()] = $endpoint;

        switch ($endpoint->getHttpMethod()) {

            case HttpMethods::GET:

                $this->get($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;

            case HttpMethods::POST:

                $this->post($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;

            case HttpMethods::PUT:

                $this->put($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;

            case HttpMethods::DELETE:

                $this->delete($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;
        }

        return $this;
    }
1012223
@Override
    public CFEndPoint[] getEndPoints(CFEndPoint[] endPointList, CFEndPointCriteria criteria) {
        return commonGetEndPoints(endPointList, criteria, false);
    }
770554
private function loadAllEndpoints()
    {
        self::$endpointClasses = array_map(function ($classPath) {
            // For ./Api/Endpoints/MatchById -> ('MatchById.php')
            list($endpointClass) = array_slice(explode('/', $classPath), -1, 1);
            
            // Build the full class name with namespace
            $fullClassName = join('\\', [__NAMESPACE__, 'Endpoints', str_replace('.php', '', $endpointClass)]);
            
            /** @var Endpoint $endpoint */
            $endpoint = new $fullClassName($this->region);
            
            self::$endpointDefinitions[$endpoint->getName()] = [
                'class' => $fullClassName,
                'instance' => $endpoint,
            ];
            
            return $fullClassName;
        }, glob(__DIR__.'/Endpoints/*.php'));
    }
236843
public function api(string $method, string $endpoint, array $data = []): array
    {
        $endpoint = '/' . ltrim($endpoint, '/'); // Ensure leading slash is present
        return $this->api->call($method, $endpoint, $data);
    }
244905
public function getValue($endpoint, $key)
    {
        if (isset($this->endpoints['endpoints'][$endpoint])
            && isset($this->endpoints['endpoints'][$endpoint][$key])
        ) {
            return $this->endpoints['endpoints'][$endpoint][$key];
        }

        if (isset($this->endpoints[$key])) {
            return $this->endpoints[$key];
        }

        return null;
    }
280072
private function callEndpoint($tracking)
    {
        $trackingHolder = is_array($tracking) ? $tracking : array($tracking);
        $trackingCollection = new Request\TrackingRequestCollection();

        foreach ($trackingHolder as $tracking) {
            if (!$tracking instanceof Tracking\AbstractTracking) {
                continue;
            }

            $payloadData = $this->getTrackingPayloadData($tracking);

            $trackingRequest = new Request\TrackingRequest($payloadData);
            $trackingCollection->add($trackingRequest);
        }

        $adapterOptions = $this->getOption('adapter');
        $clientAdapter = $this->clientAdapter;
        $clientAdapter->setOptions($adapterOptions);

        return $clientAdapter->send($this->apiEndpointUrl, $trackingCollection);
    }
1015157
protected function getDevicesFromSessions(Carbon $start, Carbon $end)
    {
        return $this->getVisitorsFilteredByDateRange($start, $end)
            ->filter(function (Visitor $session) {
                return $session->hasDevice();
            })
            ->transform(function (Visitor $session) {
                return $session->device;
            })
            ->groupBy('kind')
            ->transform(function (Collection $items, $key) {
                return [
                    'kind'  => trans("tracker::devices.kinds.$key"),
                    'count' => $items->count(),
                ];
            });
    }
282613
public function endpoints()
	{
		if (isset($this->endpoints)) {
			return $this->endpoints;
		}
		
		return $this->endpoints = DB::table('oauth_client_endpoints')
			->select('redirect_uri')
			->where('client_id', $this->id)
			->lists('redirect_uri');
	}
467074
public function getAPIEndpoint($uri = false)
    {
        $endpoint = $this->getBase() . '/' . $this->getVersion() . '/';

        if ($uri) {
            $endpoint .= $uri;
        }

        return $endpoint;
    }
744971
protected function getEndpoint($method)
    {
        $endpoint = 'inspect';
        $number = $this->getArgument("number");
        if (!is_null($number)) {
            $endpoint .= "/$number";
            $this->delArgument("number");
        }
        return $endpoint;
    }
243088
protected function getEndpoints(InputInterface $input): array
    {
        $endpointsName = $input->getOption('endpoint');
        $endpoints = Endpoints::filter($endpointsName);

        if (count($endpointsName) > count($endpoints)) {
            throw new Exception(sprintf(
                'Endpoint not found. Endpoints available: %s',
                implode(', ', array_keys(Endpoints::all()))
            ));
        }

        return $endpoints;
    }
579986
public function getEndpoints($serviceType)
	{
		if (is_null($this->token)) {
			throw new OpenstackException('Unauthenticated');
		}
		$serviceEndpoints = array();
		foreach ($this->serviceCatalog as $value) {
			if ($value['type'] == $serviceType) {
				$serviceEndpoints = $value['endpoints'];
			}
		}
		return $serviceEndpoints;
	}
48790
public function getOptionsDescriptions()
    {
        return [
            self::OPTION_ENDPOINT_ROUTE => ['Internal use only: Route that was applied to resolve the Endpoint URI', []],
            self::OPTION_EXCHANGE_PATTERN => [
                'Exchange pattern to communicate with this endpoint',
                [
                    self::EXCHANGE_PATTERN_IN_ONLY => 'The endpoint will not block the flow or modify the message',
                    self::EXCHANGE_PATTERN_IN_OUT => 'The endpoint will block the flow and update the message',
                ],
            ],
            self::OPTION_USERNAME => ['Username to authenticate in this endpoint', []],
            self::OPTION_PASSWORD => ['Password to authenticate in this endpoint', []],
            self::OPTION_TRACK => ['Whether to track the events this endpoint or not', []],
        ];
    }
258059
public function getAvailablePlatforms()
    {
        $platforms = array();

        foreach ($this->getSupportedDrivers() as $driverName => $driverClass) {
            $driver = new $driverClass;
            $platforms[$driverName] = $driver->getDatabasePlatform();
        }

        return $platforms;
    }
306505
public function getAllHostIPAddresses()
    {
        list($start_ip, $end_ip) = $this->getIPAddressRangeAsInts();

        if ($this->getNetworkSize() < 31) {
            $start_ip += 1;
            $end_ip   -= 1;
        }

        for ($ip = $start_ip; $ip <= $end_ip; $ip++) {
            yield long2ip($ip);
        }
    }