diff --git a/.openapi-generator/FILES b/.openapi-generator/FILES index 31d037e..24ab2a5 100644 --- a/.openapi-generator/FILES +++ b/.openapi-generator/FILES @@ -1,6 +1,7 @@ .gitignore .php_cs MuxPhp/Api/AssetsApi.php +MuxPhp/Api/DRMConfigurationsApi.php MuxPhp/Api/DeliveryUsageApi.php MuxPhp/Api/DimensionsApi.php MuxPhp/Api/DirectUploadsApi.php @@ -52,6 +53,8 @@ MuxPhp/Models/CreateTrackResponse.php MuxPhp/Models/CreateTranscriptionVocabularyRequest.php MuxPhp/Models/CreateUploadRequest.php MuxPhp/Models/CreateWebInputRequest.php +MuxPhp/Models/DRMConfiguration.php +MuxPhp/Models/DRMConfigurationResponse.php MuxPhp/Models/DeliveryReport.php MuxPhp/Models/DeliveryReportDeliveredSecondsByResolution.php MuxPhp/Models/DimensionValue.php @@ -96,6 +99,7 @@ MuxPhp/Models/ListAllMetricValuesResponse.php MuxPhp/Models/ListAssetsResponse.php MuxPhp/Models/ListBreakdownValuesResponse.php MuxPhp/Models/ListBreakdownValuesResponseMeta.php +MuxPhp/Models/ListDRMConfigurationsResponse.php MuxPhp/Models/ListDeliveryUsageResponse.php MuxPhp/Models/ListDimensionValuesResponse.php MuxPhp/Models/ListDimensionsResponse.php @@ -189,6 +193,7 @@ MuxPhp/ObjectSerializer.php README.md composer.json docs/Api/AssetsApi.md +docs/Api/DRMConfigurationsApi.md docs/Api/DeliveryUsageApi.md docs/Api/DimensionsApi.md docs/Api/DirectUploadsApi.md @@ -237,6 +242,8 @@ docs/Model/CreateTrackResponse.md docs/Model/CreateTranscriptionVocabularyRequest.md docs/Model/CreateUploadRequest.md docs/Model/CreateWebInputRequest.md +docs/Model/DRMConfiguration.md +docs/Model/DRMConfigurationResponse.md docs/Model/DeliveryReport.md docs/Model/DeliveryReportDeliveredSecondsByResolution.md docs/Model/DimensionValue.md @@ -281,6 +288,7 @@ docs/Model/ListAllMetricValuesResponse.md docs/Model/ListAssetsResponse.md docs/Model/ListBreakdownValuesResponse.md docs/Model/ListBreakdownValuesResponseMeta.md +docs/Model/ListDRMConfigurationsResponse.md docs/Model/ListDeliveryUsageResponse.md docs/Model/ListDimensionValuesResponse.md docs/Model/ListDimensionsResponse.md diff --git a/MuxPhp/Api/DRMConfigurationsApi.php b/MuxPhp/Api/DRMConfigurationsApi.php new file mode 100644 index 0000000..fd4de50 --- /dev/null +++ b/MuxPhp/Api/DRMConfigurationsApi.php @@ -0,0 +1,697 @@ +client = $client ?: new Client(); + $this->config = $config ?: new Configuration(); + $this->headerSelector = $selector ?: new HeaderSelector(); + $this->hostIndex = $hostIndex; + } + + /** + * Set the host index + * + * @param int $hostIndex Host index (required) + */ + public function setHostIndex($hostIndex) + { + $this->hostIndex = $hostIndex; + } + + /** + * Get the host index + * + * @return int Host index + */ + public function getHostIndex() + { + return $this->hostIndex; + } + + /** + * @return Configuration + */ + public function getConfig() + { + return $this->config; + } + + /** + * Operation getDrmConfiguration + * + * Retrieve a DRM Configuration + * + * @param string $drm_configuration_id The DRM Configuration ID. (required) + * + * @throws \MuxPhp\ApiException on non-2xx response + * @throws \InvalidArgumentException + * @return \MuxPhp\Models\DRMConfigurationResponse + */ + public function getDrmConfiguration($drm_configuration_id) + { + list($response) = $this->getDrmConfigurationWithHttpInfo($drm_configuration_id); + return $response; + } + + /** + * Operation getDrmConfigurationWithHttpInfo + * + * Retrieve a DRM Configuration + * + * @param string $drm_configuration_id The DRM Configuration ID. (required) + * + * @throws \MuxPhp\ApiException on non-2xx response + * @throws \InvalidArgumentException + * @return array of \MuxPhp\Models\DRMConfigurationResponse, HTTP status code, HTTP response headers (array of strings) + */ + public function getDrmConfigurationWithHttpInfo($drm_configuration_id) + { + $request = $this->getDrmConfigurationRequest($drm_configuration_id); + + try { + $options = $this->createHttpClientOption(); + try { + $response = $this->client->send($request, $options); + } catch (RequestException $e) { + throw new ApiException( + "[{$e->getCode()}] {$e->getMessage()}", + $e->getCode(), + $e->getResponse() ? $e->getResponse()->getHeaders() : null, + $e->getResponse() ? (string) $e->getResponse()->getBody() : null + ); + } + + $statusCode = $response->getStatusCode(); + + if ($statusCode < 200 || $statusCode > 299) { + throw new ApiException( + sprintf( + '[%d] Error connecting to the API (%s)', + $statusCode, + $request->getUri() + ), + $statusCode, + $response->getHeaders(), + $response->getBody() + ); + } + + $responseBody = $response->getBody(); + switch($statusCode) { + case 200: + if ('\MuxPhp\Models\DRMConfigurationResponse' === '\SplFileObject') { + $content = $responseBody; //stream goes to serializer + } else { + $content = (string) $responseBody; + } + + return [ + ObjectSerializer::deserialize($content, '\MuxPhp\Models\DRMConfigurationResponse', []), + $response->getStatusCode(), + $response->getHeaders() + ]; + } + + $returnType = '\MuxPhp\Models\DRMConfigurationResponse'; + $responseBody = $response->getBody(); + if ($returnType === '\SplFileObject') { + $content = $responseBody; //stream goes to serializer + } else { + $content = (string) $responseBody; + } + + return [ + ObjectSerializer::deserialize($content, $returnType, []), + $response->getStatusCode(), + $response->getHeaders() + ]; + + } catch (ApiException $e) { + switch ($e->getCode()) { + case 200: + $data = ObjectSerializer::deserialize( + $e->getResponseBody(), + '\MuxPhp\Models\DRMConfigurationResponse', + $e->getResponseHeaders() + ); + $e->setResponseObject($data); + break; + } + throw $e; + } + } + + /** + * Operation getDrmConfigurationAsync + * + * Retrieve a DRM Configuration + * + * @param string $drm_configuration_id The DRM Configuration ID. (required) + * + * @throws \InvalidArgumentException + * @return \GuzzleHttp\Promise\PromiseInterface + */ + public function getDrmConfigurationAsync($drm_configuration_id) + { + return $this->getDrmConfigurationAsyncWithHttpInfo($drm_configuration_id) + ->then( + function ($response) { + return $response[0]; + } + ); + } + + /** + * Operation getDrmConfigurationAsyncWithHttpInfo + * + * Retrieve a DRM Configuration + * + * @param string $drm_configuration_id The DRM Configuration ID. (required) + * + * @throws \InvalidArgumentException + * @return \GuzzleHttp\Promise\PromiseInterface + */ + public function getDrmConfigurationAsyncWithHttpInfo($drm_configuration_id) + { + $returnType = '\MuxPhp\Models\DRMConfigurationResponse'; + $request = $this->getDrmConfigurationRequest($drm_configuration_id); + + return $this->client + ->sendAsync($request, $this->createHttpClientOption()) + ->then( + function ($response) use ($returnType) { + $responseBody = $response->getBody(); + if ($returnType === '\SplFileObject') { + $content = $responseBody; //stream goes to serializer + } else { + $content = (string) $responseBody; + } + + return [ + ObjectSerializer::deserialize($content, $returnType, []), + $response->getStatusCode(), + $response->getHeaders() + ]; + }, + function ($exception) { + $response = $exception->getResponse(); + $statusCode = $response->getStatusCode(); + throw new ApiException( + sprintf( + '[%d] Error connecting to the API (%s)', + $statusCode, + $exception->getRequest()->getUri() + ), + $statusCode, + $response->getHeaders(), + $response->getBody() + ); + } + ); + } + + /** + * Create request for operation 'getDrmConfiguration' + * + * @param string $drm_configuration_id The DRM Configuration ID. (required) + * + * @throws \InvalidArgumentException + * @return \GuzzleHttp\Psr7\Request + */ + public function getDrmConfigurationRequest($drm_configuration_id) + { + // verify the required parameter 'drm_configuration_id' is set + if ($drm_configuration_id === null || (is_array($drm_configuration_id) && count($drm_configuration_id) === 0)) { + throw new \InvalidArgumentException( + 'Missing the required parameter $drm_configuration_id when calling getDrmConfiguration' + ); + } + + $resourcePath = '/video/v1/drm-configurations/{DRM_CONFIGURATION_ID}'; + $formParams = []; + $queryParams = []; + $headerParams = []; + $httpBody = ''; + $multipart = false; + + + + // path params + if ($drm_configuration_id !== null) { + $resourcePath = str_replace( + '{' . 'DRM_CONFIGURATION_ID' . '}', + ObjectSerializer::toPathValue($drm_configuration_id), + $resourcePath + ); + } + + + if ($multipart) { + $headers = $this->headerSelector->selectHeadersForMultipart( + ['application/json'] + ); + } else { + $headers = $this->headerSelector->selectHeaders( + ['application/json'], + [] + ); + } + + // for model (json/xml) + if (count($formParams) > 0) { + if ($multipart) { + $multipartContents = []; + foreach ($formParams as $formParamName => $formParamValue) { + $formParamValueItems = is_array($formParamValue) ? $formParamValue : [$formParamValue]; + foreach ($formParamValueItems as $formParamValueItem) { + $multipartContents[] = [ + 'name' => $formParamName, + 'contents' => $formParamValueItem + ]; + } + } + // for HTTP post (form) + $httpBody = new MultipartStream($multipartContents); + + } elseif ($headers['Content-Type'] === 'application/json') { + $httpBody = \GuzzleHttp\json_encode($formParams); + + } else { + // for HTTP post (form) + $httpBody = \GuzzleHttp\Psr7\build_query($formParams); + } + } + + // this endpoint requires HTTP basic authentication + if (!empty($this->config->getUsername()) || !(empty($this->config->getPassword()))) { + $headers['Authorization'] = 'Basic ' . base64_encode($this->config->getUsername() . ":" . $this->config->getPassword()); + } + + $defaultHeaders = []; + if ($this->config->getUserAgent()) { + $defaultHeaders['User-Agent'] = $this->config->getUserAgent(); + } + + $headers = array_merge( + $defaultHeaders, + $headerParams, + $headers + ); + + + // MUX: adds support for array params. + // TODO: future upstream? + $query = ObjectSerializer::buildBetterQuery($queryParams); + return new Request( + 'GET', + $this->config->getHost() . $resourcePath . ($query ? "?{$query}" : ''), + $headers, + $httpBody + ); + } + + /** + * Operation listDrmConfigurations + * + * List DRM Configurations + * + * @param int $page Offset by this many pages, of the size of `limit` (optional, default to 1) + * @param int $limit Number of items to include in the response (optional, default to 25) + * + * @throws \MuxPhp\ApiException on non-2xx response + * @throws \InvalidArgumentException + * @return \MuxPhp\Models\ListDRMConfigurationsResponse + */ + public function listDrmConfigurations($page = 1, $limit = 25) + { + list($response) = $this->listDrmConfigurationsWithHttpInfo($page, $limit); + return $response; + } + + /** + * Operation listDrmConfigurationsWithHttpInfo + * + * List DRM Configurations + * + * @param int $page Offset by this many pages, of the size of `limit` (optional, default to 1) + * @param int $limit Number of items to include in the response (optional, default to 25) + * + * @throws \MuxPhp\ApiException on non-2xx response + * @throws \InvalidArgumentException + * @return array of \MuxPhp\Models\ListDRMConfigurationsResponse, HTTP status code, HTTP response headers (array of strings) + */ + public function listDrmConfigurationsWithHttpInfo($page = 1, $limit = 25) + { + $request = $this->listDrmConfigurationsRequest($page, $limit); + + try { + $options = $this->createHttpClientOption(); + try { + $response = $this->client->send($request, $options); + } catch (RequestException $e) { + throw new ApiException( + "[{$e->getCode()}] {$e->getMessage()}", + $e->getCode(), + $e->getResponse() ? $e->getResponse()->getHeaders() : null, + $e->getResponse() ? (string) $e->getResponse()->getBody() : null + ); + } + + $statusCode = $response->getStatusCode(); + + if ($statusCode < 200 || $statusCode > 299) { + throw new ApiException( + sprintf( + '[%d] Error connecting to the API (%s)', + $statusCode, + $request->getUri() + ), + $statusCode, + $response->getHeaders(), + $response->getBody() + ); + } + + $responseBody = $response->getBody(); + switch($statusCode) { + case 200: + if ('\MuxPhp\Models\ListDRMConfigurationsResponse' === '\SplFileObject') { + $content = $responseBody; //stream goes to serializer + } else { + $content = (string) $responseBody; + } + + return [ + ObjectSerializer::deserialize($content, '\MuxPhp\Models\ListDRMConfigurationsResponse', []), + $response->getStatusCode(), + $response->getHeaders() + ]; + } + + $returnType = '\MuxPhp\Models\ListDRMConfigurationsResponse'; + $responseBody = $response->getBody(); + if ($returnType === '\SplFileObject') { + $content = $responseBody; //stream goes to serializer + } else { + $content = (string) $responseBody; + } + + return [ + ObjectSerializer::deserialize($content, $returnType, []), + $response->getStatusCode(), + $response->getHeaders() + ]; + + } catch (ApiException $e) { + switch ($e->getCode()) { + case 200: + $data = ObjectSerializer::deserialize( + $e->getResponseBody(), + '\MuxPhp\Models\ListDRMConfigurationsResponse', + $e->getResponseHeaders() + ); + $e->setResponseObject($data); + break; + } + throw $e; + } + } + + /** + * Operation listDrmConfigurationsAsync + * + * List DRM Configurations + * + * @param int $page Offset by this many pages, of the size of `limit` (optional, default to 1) + * @param int $limit Number of items to include in the response (optional, default to 25) + * + * @throws \InvalidArgumentException + * @return \GuzzleHttp\Promise\PromiseInterface + */ + public function listDrmConfigurationsAsync($page = 1, $limit = 25) + { + return $this->listDrmConfigurationsAsyncWithHttpInfo($page, $limit) + ->then( + function ($response) { + return $response[0]; + } + ); + } + + /** + * Operation listDrmConfigurationsAsyncWithHttpInfo + * + * List DRM Configurations + * + * @param int $page Offset by this many pages, of the size of `limit` (optional, default to 1) + * @param int $limit Number of items to include in the response (optional, default to 25) + * + * @throws \InvalidArgumentException + * @return \GuzzleHttp\Promise\PromiseInterface + */ + public function listDrmConfigurationsAsyncWithHttpInfo($page = 1, $limit = 25) + { + $returnType = '\MuxPhp\Models\ListDRMConfigurationsResponse'; + $request = $this->listDrmConfigurationsRequest($page, $limit); + + return $this->client + ->sendAsync($request, $this->createHttpClientOption()) + ->then( + function ($response) use ($returnType) { + $responseBody = $response->getBody(); + if ($returnType === '\SplFileObject') { + $content = $responseBody; //stream goes to serializer + } else { + $content = (string) $responseBody; + } + + return [ + ObjectSerializer::deserialize($content, $returnType, []), + $response->getStatusCode(), + $response->getHeaders() + ]; + }, + function ($exception) { + $response = $exception->getResponse(); + $statusCode = $response->getStatusCode(); + throw new ApiException( + sprintf( + '[%d] Error connecting to the API (%s)', + $statusCode, + $exception->getRequest()->getUri() + ), + $statusCode, + $response->getHeaders(), + $response->getBody() + ); + } + ); + } + + /** + * Create request for operation 'listDrmConfigurations' + * + * @param int $page Offset by this many pages, of the size of `limit` (optional, default to 1) + * @param int $limit Number of items to include in the response (optional, default to 25) + * + * @throws \InvalidArgumentException + * @return \GuzzleHttp\Psr7\Request + */ + public function listDrmConfigurationsRequest($page = 1, $limit = 25) + { + + $resourcePath = '/video/v1/drm-configurations'; + $formParams = []; + $queryParams = []; + $headerParams = []; + $httpBody = ''; + $multipart = false; + + // query params + if ($page !== null) { + if('form' === 'form' && is_array($page)) { + foreach($page as $key => $value) { + $queryParams[$key] = $value; + } + } + else { + $queryParams['page'] = $page; + } + } + // query params + if ($limit !== null) { + if('form' === 'form' && is_array($limit)) { + foreach($limit as $key => $value) { + $queryParams[$key] = $value; + } + } + else { + $queryParams['limit'] = $limit; + } + } + + + + + if ($multipart) { + $headers = $this->headerSelector->selectHeadersForMultipart( + ['application/json'] + ); + } else { + $headers = $this->headerSelector->selectHeaders( + ['application/json'], + [] + ); + } + + // for model (json/xml) + if (count($formParams) > 0) { + if ($multipart) { + $multipartContents = []; + foreach ($formParams as $formParamName => $formParamValue) { + $formParamValueItems = is_array($formParamValue) ? $formParamValue : [$formParamValue]; + foreach ($formParamValueItems as $formParamValueItem) { + $multipartContents[] = [ + 'name' => $formParamName, + 'contents' => $formParamValueItem + ]; + } + } + // for HTTP post (form) + $httpBody = new MultipartStream($multipartContents); + + } elseif ($headers['Content-Type'] === 'application/json') { + $httpBody = \GuzzleHttp\json_encode($formParams); + + } else { + // for HTTP post (form) + $httpBody = \GuzzleHttp\Psr7\build_query($formParams); + } + } + + // this endpoint requires HTTP basic authentication + if (!empty($this->config->getUsername()) || !(empty($this->config->getPassword()))) { + $headers['Authorization'] = 'Basic ' . base64_encode($this->config->getUsername() . ":" . $this->config->getPassword()); + } + + $defaultHeaders = []; + if ($this->config->getUserAgent()) { + $defaultHeaders['User-Agent'] = $this->config->getUserAgent(); + } + + $headers = array_merge( + $defaultHeaders, + $headerParams, + $headers + ); + + + // MUX: adds support for array params. + // TODO: future upstream? + $query = ObjectSerializer::buildBetterQuery($queryParams); + return new Request( + 'GET', + $this->config->getHost() . $resourcePath . ($query ? "?{$query}" : ''), + $headers, + $httpBody + ); + } + + /** + * Create http client option + * + * @throws \RuntimeException on file opening failure + * @return array of http client options + */ + protected function createHttpClientOption() + { + $options = []; + if ($this->config->getDebug()) { + $options[RequestOptions::DEBUG] = fopen($this->config->getDebugFile(), 'a'); + if (!$options[RequestOptions::DEBUG]) { + throw new \RuntimeException('Failed to open the debug file: ' . $this->config->getDebugFile()); + } + } + + return $options; + } +} diff --git a/MuxPhp/Api/MetricsApi.php b/MuxPhp/Api/MetricsApi.php index a2e34a8..dd14f8c 100644 --- a/MuxPhp/Api/MetricsApi.php +++ b/MuxPhp/Api/MetricsApi.php @@ -124,7 +124,7 @@ public function getConfig() * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string $group_by Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. (optional) * @@ -147,7 +147,7 @@ public function getMetricTimeseriesData($metric_id, $timeframe = null, $filters * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string $group_by Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. (optional) * @@ -241,7 +241,7 @@ public function getMetricTimeseriesDataWithHttpInfo($metric_id, $timeframe = nul * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string $group_by Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. (optional) * @@ -267,7 +267,7 @@ function ($response) { * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string $group_by Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. (optional) * @@ -320,7 +320,7 @@ function ($exception) { * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string $group_by Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. (optional) * @@ -494,7 +494,7 @@ public function getMetricTimeseriesDataRequest($metric_id, $timeframe = null, $f * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * * @throws \MuxPhp\ApiException on non-2xx response * @throws \InvalidArgumentException @@ -515,7 +515,7 @@ public function getOverallValues($metric_id, $timeframe = null, $filters = null, * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * * @throws \MuxPhp\ApiException on non-2xx response * @throws \InvalidArgumentException @@ -607,7 +607,7 @@ public function getOverallValuesWithHttpInfo($metric_id, $timeframe = null, $fil * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * * @throws \InvalidArgumentException * @return \GuzzleHttp\Promise\PromiseInterface @@ -631,7 +631,7 @@ function ($response) { * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * * @throws \InvalidArgumentException * @return \GuzzleHttp\Promise\PromiseInterface @@ -682,7 +682,7 @@ function ($exception) { * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * * @throws \InvalidArgumentException * @return \GuzzleHttp\Psr7\Request @@ -1165,7 +1165,7 @@ public function listAllMetricValuesRequest($timeframe = null, $filters = null, $ * * @param string $metric_id ID of the Metric (required) * @param string $group_by Breakdown value to group the results by (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) * @param int $limit Number of items to include in the response (optional, default to 25) @@ -1191,7 +1191,7 @@ public function listBreakdownValues($metric_id, $group_by = null, $measurement = * * @param string $metric_id ID of the Metric (required) * @param string $group_by Breakdown value to group the results by (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) * @param int $limit Number of items to include in the response (optional, default to 25) @@ -1288,7 +1288,7 @@ public function listBreakdownValuesWithHttpInfo($metric_id, $group_by = null, $m * * @param string $metric_id ID of the Metric (required) * @param string $group_by Breakdown value to group the results by (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) * @param int $limit Number of items to include in the response (optional, default to 25) @@ -1317,7 +1317,7 @@ function ($response) { * * @param string $metric_id ID of the Metric (required) * @param string $group_by Breakdown value to group the results by (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) * @param int $limit Number of items to include in the response (optional, default to 25) @@ -1373,7 +1373,7 @@ function ($exception) { * * @param string $metric_id ID of the Metric (required) * @param string $group_by Breakdown value to group the results by (optional) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) * @param string[] $metric_filters Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` (optional) * @param int $limit Number of items to include in the response (optional, default to 25) @@ -1582,7 +1582,7 @@ public function listBreakdownValuesRequest($metric_id, $group_by = null, $measur * List Insights * * @param string $metric_id ID of the Metric (required) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) @@ -1604,7 +1604,7 @@ public function listInsights($metric_id, $measurement = null, $order_direction = * List Insights * * @param string $metric_id ID of the Metric (required) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) @@ -1697,7 +1697,7 @@ public function listInsightsWithHttpInfo($metric_id, $measurement = null, $order * List Insights * * @param string $metric_id ID of the Metric (required) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) @@ -1722,7 +1722,7 @@ function ($response) { * List Insights * * @param string $metric_id ID of the Metric (required) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) @@ -1774,7 +1774,7 @@ function ($exception) { * Create request for operation 'listInsights' * * @param string $metric_id ID of the Metric (required) - * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. (optional) + * @param string $measurement Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` (optional) * @param string $order_direction Sort order. (optional) * @param string[] $timeframe Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` (optional) * @param string[] $filters Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` (optional) diff --git a/MuxPhp/Configuration.php b/MuxPhp/Configuration.php index 097ac3d..f98ab86 100644 --- a/MuxPhp/Configuration.php +++ b/MuxPhp/Configuration.php @@ -91,7 +91,7 @@ class Configuration * * @var string */ - protected $userAgent = 'OpenAPI-Generator/3.17.0/PHP'; + protected $userAgent = 'OpenAPI-Generator/3.18.0/PHP'; /** * Debug switch (default set to false) @@ -400,7 +400,7 @@ public static function toDebugReport() $report .= ' OS: ' . php_uname() . PHP_EOL; $report .= ' PHP Version: ' . PHP_VERSION . PHP_EOL; $report .= ' The version of the OpenAPI document: v1' . PHP_EOL; - $report .= ' SDK Package Version: 3.17.0' . PHP_EOL; + $report .= ' SDK Package Version: 3.18.0' . PHP_EOL; $report .= ' Temp Folder Path: ' . self::getDefaultConfiguration()->getTempFolderPath() . PHP_EOL; return $report; diff --git a/MuxPhp/Models/CreateAssetRequest.php b/MuxPhp/Models/CreateAssetRequest.php index 657affb..9576997 100644 --- a/MuxPhp/Models/CreateAssetRequest.php +++ b/MuxPhp/Models/CreateAssetRequest.php @@ -62,6 +62,7 @@ class CreateAssetRequest implements ModelInterface, ArrayAccess, \JsonSerializab protected static $openAPITypes = [ 'input' => '\MuxPhp\Models\InputSettings[]', 'playback_policy' => '\MuxPhp\Models\PlaybackPolicy[]', + 'advanced_playback_policies' => '\MuxPhp\Models\CreatePlaybackIDRequest[]', 'per_title_encode' => 'bool', 'passthrough' => 'string', 'mp4_support' => 'string', @@ -82,6 +83,7 @@ class CreateAssetRequest implements ModelInterface, ArrayAccess, \JsonSerializab protected static $openAPIFormats = [ 'input' => null, 'playback_policy' => null, + 'advanced_playback_policies' => null, 'per_title_encode' => 'boolean', 'passthrough' => null, 'mp4_support' => null, @@ -100,6 +102,7 @@ class CreateAssetRequest implements ModelInterface, ArrayAccess, \JsonSerializab protected static array $openAPINullables = [ 'input' => false, 'playback_policy' => false, + 'advanced_playback_policies' => false, 'per_title_encode' => false, 'passthrough' => false, 'mp4_support' => false, @@ -188,6 +191,7 @@ public function isNullableSetToNull(string $property): bool protected static $attributeMap = [ 'input' => 'input', 'playback_policy' => 'playback_policy', + 'advanced_playback_policies' => 'advanced_playback_policies', 'per_title_encode' => 'per_title_encode', 'passthrough' => 'passthrough', 'mp4_support' => 'mp4_support', @@ -206,6 +210,7 @@ public function isNullableSetToNull(string $property): bool protected static $setters = [ 'input' => 'setInput', 'playback_policy' => 'setPlaybackPolicy', + 'advanced_playback_policies' => 'setAdvancedPlaybackPolicies', 'per_title_encode' => 'setPerTitleEncode', 'passthrough' => 'setPassthrough', 'mp4_support' => 'setMp4Support', @@ -224,6 +229,7 @@ public function isNullableSetToNull(string $property): bool protected static $getters = [ 'input' => 'getInput', 'playback_policy' => 'getPlaybackPolicy', + 'advanced_playback_policies' => 'getAdvancedPlaybackPolicies', 'per_title_encode' => 'getPerTitleEncode', 'passthrough' => 'getPassthrough', 'mp4_support' => 'getMp4Support', @@ -364,6 +370,7 @@ public function __construct(array $data = null) // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 $this->setIfExists('input', $data ?? [], null); $this->setIfExists('playback_policy', $data ?? [], null); + $this->setIfExists('advanced_playback_policies', $data ?? [], null); $this->setIfExists('per_title_encode', $data ?? [], null); $this->setIfExists('passthrough', $data ?? [], null); $this->setIfExists('mp4_support', $data ?? [], null); @@ -494,7 +501,7 @@ public function getPlaybackPolicy() /** * Sets playback_policy * - * @param \MuxPhp\Models\PlaybackPolicy[]|null $playback_policy An array of playback policy names that you want applied to this asset and available through `playback_ids`. Options include: `\"public\"` (anyone with the playback URL can stream the asset). And `\"signed\"` (an additional access token is required to play the asset). If no playback_policy is set, the asset will have no playback IDs and will therefore not be playable. For simplicity, a single string name can be used in place of the array in the case of only one playback policy. + * @param \MuxPhp\Models\PlaybackPolicy[]|null $playback_policy An array of playback policy names that you want applied to this asset and available through `playback_ids`. Options include: * `\"public\"` (anyone with the playback URL can stream the asset). * `\"signed\"` (an additional access token is required to play the asset). If no `playback_policy` is set, the asset will have no playback IDs and will therefore not be playable. For simplicity, a single string name can be used in place of the array in the case of only one playback policy. * * @return self */ @@ -510,6 +517,35 @@ public function setPlaybackPolicy($playback_policy) return $this; } + /** + * Gets advanced_playback_policies + * + * @return \MuxPhp\Models\CreatePlaybackIDRequest[]|null + */ + public function getAdvancedPlaybackPolicies() + { + return $this->container['advanced_playback_policies']; + } + + /** + * Sets advanced_playback_policies + * + * @param \MuxPhp\Models\CreatePlaybackIDRequest[]|null $advanced_playback_policies An array of playback policy objects that you want applied to this asset and available through `playback_ids`. `advanced_playback_policies` must be used instead of `playback_policy` when creating a DRM playback ID. + * + * @return self + */ + public function setAdvancedPlaybackPolicies($advanced_playback_policies) + { + + if (is_null($advanced_playback_policies)) { + throw new \InvalidArgumentException('non-nullable advanced_playback_policies cannot be null'); + } + + $this->container['advanced_playback_policies'] = $advanced_playback_policies; + + return $this; + } + /** * Gets per_title_encode * diff --git a/MuxPhp/Models/CreateLiveStreamRequest.php b/MuxPhp/Models/CreateLiveStreamRequest.php index 613cea6..215f70d 100644 --- a/MuxPhp/Models/CreateLiveStreamRequest.php +++ b/MuxPhp/Models/CreateLiveStreamRequest.php @@ -61,6 +61,7 @@ class CreateLiveStreamRequest implements ModelInterface, ArrayAccess, \JsonSeria */ protected static $openAPITypes = [ 'playback_policy' => '\MuxPhp\Models\PlaybackPolicy[]', + 'advanced_playback_policies' => '\MuxPhp\Models\CreatePlaybackIDRequest[]', 'new_asset_settings' => '\MuxPhp\Models\CreateAssetRequest', 'reconnect_window' => 'float', 'use_slate_for_standard_latency' => 'bool', @@ -86,6 +87,7 @@ class CreateLiveStreamRequest implements ModelInterface, ArrayAccess, \JsonSeria */ protected static $openAPIFormats = [ 'playback_policy' => null, + 'advanced_playback_policies' => null, 'new_asset_settings' => null, 'reconnect_window' => 'float', 'use_slate_for_standard_latency' => 'boolean', @@ -109,6 +111,7 @@ class CreateLiveStreamRequest implements ModelInterface, ArrayAccess, \JsonSeria */ protected static array $openAPINullables = [ 'playback_policy' => false, + 'advanced_playback_policies' => false, 'new_asset_settings' => false, 'reconnect_window' => false, 'use_slate_for_standard_latency' => false, @@ -202,6 +205,7 @@ public function isNullableSetToNull(string $property): bool */ protected static $attributeMap = [ 'playback_policy' => 'playback_policy', + 'advanced_playback_policies' => 'advanced_playback_policies', 'new_asset_settings' => 'new_asset_settings', 'reconnect_window' => 'reconnect_window', 'use_slate_for_standard_latency' => 'use_slate_for_standard_latency', @@ -225,6 +229,7 @@ public function isNullableSetToNull(string $property): bool */ protected static $setters = [ 'playback_policy' => 'setPlaybackPolicy', + 'advanced_playback_policies' => 'setAdvancedPlaybackPolicies', 'new_asset_settings' => 'setNewAssetSettings', 'reconnect_window' => 'setReconnectWindow', 'use_slate_for_standard_latency' => 'setUseSlateForStandardLatency', @@ -248,6 +253,7 @@ public function isNullableSetToNull(string $property): bool */ protected static $getters = [ 'playback_policy' => 'getPlaybackPolicy', + 'advanced_playback_policies' => 'getAdvancedPlaybackPolicies', 'new_asset_settings' => 'getNewAssetSettings', 'reconnect_window' => 'getReconnectWindow', 'use_slate_for_standard_latency' => 'getUseSlateForStandardLatency', @@ -342,6 +348,7 @@ public function __construct(array $data = null) // please re-integrate with mainline when possible. // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 $this->setIfExists('playback_policy', $data ?? [], null); + $this->setIfExists('advanced_playback_policies', $data ?? [], null); $this->setIfExists('new_asset_settings', $data ?? [], null); $this->setIfExists('reconnect_window', $data ?? [], 60); $this->setIfExists('use_slate_for_standard_latency', $data ?? [], false); @@ -454,6 +461,35 @@ public function setPlaybackPolicy($playback_policy) return $this; } + /** + * Gets advanced_playback_policies + * + * @return \MuxPhp\Models\CreatePlaybackIDRequest[]|null + */ + public function getAdvancedPlaybackPolicies() + { + return $this->container['advanced_playback_policies']; + } + + /** + * Sets advanced_playback_policies + * + * @param \MuxPhp\Models\CreatePlaybackIDRequest[]|null $advanced_playback_policies An array of playback policy objects that you want applied to this asset and available through `playback_ids`. `advanced_playback_policies` must be used instead of `playback_policy` when creating a DRM playback ID. + * + * @return self + */ + public function setAdvancedPlaybackPolicies($advanced_playback_policies) + { + + if (is_null($advanced_playback_policies)) { + throw new \InvalidArgumentException('non-nullable advanced_playback_policies cannot be null'); + } + + $this->container['advanced_playback_policies'] = $advanced_playback_policies; + + return $this; + } + /** * Gets new_asset_settings * diff --git a/MuxPhp/Models/CreatePlaybackIDRequest.php b/MuxPhp/Models/CreatePlaybackIDRequest.php index 36eeba6..48c716b 100644 --- a/MuxPhp/Models/CreatePlaybackIDRequest.php +++ b/MuxPhp/Models/CreatePlaybackIDRequest.php @@ -60,7 +60,8 @@ class CreatePlaybackIDRequest implements ModelInterface, ArrayAccess, \JsonSeria * @var string[] */ protected static $openAPITypes = [ - 'policy' => '\MuxPhp\Models\PlaybackPolicy' + 'policy' => '\MuxPhp\Models\PlaybackPolicy', + 'drm_configuration_id' => 'string' ]; /** @@ -71,7 +72,8 @@ class CreatePlaybackIDRequest implements ModelInterface, ArrayAccess, \JsonSeria * @psalm-var array */ protected static $openAPIFormats = [ - 'policy' => null + 'policy' => null, + 'drm_configuration_id' => null ]; /** @@ -80,7 +82,8 @@ class CreatePlaybackIDRequest implements ModelInterface, ArrayAccess, \JsonSeria * @var boolean[] */ protected static array $openAPINullables = [ - 'policy' => false + 'policy' => false, + 'drm_configuration_id' => false ]; /** @@ -159,7 +162,8 @@ public function isNullableSetToNull(string $property): bool * @var string[] */ protected static $attributeMap = [ - 'policy' => 'policy' + 'policy' => 'policy', + 'drm_configuration_id' => 'drm_configuration_id' ]; /** @@ -168,7 +172,8 @@ public function isNullableSetToNull(string $property): bool * @var string[] */ protected static $setters = [ - 'policy' => 'setPolicy' + 'policy' => 'setPolicy', + 'drm_configuration_id' => 'setDrmConfigurationId' ]; /** @@ -177,7 +182,8 @@ public function isNullableSetToNull(string $property): bool * @var string[] */ protected static $getters = [ - 'policy' => 'getPolicy' + 'policy' => 'getPolicy', + 'drm_configuration_id' => 'getDrmConfigurationId' ]; /** @@ -241,6 +247,7 @@ public function __construct(array $data = null) // please re-integrate with mainline when possible. // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 $this->setIfExists('policy', $data ?? [], null); + $this->setIfExists('drm_configuration_id', $data ?? [], null); } /** @@ -313,6 +320,35 @@ public function setPolicy($policy) return $this; } + + /** + * Gets drm_configuration_id + * + * @return string|null + */ + public function getDrmConfigurationId() + { + return $this->container['drm_configuration_id']; + } + + /** + * Sets drm_configuration_id + * + * @param string|null $drm_configuration_id The DRM configuration used by this playback ID. Must only be set when `policy` is set to `drm`. + * + * @return self + */ + public function setDrmConfigurationId($drm_configuration_id) + { + + if (is_null($drm_configuration_id)) { + throw new \InvalidArgumentException('non-nullable drm_configuration_id cannot be null'); + } + + $this->container['drm_configuration_id'] = $drm_configuration_id; + + return $this; + } /** * Returns true if offset exists. False otherwise. * diff --git a/MuxPhp/Models/CreateUploadRequest.php b/MuxPhp/Models/CreateUploadRequest.php index 32eac7b..a6f9b22 100644 --- a/MuxPhp/Models/CreateUploadRequest.php +++ b/MuxPhp/Models/CreateUploadRequest.php @@ -422,7 +422,7 @@ public function getTest() /** * Sets test * - * @param bool|null $test test + * @param bool|null $test Indicates if this is a test Direct Upload, in which case the Asset that gets created will be a `test` Asset. * * @return self */ diff --git a/MuxPhp/Models/DRMConfiguration.php b/MuxPhp/Models/DRMConfiguration.php new file mode 100644 index 0000000..c2ec347 --- /dev/null +++ b/MuxPhp/Models/DRMConfiguration.php @@ -0,0 +1,407 @@ + + * @template TKey int|null + * @template TValue mixed|null + */ +class DRMConfiguration implements ModelInterface, ArrayAccess, \JsonSerializable +{ + public const DISCRIMINATOR = null; + + /** + * The original name of the model. + * + * @var string + */ + protected static $openAPIModelName = 'DRMConfiguration'; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @var string[] + */ + protected static $openAPITypes = [ + 'id' => 'string' + ]; + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @var string[] + * @phpstan-var array + * @psalm-var array + */ + protected static $openAPIFormats = [ + 'id' => null + ]; + + /** + * Array of nullable properties. Used for (de)serialization + * + * @var boolean[] + */ + protected static array $openAPINullables = [ + 'id' => false + ]; + + /** + * If a nullable field gets set to null, insert it here + * + * @var boolean[] + */ + protected array $openAPINullablesSetToNull = []; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPITypes() + { + return self::$openAPITypes; + } + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPIFormats() + { + return self::$openAPIFormats; + } + + /** + * Array of nullable properties + * + * @return array + */ + protected static function openAPINullables(): array + { + return self::$openAPINullables; + } + + /** + * Array of nullable field names deliberately set to null + * + * @return boolean[] + */ + private function getOpenAPINullablesSetToNull(): array + { + return $this->openAPINullablesSetToNull; + } + + /** + * Checks if a property is nullable + * + * @param string $property + * @return bool + */ + public static function isNullable(string $property): bool + { + return self::openAPINullables()[$property] ?? false; + } + + /** + * Checks if a nullable property is set to null. + * + * @param string $property + * @return bool + */ + public function isNullableSetToNull(string $property): bool + { + return in_array($property, $this->getOpenAPINullablesSetToNull(), true); + } + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @var string[] + */ + protected static $attributeMap = [ + 'id' => 'id' + ]; + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @var string[] + */ + protected static $setters = [ + 'id' => 'setId' + ]; + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @var string[] + */ + protected static $getters = [ + 'id' => 'getId' + ]; + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @return array + */ + public static function attributeMap() + { + return self::$attributeMap; + } + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @return array + */ + public static function setters() + { + return self::$setters; + } + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @return array + */ + public static function getters() + { + return self::$getters; + } + + /** + * The original name of the model. + * + * @return string + */ + public function getModelName() + { + return self::$openAPIModelName; + } + + + /** + * Associative array for storing property values + * + * @var mixed[] + */ + protected $container = []; + + /** + * Constructor + * + * @param mixed[] $data Associated array of property values + * initializing the model + */ + public function __construct(array $data = null) + { + // MUX: enum hack (self::) due to OAS emitting problems. + // please re-integrate with mainline when possible. + // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 + $this->setIfExists('id', $data ?? [], null); + } + + /** + * Sets $this->container[$variableName] to the given data or to the given default Value; if $variableName + * is nullable and its value is set to null in the $fields array, then mark it as "set to null" in the + * $this->openAPINullablesSetToNull array + * + * @param string $variableName + * @param array $fields + * @param mixed $defaultValue + */ + private function setIfExists(string $variableName, array $fields, $defaultValue): void + { + if (self::isNullable($variableName) && array_key_exists($variableName, $fields) && is_null($fields[$variableName])) { + $this->openAPINullablesSetToNull[] = $variableName; + } + + $this->container[$variableName] = $fields[$variableName] ?? $defaultValue; + } + + /** + * Show all the invalid properties with reasons. + * + * @return array invalid properties with reasons + */ + public function listInvalidProperties() + { + $invalidProperties = []; + + return $invalidProperties; + } + + /** + * Validate all the properties in the model + * return true if all passed + * + * @return bool True if all properties are valid + */ + public function valid() + { + return count($this->listInvalidProperties()) === 0; + } + + + /** + * Gets id + * + * @return string|null + */ + public function getId() + { + return $this->container['id']; + } + + /** + * Sets id + * + * @param string|null $id Unique identifier for the DRM Configuration. Max 255 characters. + * + * @return self + */ + public function setId($id) + { + + if (is_null($id)) { + throw new \InvalidArgumentException('non-nullable id cannot be null'); + } + + $this->container['id'] = $id; + + return $this; + } + /** + * Returns true if offset exists. False otherwise. + * + * @param integer $offset Offset + * + * @return boolean + */ + public function offsetExists($offset): bool + { + return isset($this->container[$offset]); + } + + /** + * Gets offset. + * + * @param integer $offset Offset + * + * @return mixed|null + */ + #[\ReturnTypeWillChange] + public function offsetGet($offset) + { + return $this->container[$offset] ?? null; + } + + /** + * Sets value based on offset. + * + * @param int|null $offset Offset + * @param mixed $value Value to be set + * + * @return void + */ + public function offsetSet($offset, $value): void + { + if (is_null($offset)) { + $this->container[] = $value; + } else { + $this->container[$offset] = $value; + } + } + + /** + * Unsets offset. + * + * @param integer $offset Offset + * + * @return void + */ + public function offsetUnset($offset): void + { + unset($this->container[$offset]); + } + + /** + * Serializes the object to a value that can be serialized natively by json_encode(). + * @link https://www.php.net/manual/en/jsonserializable.jsonserialize.php + * + * @return mixed Returns data which can be serialized by json_encode(), which is a value + * of any type other than a resource. + */ + #[\ReturnTypeWillChange] + public function jsonSerialize() + { + return ObjectSerializer::sanitizeForSerialization($this); + } + + /** + * Gets the string presentation of the object + * + * @return string + */ + public function __toString(): string + { + return json_encode( + ObjectSerializer::sanitizeForSerialization($this), + JSON_PRETTY_PRINT + ); + } + + /** + * Gets a header-safe presentation of the object + * + * @return string + */ + public function toHeaderValue(): string + { + return json_encode(ObjectSerializer::sanitizeForSerialization($this)); + } +} + + diff --git a/MuxPhp/Models/DRMConfigurationResponse.php b/MuxPhp/Models/DRMConfigurationResponse.php new file mode 100644 index 0000000..304f28a --- /dev/null +++ b/MuxPhp/Models/DRMConfigurationResponse.php @@ -0,0 +1,407 @@ + + * @template TKey int|null + * @template TValue mixed|null + */ +class DRMConfigurationResponse implements ModelInterface, ArrayAccess, \JsonSerializable +{ + public const DISCRIMINATOR = null; + + /** + * The original name of the model. + * + * @var string + */ + protected static $openAPIModelName = 'DRMConfigurationResponse'; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @var string[] + */ + protected static $openAPITypes = [ + 'data' => '\MuxPhp\Models\DRMConfiguration' + ]; + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @var string[] + * @phpstan-var array + * @psalm-var array + */ + protected static $openAPIFormats = [ + 'data' => null + ]; + + /** + * Array of nullable properties. Used for (de)serialization + * + * @var boolean[] + */ + protected static array $openAPINullables = [ + 'data' => false + ]; + + /** + * If a nullable field gets set to null, insert it here + * + * @var boolean[] + */ + protected array $openAPINullablesSetToNull = []; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPITypes() + { + return self::$openAPITypes; + } + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPIFormats() + { + return self::$openAPIFormats; + } + + /** + * Array of nullable properties + * + * @return array + */ + protected static function openAPINullables(): array + { + return self::$openAPINullables; + } + + /** + * Array of nullable field names deliberately set to null + * + * @return boolean[] + */ + private function getOpenAPINullablesSetToNull(): array + { + return $this->openAPINullablesSetToNull; + } + + /** + * Checks if a property is nullable + * + * @param string $property + * @return bool + */ + public static function isNullable(string $property): bool + { + return self::openAPINullables()[$property] ?? false; + } + + /** + * Checks if a nullable property is set to null. + * + * @param string $property + * @return bool + */ + public function isNullableSetToNull(string $property): bool + { + return in_array($property, $this->getOpenAPINullablesSetToNull(), true); + } + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @var string[] + */ + protected static $attributeMap = [ + 'data' => 'data' + ]; + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @var string[] + */ + protected static $setters = [ + 'data' => 'setData' + ]; + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @var string[] + */ + protected static $getters = [ + 'data' => 'getData' + ]; + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @return array + */ + public static function attributeMap() + { + return self::$attributeMap; + } + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @return array + */ + public static function setters() + { + return self::$setters; + } + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @return array + */ + public static function getters() + { + return self::$getters; + } + + /** + * The original name of the model. + * + * @return string + */ + public function getModelName() + { + return self::$openAPIModelName; + } + + + /** + * Associative array for storing property values + * + * @var mixed[] + */ + protected $container = []; + + /** + * Constructor + * + * @param mixed[] $data Associated array of property values + * initializing the model + */ + public function __construct(array $data = null) + { + // MUX: enum hack (self::) due to OAS emitting problems. + // please re-integrate with mainline when possible. + // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 + $this->setIfExists('data', $data ?? [], null); + } + + /** + * Sets $this->container[$variableName] to the given data or to the given default Value; if $variableName + * is nullable and its value is set to null in the $fields array, then mark it as "set to null" in the + * $this->openAPINullablesSetToNull array + * + * @param string $variableName + * @param array $fields + * @param mixed $defaultValue + */ + private function setIfExists(string $variableName, array $fields, $defaultValue): void + { + if (self::isNullable($variableName) && array_key_exists($variableName, $fields) && is_null($fields[$variableName])) { + $this->openAPINullablesSetToNull[] = $variableName; + } + + $this->container[$variableName] = $fields[$variableName] ?? $defaultValue; + } + + /** + * Show all the invalid properties with reasons. + * + * @return array invalid properties with reasons + */ + public function listInvalidProperties() + { + $invalidProperties = []; + + return $invalidProperties; + } + + /** + * Validate all the properties in the model + * return true if all passed + * + * @return bool True if all properties are valid + */ + public function valid() + { + return count($this->listInvalidProperties()) === 0; + } + + + /** + * Gets data + * + * @return \MuxPhp\Models\DRMConfiguration|null + */ + public function getData() + { + return $this->container['data']; + } + + /** + * Sets data + * + * @param \MuxPhp\Models\DRMConfiguration|null $data data + * + * @return self + */ + public function setData($data) + { + + if (is_null($data)) { + throw new \InvalidArgumentException('non-nullable data cannot be null'); + } + + $this->container['data'] = $data; + + return $this; + } + /** + * Returns true if offset exists. False otherwise. + * + * @param integer $offset Offset + * + * @return boolean + */ + public function offsetExists($offset): bool + { + return isset($this->container[$offset]); + } + + /** + * Gets offset. + * + * @param integer $offset Offset + * + * @return mixed|null + */ + #[\ReturnTypeWillChange] + public function offsetGet($offset) + { + return $this->container[$offset] ?? null; + } + + /** + * Sets value based on offset. + * + * @param int|null $offset Offset + * @param mixed $value Value to be set + * + * @return void + */ + public function offsetSet($offset, $value): void + { + if (is_null($offset)) { + $this->container[] = $value; + } else { + $this->container[$offset] = $value; + } + } + + /** + * Unsets offset. + * + * @param integer $offset Offset + * + * @return void + */ + public function offsetUnset($offset): void + { + unset($this->container[$offset]); + } + + /** + * Serializes the object to a value that can be serialized natively by json_encode(). + * @link https://www.php.net/manual/en/jsonserializable.jsonserialize.php + * + * @return mixed Returns data which can be serialized by json_encode(), which is a value + * of any type other than a resource. + */ + #[\ReturnTypeWillChange] + public function jsonSerialize() + { + return ObjectSerializer::sanitizeForSerialization($this); + } + + /** + * Gets the string presentation of the object + * + * @return string + */ + public function __toString(): string + { + return json_encode( + ObjectSerializer::sanitizeForSerialization($this), + JSON_PRETTY_PRINT + ); + } + + /** + * Gets a header-safe presentation of the object + * + * @return string + */ + public function toHeaderValue(): string + { + return json_encode(ObjectSerializer::sanitizeForSerialization($this)); + } +} + + diff --git a/MuxPhp/Models/ListDRMConfigurationsResponse.php b/MuxPhp/Models/ListDRMConfigurationsResponse.php new file mode 100644 index 0000000..3ca573e --- /dev/null +++ b/MuxPhp/Models/ListDRMConfigurationsResponse.php @@ -0,0 +1,407 @@ + + * @template TKey int|null + * @template TValue mixed|null + */ +class ListDRMConfigurationsResponse implements ModelInterface, ArrayAccess, \JsonSerializable +{ + public const DISCRIMINATOR = null; + + /** + * The original name of the model. + * + * @var string + */ + protected static $openAPIModelName = 'ListDRMConfigurationsResponse'; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @var string[] + */ + protected static $openAPITypes = [ + 'data' => '\MuxPhp\Models\DRMConfiguration[]' + ]; + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @var string[] + * @phpstan-var array + * @psalm-var array + */ + protected static $openAPIFormats = [ + 'data' => null + ]; + + /** + * Array of nullable properties. Used for (de)serialization + * + * @var boolean[] + */ + protected static array $openAPINullables = [ + 'data' => false + ]; + + /** + * If a nullable field gets set to null, insert it here + * + * @var boolean[] + */ + protected array $openAPINullablesSetToNull = []; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPITypes() + { + return self::$openAPITypes; + } + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPIFormats() + { + return self::$openAPIFormats; + } + + /** + * Array of nullable properties + * + * @return array + */ + protected static function openAPINullables(): array + { + return self::$openAPINullables; + } + + /** + * Array of nullable field names deliberately set to null + * + * @return boolean[] + */ + private function getOpenAPINullablesSetToNull(): array + { + return $this->openAPINullablesSetToNull; + } + + /** + * Checks if a property is nullable + * + * @param string $property + * @return bool + */ + public static function isNullable(string $property): bool + { + return self::openAPINullables()[$property] ?? false; + } + + /** + * Checks if a nullable property is set to null. + * + * @param string $property + * @return bool + */ + public function isNullableSetToNull(string $property): bool + { + return in_array($property, $this->getOpenAPINullablesSetToNull(), true); + } + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @var string[] + */ + protected static $attributeMap = [ + 'data' => 'data' + ]; + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @var string[] + */ + protected static $setters = [ + 'data' => 'setData' + ]; + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @var string[] + */ + protected static $getters = [ + 'data' => 'getData' + ]; + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @return array + */ + public static function attributeMap() + { + return self::$attributeMap; + } + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @return array + */ + public static function setters() + { + return self::$setters; + } + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @return array + */ + public static function getters() + { + return self::$getters; + } + + /** + * The original name of the model. + * + * @return string + */ + public function getModelName() + { + return self::$openAPIModelName; + } + + + /** + * Associative array for storing property values + * + * @var mixed[] + */ + protected $container = []; + + /** + * Constructor + * + * @param mixed[] $data Associated array of property values + * initializing the model + */ + public function __construct(array $data = null) + { + // MUX: enum hack (self::) due to OAS emitting problems. + // please re-integrate with mainline when possible. + // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 + $this->setIfExists('data', $data ?? [], null); + } + + /** + * Sets $this->container[$variableName] to the given data or to the given default Value; if $variableName + * is nullable and its value is set to null in the $fields array, then mark it as "set to null" in the + * $this->openAPINullablesSetToNull array + * + * @param string $variableName + * @param array $fields + * @param mixed $defaultValue + */ + private function setIfExists(string $variableName, array $fields, $defaultValue): void + { + if (self::isNullable($variableName) && array_key_exists($variableName, $fields) && is_null($fields[$variableName])) { + $this->openAPINullablesSetToNull[] = $variableName; + } + + $this->container[$variableName] = $fields[$variableName] ?? $defaultValue; + } + + /** + * Show all the invalid properties with reasons. + * + * @return array invalid properties with reasons + */ + public function listInvalidProperties() + { + $invalidProperties = []; + + return $invalidProperties; + } + + /** + * Validate all the properties in the model + * return true if all passed + * + * @return bool True if all properties are valid + */ + public function valid() + { + return count($this->listInvalidProperties()) === 0; + } + + + /** + * Gets data + * + * @return \MuxPhp\Models\DRMConfiguration[]|null + */ + public function getData() + { + return $this->container['data']; + } + + /** + * Sets data + * + * @param \MuxPhp\Models\DRMConfiguration[]|null $data data + * + * @return self + */ + public function setData($data) + { + + if (is_null($data)) { + throw new \InvalidArgumentException('non-nullable data cannot be null'); + } + + $this->container['data'] = $data; + + return $this; + } + /** + * Returns true if offset exists. False otherwise. + * + * @param integer $offset Offset + * + * @return boolean + */ + public function offsetExists($offset): bool + { + return isset($this->container[$offset]); + } + + /** + * Gets offset. + * + * @param integer $offset Offset + * + * @return mixed|null + */ + #[\ReturnTypeWillChange] + public function offsetGet($offset) + { + return $this->container[$offset] ?? null; + } + + /** + * Sets value based on offset. + * + * @param int|null $offset Offset + * @param mixed $value Value to be set + * + * @return void + */ + public function offsetSet($offset, $value): void + { + if (is_null($offset)) { + $this->container[] = $value; + } else { + $this->container[$offset] = $value; + } + } + + /** + * Unsets offset. + * + * @param integer $offset Offset + * + * @return void + */ + public function offsetUnset($offset): void + { + unset($this->container[$offset]); + } + + /** + * Serializes the object to a value that can be serialized natively by json_encode(). + * @link https://www.php.net/manual/en/jsonserializable.jsonserialize.php + * + * @return mixed Returns data which can be serialized by json_encode(), which is a value + * of any type other than a resource. + */ + #[\ReturnTypeWillChange] + public function jsonSerialize() + { + return ObjectSerializer::sanitizeForSerialization($this); + } + + /** + * Gets the string presentation of the object + * + * @return string + */ + public function __toString(): string + { + return json_encode( + ObjectSerializer::sanitizeForSerialization($this), + JSON_PRETTY_PRINT + ); + } + + /** + * Gets a header-safe presentation of the object + * + * @return string + */ + public function toHeaderValue(): string + { + return json_encode(ObjectSerializer::sanitizeForSerialization($this)); + } +} + + diff --git a/MuxPhp/Models/PlaybackID.php b/MuxPhp/Models/PlaybackID.php index b66da0e..3ef7972 100644 --- a/MuxPhp/Models/PlaybackID.php +++ b/MuxPhp/Models/PlaybackID.php @@ -61,7 +61,8 @@ class PlaybackID implements ModelInterface, ArrayAccess, \JsonSerializable */ protected static $openAPITypes = [ 'id' => 'string', - 'policy' => '\MuxPhp\Models\PlaybackPolicy' + 'policy' => '\MuxPhp\Models\PlaybackPolicy', + 'drm_configuration_id' => 'string' ]; /** @@ -73,7 +74,8 @@ class PlaybackID implements ModelInterface, ArrayAccess, \JsonSerializable */ protected static $openAPIFormats = [ 'id' => null, - 'policy' => null + 'policy' => null, + 'drm_configuration_id' => null ]; /** @@ -83,7 +85,8 @@ class PlaybackID implements ModelInterface, ArrayAccess, \JsonSerializable */ protected static array $openAPINullables = [ 'id' => false, - 'policy' => false + 'policy' => false, + 'drm_configuration_id' => false ]; /** @@ -163,7 +166,8 @@ public function isNullableSetToNull(string $property): bool */ protected static $attributeMap = [ 'id' => 'id', - 'policy' => 'policy' + 'policy' => 'policy', + 'drm_configuration_id' => 'drm_configuration_id' ]; /** @@ -173,7 +177,8 @@ public function isNullableSetToNull(string $property): bool */ protected static $setters = [ 'id' => 'setId', - 'policy' => 'setPolicy' + 'policy' => 'setPolicy', + 'drm_configuration_id' => 'setDrmConfigurationId' ]; /** @@ -183,7 +188,8 @@ public function isNullableSetToNull(string $property): bool */ protected static $getters = [ 'id' => 'getId', - 'policy' => 'getPolicy' + 'policy' => 'getPolicy', + 'drm_configuration_id' => 'getDrmConfigurationId' ]; /** @@ -248,6 +254,7 @@ public function __construct(array $data = null) // src: https://github.com/OpenAPITools/openapi-generator/issues/9038 $this->setIfExists('id', $data ?? [], null); $this->setIfExists('policy', $data ?? [], null); + $this->setIfExists('drm_configuration_id', $data ?? [], null); } /** @@ -349,6 +356,35 @@ public function setPolicy($policy) return $this; } + + /** + * Gets drm_configuration_id + * + * @return string|null + */ + public function getDrmConfigurationId() + { + return $this->container['drm_configuration_id']; + } + + /** + * Sets drm_configuration_id + * + * @param string|null $drm_configuration_id The DRM configuration used by this playback ID. Must only be set when `policy` is set to `drm`. + * + * @return self + */ + public function setDrmConfigurationId($drm_configuration_id) + { + + if (is_null($drm_configuration_id)) { + throw new \InvalidArgumentException('non-nullable drm_configuration_id cannot be null'); + } + + $this->container['drm_configuration_id'] = $drm_configuration_id; + + return $this; + } /** * Returns true if offset exists. False otherwise. * diff --git a/MuxPhp/Models/PlaybackPolicy.php b/MuxPhp/Models/PlaybackPolicy.php index f5c3d7f..80553ae 100644 --- a/MuxPhp/Models/PlaybackPolicy.php +++ b/MuxPhp/Models/PlaybackPolicy.php @@ -46,6 +46,7 @@ class PlaybackPolicy */ public const _PUBLIC = 'public'; public const SIGNED = 'signed'; + public const DRM = 'drm'; /** * Gets allowable values of the enum @@ -56,6 +57,7 @@ public static function getAllowableEnumValues() return [ self::_PUBLIC, self::SIGNED, + self::DRM, ]; } } diff --git a/README.md b/README.md index afb401b..6827cf4 100644 --- a/README.md +++ b/README.md @@ -158,6 +158,8 @@ Class | Method | HTTP request | Description *AssetsApi* | [**updateAsset**](docs/Api/AssetsApi.md#updateasset) | **PATCH** /video/v1/assets/{ASSET_ID} | Update an asset *AssetsApi* | [**updateAssetMasterAccess**](docs/Api/AssetsApi.md#updateassetmasteraccess) | **PUT** /video/v1/assets/{ASSET_ID}/master-access | Update master access *AssetsApi* | [**updateAssetMp4Support**](docs/Api/AssetsApi.md#updateassetmp4support) | **PUT** /video/v1/assets/{ASSET_ID}/mp4-support | Update MP4 support +*DRMConfigurationsApi* | [**getDrmConfiguration**](docs/Api/DRMConfigurationsApi.md#getdrmconfiguration) | **GET** /video/v1/drm-configurations/{DRM_CONFIGURATION_ID} | Retrieve a DRM Configuration +*DRMConfigurationsApi* | [**listDrmConfigurations**](docs/Api/DRMConfigurationsApi.md#listdrmconfigurations) | **GET** /video/v1/drm-configurations | List DRM Configurations *DeliveryUsageApi* | [**listDeliveryUsage**](docs/Api/DeliveryUsageApi.md#listdeliveryusage) | **GET** /video/v1/delivery-usage | List Usage *DimensionsApi* | [**listDimensionValues**](docs/Api/DimensionsApi.md#listdimensionvalues) | **GET** /data/v1/dimensions/{DIMENSION_ID} | Lists the values for a specific dimension *DimensionsApi* | [**listDimensions**](docs/Api/DimensionsApi.md#listdimensions) | **GET** /data/v1/dimensions | List Dimensions @@ -277,6 +279,8 @@ Class | Method | HTTP request | Description - [CreateTranscriptionVocabularyRequest](docs/Model/CreateTranscriptionVocabularyRequest.md) - [CreateUploadRequest](docs/Model/CreateUploadRequest.md) - [CreateWebInputRequest](docs/Model/CreateWebInputRequest.md) +- [DRMConfiguration](docs/Model/DRMConfiguration.md) +- [DRMConfigurationResponse](docs/Model/DRMConfigurationResponse.md) - [DeliveryReport](docs/Model/DeliveryReport.md) - [DeliveryReportDeliveredSecondsByResolution](docs/Model/DeliveryReportDeliveredSecondsByResolution.md) - [DimensionValue](docs/Model/DimensionValue.md) @@ -321,6 +325,7 @@ Class | Method | HTTP request | Description - [ListAssetsResponse](docs/Model/ListAssetsResponse.md) - [ListBreakdownValuesResponse](docs/Model/ListBreakdownValuesResponse.md) - [ListBreakdownValuesResponseMeta](docs/Model/ListBreakdownValuesResponseMeta.md) +- [ListDRMConfigurationsResponse](docs/Model/ListDRMConfigurationsResponse.md) - [ListDeliveryUsageResponse](docs/Model/ListDeliveryUsageResponse.md) - [ListDimensionValuesResponse](docs/Model/ListDimensionValuesResponse.md) - [ListDimensionsResponse](docs/Model/ListDimensionsResponse.md) @@ -434,5 +439,5 @@ devex@mux.com This PHP package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: - API version: `v1` - - Package version: `3.17.0` + - Package version: `3.18.0` - Build package: `org.openapitools.codegen.languages.PhpClientCodegen` diff --git a/composer.json b/composer.json index c77fd63..f45ba6e 100644 --- a/composer.json +++ b/composer.json @@ -1,6 +1,6 @@ { "name": "muxinc/mux-php", - "version": "3.17.0", + "version": "3.18.0", "description": "Mux is how developers build online video. This API encompasses both Mux Video and Mux Data functionality to help you build your video-related projects better and faster than ever before.", "keywords": [ "php", diff --git a/docs/Api/DRMConfigurationsApi.md b/docs/Api/DRMConfigurationsApi.md new file mode 100644 index 0000000..5ddb48a --- /dev/null +++ b/docs/Api/DRMConfigurationsApi.md @@ -0,0 +1,135 @@ +# MuxPhp\DRMConfigurationsApi + +All URIs are relative to https://api.mux.com, except if the operation defines another base path. + +| Method | HTTP request | Description | +| ------------- | ------------- | ------------- | +| [**getDrmConfiguration()**](DRMConfigurationsApi.md#getDrmConfiguration) | **GET** /video/v1/drm-configurations/{DRM_CONFIGURATION_ID} | Retrieve a DRM Configuration | +| [**listDrmConfigurations()**](DRMConfigurationsApi.md#listDrmConfigurations) | **GET** /video/v1/drm-configurations | List DRM Configurations | + + +## `getDrmConfiguration()` + +```php +getDrmConfiguration($drm_configuration_id): \MuxPhp\Models\DRMConfigurationResponse +``` + +Retrieve a DRM Configuration + +Retrieves a single DRM Configuration. + +### Example + +```php +setUsername('YOUR_USERNAME') + ->setPassword('YOUR_PASSWORD'); + + +$apiInstance = new MuxPhp\Api\DRMConfigurationsApi( + // If you want use custom http client, pass your client which implements `GuzzleHttp\ClientInterface`. + // This is optional, `GuzzleHttp\Client` will be used as default. + new GuzzleHttp\Client(), + $config +); +$drm_configuration_id = 'drm_configuration_id_example'; // string | The DRM Configuration ID. + +try { + $result = $apiInstance->getDrmConfiguration($drm_configuration_id); + print_r($result); +} catch (Exception $e) { + echo 'Exception when calling DRMConfigurationsApi->getDrmConfiguration: ', $e->getMessage(), PHP_EOL; +} +``` + +### Parameters + +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **drm_configuration_id** | **string**| The DRM Configuration ID. | | + +### Return type + +[**\MuxPhp\Models\DRMConfigurationResponse**](../Model/DRMConfigurationResponse.md) + +### Authorization + +[accessToken](../../README.md#accessToken) + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: `application/json` + +[[Back to top]](#) [[Back to API list]](../../README.md#endpoints) +[[Back to Model list]](../../README.md#models) +[[Back to README]](../../README.md) + +## `listDrmConfigurations()` + +```php +listDrmConfigurations($page, $limit): \MuxPhp\Models\ListDRMConfigurationsResponse +``` + +List DRM Configurations + +Returns a list of DRM Configurations + +### Example + +```php +setUsername('YOUR_USERNAME') + ->setPassword('YOUR_PASSWORD'); + + +$apiInstance = new MuxPhp\Api\DRMConfigurationsApi( + // If you want use custom http client, pass your client which implements `GuzzleHttp\ClientInterface`. + // This is optional, `GuzzleHttp\Client` will be used as default. + new GuzzleHttp\Client(), + $config +); +$page = 1; // int | Offset by this many pages, of the size of `limit` +$limit = 25; // int | Number of items to include in the response + +try { + $result = $apiInstance->listDrmConfigurations($page, $limit); + print_r($result); +} catch (Exception $e) { + echo 'Exception when calling DRMConfigurationsApi->listDrmConfigurations: ', $e->getMessage(), PHP_EOL; +} +``` + +### Parameters + +| Name | Type | Description | Notes | +| ------------- | ------------- | ------------- | ------------- | +| **page** | **int**| Offset by this many pages, of the size of `limit` | [optional] [default to 1] | +| **limit** | **int**| Number of items to include in the response | [optional] [default to 25] | + +### Return type + +[**\MuxPhp\Models\ListDRMConfigurationsResponse**](../Model/ListDRMConfigurationsResponse.md) + +### Authorization + +[accessToken](../../README.md#accessToken) + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: `application/json` + +[[Back to top]](#) [[Back to API list]](../../README.md#endpoints) +[[Back to Model list]](../../README.md#models) +[[Back to README]](../../README.md) diff --git a/docs/Api/MetricsApi.md b/docs/Api/MetricsApi.md index dfacd22..84fae79 100644 --- a/docs/Api/MetricsApi.md +++ b/docs/Api/MetricsApi.md @@ -44,7 +44,7 @@ $metric_id = video_startup_time; // string | ID of the Metric $timeframe = array('timeframe_example'); // string[] | Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` $filters = array('filters_example'); // string[] | Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` $metric_filters = array('metric_filters_example'); // string[] | Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` -$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. +$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` $order_direction = 'order_direction_example'; // string | Sort order. $group_by = 'group_by_example'; // string | Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. @@ -64,7 +64,7 @@ try { | **timeframe** | [**string[]**](../Model/string.md)| Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` | [optional] | | **filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` | [optional] | | **metric_filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` | [optional] | -| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. | [optional] | +| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` | [optional] | | **order_direction** | **string**| Sort order. | [optional] | | **group_by** | **string**| Time granularity to group results by. If this value is omitted, a default granularity is chosen based on the timeframe. For timeframes of less than 90 minutes, the default granularity is `minute`. Between 90 minutes and 6 hours, the default granularity is `ten_minutes`. Between 6 hours and 15 days inclusive, the default granularity is `hour`. The granularity of timeframes that exceed 15 days is `day`. This default behavior is subject to change; it is strongly suggested that you explicitly specify the granularity. | [optional] | @@ -118,7 +118,7 @@ $metric_id = video_startup_time; // string | ID of the Metric $timeframe = array('timeframe_example'); // string[] | Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` $filters = array('filters_example'); // string[] | Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` $metric_filters = array('metric_filters_example'); // string[] | Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` -$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. +$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` try { $result = $apiInstance->getOverallValues($metric_id, $timeframe, $filters, $metric_filters, $measurement); @@ -136,7 +136,7 @@ try { | **timeframe** | [**string[]**](../Model/string.md)| Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` | [optional] | | **filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` | [optional] | | **metric_filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` | [optional] | -| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. | [optional] | +| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` | [optional] | ### Return type @@ -256,7 +256,7 @@ $apiInstance = new MuxPhp\Api\MetricsApi( ); $metric_id = video_startup_time; // string | ID of the Metric $group_by = 'group_by_example'; // string | Breakdown value to group the results by -$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. +$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` $filters = array('filters_example'); // string[] | Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` $metric_filters = array('metric_filters_example'); // string[] | Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` $limit = 25; // int | Number of items to include in the response @@ -279,7 +279,7 @@ try { | ------------- | ------------- | ------------- | ------------- | | **metric_id** | **string**| ID of the Metric | | | **group_by** | **string**| Breakdown value to group the results by | [optional] | -| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. | [optional] | +| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` | [optional] | | **filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` | [optional] | | **metric_filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match inequality conditions from provided metric comparison clauses. Must be provided as an array query string parameter. Possible filterable metrics are the same as the set of metric ids, with the exceptions of `exits_before_video_start`, `unique_viewers`, `video_startup_failure_percentage`, and `views`. Example: * `metric_filters[]=aggregate_startup_time>=1000` | [optional] | | **limit** | **int**| Number of items to include in the response | [optional] [default to 25] | @@ -335,7 +335,7 @@ $apiInstance = new MuxPhp\Api\MetricsApi( $config ); $metric_id = video_startup_time; // string | ID of the Metric -$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. +$measurement = 'measurement_example'; // string | Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` $order_direction = 'order_direction_example'; // string | Sort order. $timeframe = array('timeframe_example'); // string[] | Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` $filters = array('filters_example'); // string[] | Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` @@ -354,7 +354,7 @@ try { | Name | Type | Description | Notes | | ------------- | ------------- | ------------- | ------------- | | **metric_id** | **string**| ID of the Metric | | -| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. | [optional] | +| **measurement** | **string**| Measurement for the provided metric. If omitted, the default for the metric will be used. The default measurement for each metric is: \"sum\" : `ad_attempt_count`, `ad_break_count`, `ad_break_error_count`, `ad_error_count`, `ad_impression_count`, `playing_time` \"median\" : `ad_preroll_startup_time`, `ad_watch_time`, `aggregate_startup_time`, `content_startup_time`, `content_watch_time`, `max_downscale_percentage`, `max_upscale_percentage`, `page_load_time`, `player_average_live_latency`, `player_startup_time`, `rebuffer_count`, `rebuffer_duration`, `requests_for_first_preroll`, `video_startup_preroll_load_time`, `video_startup_preroll_request_time`, `video_startup_time`, `view_average_request_latency`, `view_average_request_throughput`, `view_max_request_latency`, `weighted_average_bitrate` \"avg\" : `ad_break_error_percentage`, `ad_error_percentage`, `ad_exit_before_start_count`, `ad_exit_before_start_percentage`, `ad_playback_failure_percentage`, `ad_startup_error_count`, `ad_startup_error_percentage`, `content_playback_failure_percentage`, `downscale_percentage`, `exits_before_video_start`, `playback_business_exception_percentage`, `playback_failure_percentage`, `playback_success_score`, `rebuffer_frequency`, `rebuffer_percentage`, `seek_latency`, `smoothness_score`, `startup_time_score`, `upscale_percentage`, `video_quality_score`, `video_startup_business_exception_percentage`, `video_startup_failure_percentage`, `viewer_experience_score` \"count\" : `started_views`, `unique_viewers` | [optional] | | **order_direction** | **string**| Sort order. | [optional] | | **timeframe** | [**string[]**](../Model/string.md)| Timeframe window to limit results by. Must be provided as an array query string parameter (e.g. timeframe[]=). Accepted formats are... * array of epoch timestamps e.g. `timeframe[]=1498867200&timeframe[]=1498953600` * duration string e.g. `timeframe[]=24:hours or timeframe[]=7:days` | [optional] | | **filters** | [**string[]**](../Model/string.md)| Limit the results to rows that match conditions from provided key:value pairs. Must be provided as an array query string parameter. To exclude rows that match a certain condition, prepend a `!` character to the dimension. Possible filter names are the same as returned by the List Filters endpoint. Example: * `filters[]=operating_system:windows&filters[]=!country:US` | [optional] | diff --git a/docs/Model/CreateAssetRequest.md b/docs/Model/CreateAssetRequest.md index 525e474..43f3338 100644 --- a/docs/Model/CreateAssetRequest.md +++ b/docs/Model/CreateAssetRequest.md @@ -5,7 +5,8 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **input** | [**\MuxPhp\Models\InputSettings[]**](InputSettings.md) | An array of objects that each describe an input file to be used to create the asset. As a shortcut, input can also be a string URL for a file when only one input file is used. See `input[].url` for requirements. | [optional] -**playback_policy** | [**\MuxPhp\Models\PlaybackPolicy[]**](PlaybackPolicy.md) | An array of playback policy names that you want applied to this asset and available through `playback_ids`. Options include: `\"public\"` (anyone with the playback URL can stream the asset). And `\"signed\"` (an additional access token is required to play the asset). If no playback_policy is set, the asset will have no playback IDs and will therefore not be playable. For simplicity, a single string name can be used in place of the array in the case of only one playback policy. | [optional] +**playback_policy** | [**\MuxPhp\Models\PlaybackPolicy[]**](PlaybackPolicy.md) | An array of playback policy names that you want applied to this asset and available through `playback_ids`. Options include: * `\"public\"` (anyone with the playback URL can stream the asset). * `\"signed\"` (an additional access token is required to play the asset). If no `playback_policy` is set, the asset will have no playback IDs and will therefore not be playable. For simplicity, a single string name can be used in place of the array in the case of only one playback policy. | [optional] +**advanced_playback_policies** | [**\MuxPhp\Models\CreatePlaybackIDRequest[]**](CreatePlaybackIDRequest.md) | An array of playback policy objects that you want applied to this asset and available through `playback_ids`. `advanced_playback_policies` must be used instead of `playback_policy` when creating a DRM playback ID. | [optional] **per_title_encode** | **bool** | | [optional] **passthrough** | **string** | Arbitrary user-supplied metadata that will be included in the asset details and related webhooks. Can be used to store your own ID for a video along with the asset. **Max: 255 characters**. | [optional] **mp4_support** | **string** | Specify what level of support for mp4 playback. * The `capped-1080p` option produces a single MP4 file, called `capped-1080p.mp4`, with the video resolution capped at 1080p. This option produces an `audio.m4a` file for an audio-only asset. * The `audio-only` option produces a single M4A file, called `audio.m4a` for a video or an audio-only asset. MP4 generation will error when this option is specified for a video-only asset. * The `audio-only,capped-1080p` option produces both the `audio.m4a` and `capped-1080p.mp4` files. Only the `capped-1080p.mp4` file is produced for a video-only asset, while only the `audio.m4a` file is produced for an audio-only asset. The `standard`(deprecated) option produces up to three MP4 files with different levels of resolution (`high.mp4`, `medium.mp4`, `low.mp4`, or `audio.m4a` for an audio-only asset). MP4 files are not produced for `none` (default). In most cases you should use our default HLS-based streaming playback (`{playback_id}.m3u8`) which can automatically adjust to viewers' connection speeds, but an mp4 can be useful for some legacy devices or downloading for offline playback. See the [Download your videos guide](https://docs.mux.com/guides/enable-static-mp4-renditions) for more information. | [optional] diff --git a/docs/Model/CreateLiveStreamRequest.md b/docs/Model/CreateLiveStreamRequest.md index 0197f7a..b9e8ff2 100644 --- a/docs/Model/CreateLiveStreamRequest.md +++ b/docs/Model/CreateLiveStreamRequest.md @@ -5,6 +5,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **playback_policy** | [**\MuxPhp\Models\PlaybackPolicy[]**](PlaybackPolicy.md) | | [optional] +**advanced_playback_policies** | [**\MuxPhp\Models\CreatePlaybackIDRequest[]**](CreatePlaybackIDRequest.md) | An array of playback policy objects that you want applied to this asset and available through `playback_ids`. `advanced_playback_policies` must be used instead of `playback_policy` when creating a DRM playback ID. | [optional] **new_asset_settings** | [**\MuxPhp\Models\CreateAssetRequest**](CreateAssetRequest.md) | | [optional] **reconnect_window** | **float** | When live streaming software disconnects from Mux, either intentionally or due to a drop in the network, the Reconnect Window is the time in seconds that Mux should wait for the streaming software to reconnect before considering the live stream finished and completing the recorded asset. Defaults to 60 seconds on the API if not specified. If not specified directly, Standard Latency streams have a Reconnect Window of 60 seconds; Reduced and Low Latency streams have a default of 0 seconds, or no Reconnect Window. For that reason, we suggest specifying a value other than zero for Reduced and Low Latency streams. Reduced and Low Latency streams with a Reconnect Window greater than zero will insert slate media into the recorded asset while waiting for the streaming software to reconnect or when there are brief interruptions in the live stream media. When using a Reconnect Window setting higher than 60 seconds with a Standard Latency stream, we highly recommend enabling slate with the `use_slate_for_standard_latency` option. | [optional] [default to 60] **use_slate_for_standard_latency** | **bool** | By default, Standard Latency live streams do not have slate media inserted while waiting for live streaming software to reconnect to Mux. Setting this to true enables slate insertion on a Standard Latency stream. | [optional] [default to false] diff --git a/docs/Model/CreatePlaybackIDRequest.md b/docs/Model/CreatePlaybackIDRequest.md index eeb78bd..5facd50 100644 --- a/docs/Model/CreatePlaybackIDRequest.md +++ b/docs/Model/CreatePlaybackIDRequest.md @@ -5,5 +5,6 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **policy** | [**\MuxPhp\Models\PlaybackPolicy**](PlaybackPolicy.md) | | [optional] +**drm_configuration_id** | **string** | The DRM configuration used by this playback ID. Must only be set when `policy` is set to `drm`. | [optional] [[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md) diff --git a/docs/Model/CreateUploadRequest.md b/docs/Model/CreateUploadRequest.md index b1ab14d..384b190 100644 --- a/docs/Model/CreateUploadRequest.md +++ b/docs/Model/CreateUploadRequest.md @@ -7,6 +7,6 @@ Name | Type | Description | Notes **timeout** | **int** | Max time in seconds for the signed upload URL to be valid. If a successful upload has not occurred before the timeout limit, the direct upload is marked `timed_out` | [optional] [default to 3600] **cors_origin** | **string** | If the upload URL will be used in a browser, you must specify the origin in order for the signed URL to have the correct CORS headers. | [optional] **new_asset_settings** | [**\MuxPhp\Models\CreateAssetRequest**](CreateAssetRequest.md) | | [optional] -**test** | **bool** | | [optional] +**test** | **bool** | Indicates if this is a test Direct Upload, in which case the Asset that gets created will be a `test` Asset. | [optional] [[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md) diff --git a/docs/Model/DRMConfiguration.md b/docs/Model/DRMConfiguration.md new file mode 100644 index 0000000..795990b --- /dev/null +++ b/docs/Model/DRMConfiguration.md @@ -0,0 +1,9 @@ +# # DRMConfiguration + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **string** | Unique identifier for the DRM Configuration. Max 255 characters. | [optional] + +[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md) diff --git a/docs/Model/DRMConfigurationResponse.md b/docs/Model/DRMConfigurationResponse.md new file mode 100644 index 0000000..a6462b0 --- /dev/null +++ b/docs/Model/DRMConfigurationResponse.md @@ -0,0 +1,9 @@ +# # DRMConfigurationResponse + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**data** | [**\MuxPhp\Models\DRMConfiguration**](DRMConfiguration.md) | | [optional] + +[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md) diff --git a/docs/Model/ListDRMConfigurationsResponse.md b/docs/Model/ListDRMConfigurationsResponse.md new file mode 100644 index 0000000..8d1a82d --- /dev/null +++ b/docs/Model/ListDRMConfigurationsResponse.md @@ -0,0 +1,9 @@ +# # ListDRMConfigurationsResponse + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**data** | [**\MuxPhp\Models\DRMConfiguration[]**](DRMConfiguration.md) | | [optional] + +[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md) diff --git a/docs/Model/PlaybackID.md b/docs/Model/PlaybackID.md index d7324be..1e817be 100644 --- a/docs/Model/PlaybackID.md +++ b/docs/Model/PlaybackID.md @@ -6,5 +6,6 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **id** | **string** | Unique identifier for the PlaybackID | [optional] **policy** | [**\MuxPhp\Models\PlaybackPolicy**](PlaybackPolicy.md) | | [optional] +**drm_configuration_id** | **string** | The DRM configuration used by this playback ID. Must only be set when `policy` is set to `drm`. | [optional] [[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md) diff --git a/gen/generator-config.json b/gen/generator-config.json index b060070..a22265f 100644 --- a/gen/generator-config.json +++ b/gen/generator-config.json @@ -5,7 +5,7 @@ "apiPackage": "Api", "srcBasePath": "MuxPhp", "invokerPackage": "MuxPhp", - "artifactVersion": "3.17.0", + "artifactVersion": "3.18.0", "gitUserId": "muxinc", "gitRepoId": "mux-php" }