To be able to allow user to pick a valid channel combination for a given AP you should use the following api to retrieve the list of allowed channel combination.
@param int $accessPointId
@return models\WiFi\APStation\Station[]
518950
public function getStationsFromId( $accessPointId) {
        $service = sprintf( self::API_WIFI_AP_STATIONS, $accessPointId);
        $rest = $this->getService( $service);
        $rest->GET();

        return $rest->getResultAsArray( models\WiFi\APStation\Station::class);
    }
1236016
public function getComCodes($postId)
    {
        try {
            return $this->bizImpl->getComCodes($postId);
        } catch (\Throwable $throwable) {
            throw new SystemException($throwable->getMessage());
        }
    }
281364
public function index($locationId)
    {
        /** @noinspection PhpUndefinedMethodInspection */
        $location = Location::findOrFail($locationId);
        $this->authorize('view', $location);
        return $this->respondRelatedAddresses($locationId, 'location');
    }
1182155
public function getUserCapabilities(string $userId): array
    {
        if (empty($this->userCapabilities)) {
            $this->userCapabilities = Utils::fetchUserCapabilities($userId);
        }

        return $this->userCapabilities;
    }
147569
protected function getCombinesForPackage($packageId)
    {
        $cacheKey = 'packageCombines.'.$packageId;
        $packageCombines = $this->getCachedValue($cacheKey);
        if ($packageCombines === false) {
            $packageCombines = array();

            $data = $this->dataProvider->getData();
            if (isset($data[$packageId])) {
                $info = $data[$packageId];
                if (isset($info['Combines']) && is_array($info['Combines'])) {
                    $packageCombines = $info['Combines'];
                }
            }

            $this->setCachedValue($cacheKey, $packageCombines);
        }

        return $packageCombines;
    }
33885
protected function pageResourceMapper($resourceId)
    {
        if (!$this->resourceName->isPagesResourceId($resourceId)) {
            return null;
        }

        $resources = explode('.', $resourceId);

        if (empty($resources[1])) {
            return null;
        }

        $siteResourceId = $this->resourceName->get(self::RESOURCE_SITES, $resources[1]);

        $return = [
            'resourceId' => $resourceId,
            'parentResourceId' => $siteResourceId,
        ];

        if ($this->resourceName->isPageResourceId($resourceId)) {
            $pagesResourceId = $this->resourceName->get(self::RESOURCE_SITES, $resources[1], self::RESOURCE_PAGES);
            $return['parentResourceId'] = $pagesResourceId;
        }

        return array_merge(
            $this->resources[self::RESOURCE_PAGES],
            $return
        );
    }
637326
public function getChannel($channel_id = null)
    {
        $index = $channel_id ?: 'default';
        if (!array_key_exists($index, $this->channels)) {
            $this->channels[$index] = $this->connection->channel($channel_id);
        }
        return $this->channels[$index];
    }
1124674
public function getAllCapabilitiesForDevice($deviceID)
    {
        $devices = array_reverse($this->getDeviceHierarchy($deviceID));
        $capabilities = array();
        
        foreach ($devices as $device) {
            if (is_array($device->capabilities)) {
                $capabilities = array_merge($capabilities, $device->capabilities);
            }
        }
        return $capabilities;
    }
1235594
public function getParent($parentId)
    {
        if ($parentId && isset($this->site->pages[$parentId])) {
            return $this->site->pages[$parentId];
        }

        return [];
    }
461426
public function getFallBackDevices($deviceId)
    {
        $fallBackDevices = $this->getDeviceRepository()->getDeviceHierarchy($deviceId);

        array_shift($fallBackDevices);

        return array_map(array($this, 'deviceId'), $fallBackDevices);
    }
177908
public function broadcastWith()
    {
        return [
            'id' => $this->id,
            'webhook' => $this->webhook,
            'request' => $this->request,
            'response' => $this->response,
            'status' => $this->status,
        ];
    }
487049
public function channelGroupPermList($cgid, $permsid = FALSE)
  {
    return $this->execute("channelgrouppermlist", array("cgid" => $cgid, $permsid ? "-permsid" : null))->toAssocArray($permsid ? "permsid" : "permid");
  }
1239961
public function getContext($channelSid) {
        return new UserChannelContext(
            $this->version,
            $this->solution['serviceSid'],
            $this->solution['userSid'],
            $channelSid
        );
    }
1071518
protected function getSiteForRootPageId(int $pageId): array
    {
        return is_array($this->sites[$pageId]) ? $this->sites[$pageId] : [];
    }
258172
public function cmsSlotWidgets($slotId, $slotOptions = [])
    {
        $currentView = $this->currentViewHelper->getUpdatedCurrentView();

        $result = '';
        $slotOptions = $this->widgetRenderer->computeOptions($slotId, $slotOptions);

        if ($currentView && !empty($currentView->getBuiltWidgetMap()[$slotId])) {
            //parse the widget maps

            /* @var WidgetMap $widgetMap */
            foreach ($currentView->getBuiltWidgetMap()[$slotId] as $widgetMap) {
                $widget = null;

                try {
                    //get the widget
                    $widget = $this->widgetResolver->resolve($widgetMap);
                    if ($widget) {
                        if (!$widgetMap->isAsynchronous()) {
                            //render this widget
                            $result .= $this->cmsWidget($widget);
                        } else {
                            $result .= $this->widgetRenderer->prepareAsynchronousRender($widget);
                        }
                    }
                } catch (\Exception $ex) {
                    $result .= $this->widgetExceptionHandler->handle($ex, $currentView, $widget);
                }
            }
        }
        //the container for the slot
        $ngSlotControllerName = 'slot'.$slotId.'Controller';
        $ngInitLoadActions = $this->isRoleVictoireGranted() ? sprintf('ng-init=\'%s.init("%s", %s)\'', $ngSlotControllerName, $slotId, json_encode($slotOptions)) : '';
        $result = sprintf(
            '<div class="vic-slot" data-name="%s" id="vic-slot-%s" ng-controller="SlotController as %s" %s>%s</div>',
            $slotId,
            $slotId,
            $ngSlotControllerName,
            $ngInitLoadActions,
            $result
        );

        return $result;
    }
50372
public function getPerimetersConfiguration($siteId)
    {
        $perimetersConfiguration = array();
        foreach ($this->strategies as $strategy) {
            $perimetersConfiguration = array_merge(
                $perimetersConfiguration,
                array($strategy->getType() => $strategy->getPerimeterConfiguration($siteId))
            );
        }

        return $perimetersConfiguration;
    }
837460
public function channel($name, $options = [])
    {
        if (empty($this->_channels[$name])) {
            $this->_channels[$name] = new AMQPChannel($this->connection());
            if (!empty($options['prefetchCount'])) {
                $this->_channels[$name]->setPrefetchCount((int)$options['prefetchCount']);
            }
        }

        return $this->_channels[$name];
    }