media

package
v0.20220715.1080238 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 15, 2022 License: MPL-2.0 Imports: 14 Imported by: 0

README ¶

github.com/hashicorp/go-azure-sdk/resource-manager/media/2020-05-01/media Documentation

The media SDK allows for interaction with the Azure Resource Manager Service media (API Version 2020-05-01).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-sdk/resource-manager/media/2020-05-01/media"

Client Initialization

client := media.NewMediaClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: MediaClient.AccountFiltersCreateOrUpdate

ctx := context.TODO()
id := media.NewAccountFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "filterValue")

payload := media.AccountFilter{
	// ...
}


read, err := client.AccountFiltersCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AccountFiltersDelete

ctx := context.TODO()
id := media.NewAccountFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "filterValue")

read, err := client.AccountFiltersDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AccountFiltersGet

ctx := context.TODO()
id := media.NewAccountFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "filterValue")

read, err := client.AccountFiltersGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AccountFiltersList

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

// alternatively `client.AccountFiltersList(ctx, id)` can be used to do batched pagination
items, err := client.AccountFiltersListComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.AccountFiltersUpdate

ctx := context.TODO()
id := media.NewAccountFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "filterValue")

payload := media.AccountFilter{
	// ...
}


read, err := client.AccountFiltersUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetFiltersCreateOrUpdate

ctx := context.TODO()
id := media.NewAssetFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue", "filterValue")

payload := media.AssetFilter{
	// ...
}


read, err := client.AssetFiltersCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetFiltersDelete

ctx := context.TODO()
id := media.NewAssetFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue", "filterValue")

read, err := client.AssetFiltersDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetFiltersGet

ctx := context.TODO()
id := media.NewAssetFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue", "filterValue")

read, err := client.AssetFiltersGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetFiltersList

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

// alternatively `client.AssetFiltersList(ctx, id)` can be used to do batched pagination
items, err := client.AssetFiltersListComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.AssetFiltersUpdate

ctx := context.TODO()
id := media.NewAssetFilterID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue", "filterValue")

payload := media.AssetFilter{
	// ...
}


read, err := client.AssetFiltersUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsCreateOrUpdate

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

payload := media.Asset{
	// ...
}


read, err := client.AssetsCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsDelete

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

read, err := client.AssetsDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsGet

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

read, err := client.AssetsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsGetEncryptionKey

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

read, err := client.AssetsGetEncryptionKey(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsList

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

// alternatively `client.AssetsList(ctx, id, media.DefaultAssetsListOperationOptions())` can be used to do batched pagination
items, err := client.AssetsListComplete(ctx, id, media.DefaultAssetsListOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.AssetsListContainerSas

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

payload := media.ListContainerSasInput{
	// ...
}


read, err := client.AssetsListContainerSas(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsListStreamingLocators

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

read, err := client.AssetsListStreamingLocators(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.AssetsUpdate

ctx := context.TODO()
id := media.NewAssetID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "assetValue")

payload := media.Asset{
	// ...
}


read, err := client.AssetsUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.ContentKeyPoliciesCreateOrUpdate

ctx := context.TODO()
id := media.NewContentKeyPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "contentKeyPolicyValue")

payload := media.ContentKeyPolicy{
	// ...
}


read, err := client.ContentKeyPoliciesCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.ContentKeyPoliciesDelete

ctx := context.TODO()
id := media.NewContentKeyPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "contentKeyPolicyValue")

read, err := client.ContentKeyPoliciesDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.ContentKeyPoliciesGet

ctx := context.TODO()
id := media.NewContentKeyPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "contentKeyPolicyValue")

read, err := client.ContentKeyPoliciesGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.ContentKeyPoliciesGetPolicyPropertiesWithSecrets

ctx := context.TODO()
id := media.NewContentKeyPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "contentKeyPolicyValue")

read, err := client.ContentKeyPoliciesGetPolicyPropertiesWithSecrets(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.ContentKeyPoliciesList

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

// alternatively `client.ContentKeyPoliciesList(ctx, id, media.DefaultContentKeyPoliciesListOperationOptions())` can be used to do batched pagination
items, err := client.ContentKeyPoliciesListComplete(ctx, id, media.DefaultContentKeyPoliciesListOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.ContentKeyPoliciesUpdate

ctx := context.TODO()
id := media.NewContentKeyPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "contentKeyPolicyValue")

payload := media.ContentKeyPolicy{
	// ...
}


read, err := client.ContentKeyPoliciesUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.JobsCancelJob

ctx := context.TODO()
id := media.NewJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue", "jobValue")

read, err := client.JobsCancelJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.JobsCreate

ctx := context.TODO()
id := media.NewJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue", "jobValue")

payload := media.Job{
	// ...
}


read, err := client.JobsCreate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.JobsDelete

ctx := context.TODO()
id := media.NewJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue", "jobValue")

read, err := client.JobsDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.JobsGet

ctx := context.TODO()
id := media.NewJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue", "jobValue")

read, err := client.JobsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.JobsList

ctx := context.TODO()
id := media.NewTransformID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue")

// alternatively `client.JobsList(ctx, id, media.DefaultJobsListOperationOptions())` can be used to do batched pagination
items, err := client.JobsListComplete(ctx, id, media.DefaultJobsListOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.JobsUpdate

ctx := context.TODO()
id := media.NewJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue", "jobValue")

payload := media.Job{
	// ...
}


read, err := client.JobsUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.LocationsCheckNameAvailability

ctx := context.TODO()
id := media.NewLocationID("12345678-1234-9876-4563-123456789012", "locationValue")

payload := media.CheckNameAvailabilityInput{
	// ...
}


read, err := client.LocationsCheckNameAvailability(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesCreateOrUpdate

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

payload := media.MediaService{
	// ...
}


read, err := client.MediaservicesCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesDelete

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

read, err := client.MediaservicesDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesGet

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

read, err := client.MediaservicesGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesGetBySubscription

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

read, err := client.MediaservicesGetBySubscription(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesList

ctx := context.TODO()
id := media.NewResourceGroupID()

// alternatively `client.MediaservicesList(ctx, id)` can be used to do batched pagination
items, err := client.MediaservicesListComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.MediaservicesListBySubscription

ctx := context.TODO()
id := media.NewSubscriptionID()

// alternatively `client.MediaservicesListBySubscription(ctx, id)` can be used to do batched pagination
items, err := client.MediaservicesListBySubscriptionComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.MediaservicesListEdgePolicies

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

payload := media.ListEdgePoliciesInput{
	// ...
}


read, err := client.MediaservicesListEdgePolicies(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesSyncStorageKeys

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

payload := media.SyncStorageKeysInput{
	// ...
}


read, err := client.MediaservicesSyncStorageKeys(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.MediaservicesUpdate

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

payload := media.MediaService{
	// ...
}


read, err := client.MediaservicesUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.PrivateEndpointConnectionsCreateOrUpdate

ctx := context.TODO()
id := media.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "nameValue")

payload := media.PrivateEndpointConnection{
	// ...
}


read, err := client.PrivateEndpointConnectionsCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.PrivateEndpointConnectionsDelete

ctx := context.TODO()
id := media.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "nameValue")

read, err := client.PrivateEndpointConnectionsDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.PrivateEndpointConnectionsGet

ctx := context.TODO()
id := media.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "nameValue")

read, err := client.PrivateEndpointConnectionsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.PrivateEndpointConnectionsList

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

read, err := client.PrivateEndpointConnectionsList(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.PrivateLinkResourcesGet

ctx := context.TODO()
id := media.NewPrivateLinkResourceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "nameValue")

read, err := client.PrivateLinkResourcesGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.PrivateLinkResourcesList

ctx := context.TODO()
id := media.NewProviderMediaServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue")

read, err := client.PrivateLinkResourcesList(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingLocatorsCreate

ctx := context.TODO()
id := media.NewStreamingLocatorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingLocatorValue")

payload := media.StreamingLocator{
	// ...
}


read, err := client.StreamingLocatorsCreate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingLocatorsDelete

ctx := context.TODO()
id := media.NewStreamingLocatorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingLocatorValue")

read, err := client.StreamingLocatorsDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingLocatorsGet

ctx := context.TODO()
id := media.NewStreamingLocatorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingLocatorValue")

read, err := client.StreamingLocatorsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingLocatorsList

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

// alternatively `client.StreamingLocatorsList(ctx, id, media.DefaultStreamingLocatorsListOperationOptions())` can be used to do batched pagination
items, err := client.StreamingLocatorsListComplete(ctx, id, media.DefaultStreamingLocatorsListOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.StreamingLocatorsListContentKeys

ctx := context.TODO()
id := media.NewStreamingLocatorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingLocatorValue")

read, err := client.StreamingLocatorsListContentKeys(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingLocatorsListPaths

ctx := context.TODO()
id := media.NewStreamingLocatorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingLocatorValue")

read, err := client.StreamingLocatorsListPaths(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingPoliciesCreate

ctx := context.TODO()
id := media.NewStreamingPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingPolicyValue")

payload := media.StreamingPolicy{
	// ...
}


read, err := client.StreamingPoliciesCreate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingPoliciesDelete

ctx := context.TODO()
id := media.NewStreamingPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingPolicyValue")

read, err := client.StreamingPoliciesDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingPoliciesGet

ctx := context.TODO()
id := media.NewStreamingPoliciesID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "streamingPolicyValue")

read, err := client.StreamingPoliciesGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.StreamingPoliciesList

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

// alternatively `client.StreamingPoliciesList(ctx, id, media.DefaultStreamingPoliciesListOperationOptions())` can be used to do batched pagination
items, err := client.StreamingPoliciesListComplete(ctx, id, media.DefaultStreamingPoliciesListOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.TransformsCreateOrUpdate

ctx := context.TODO()
id := media.NewTransformID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue")

payload := media.Transform{
	// ...
}


read, err := client.TransformsCreateOrUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.TransformsDelete

ctx := context.TODO()
id := media.NewTransformID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue")

read, err := client.TransformsDelete(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.TransformsGet

ctx := context.TODO()
id := media.NewTransformID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue")

read, err := client.TransformsGet(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: MediaClient.TransformsList

ctx := context.TODO()
id := media.NewMediaServiceID("12345678-1234-9876-4563-123456789012", "accountValue")

// alternatively `client.TransformsList(ctx, id, media.DefaultTransformsListOperationOptions())` can be used to do batched pagination
items, err := client.TransformsListComplete(ctx, id, media.DefaultTransformsListOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: MediaClient.TransformsUpdate

ctx := context.TODO()
id := media.NewTransformID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "transformValue")

payload := media.Transform{
	// ...
}


read, err := client.TransformsUpdate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func PossibleValuesForAccountEncryptionKeyType ¶ 

func PossibleValuesForAccountEncryptionKeyType() []string

func PossibleValuesForAnalysisResolution ¶ 

func PossibleValuesForAnalysisResolution() []string

func PossibleValuesForAssetContainerPermission ¶ 

func PossibleValuesForAssetContainerPermission() []string

func PossibleValuesForAssetStorageEncryptionFormat ¶ 

func PossibleValuesForAssetStorageEncryptionFormat() []string

func PossibleValuesForAudioAnalysisMode ¶ 

func PossibleValuesForAudioAnalysisMode() []string

func PossibleValuesForBlurType ¶ 

func PossibleValuesForBlurType() []string

func PossibleValuesForChannelMapping ¶ 

func PossibleValuesForChannelMapping() []string

func PossibleValuesForContentKeyPolicyFairPlayRentalAndLeaseKeyType ¶ 

func PossibleValuesForContentKeyPolicyFairPlayRentalAndLeaseKeyType() []string

func PossibleValuesForContentKeyPolicyPlayReadyContentType ¶ 

func PossibleValuesForContentKeyPolicyPlayReadyContentType() []string

func PossibleValuesForContentKeyPolicyPlayReadyLicenseType ¶ 

func PossibleValuesForContentKeyPolicyPlayReadyLicenseType() []string

func PossibleValuesForContentKeyPolicyPlayReadyUnknownOutputPassingOption ¶ 

func PossibleValuesForContentKeyPolicyPlayReadyUnknownOutputPassingOption() []string

func PossibleValuesForContentKeyPolicyRestrictionTokenType ¶ 

func PossibleValuesForContentKeyPolicyRestrictionTokenType() []string

func PossibleValuesForDeinterlaceMode ¶ 

func PossibleValuesForDeinterlaceMode() []string

func PossibleValuesForDeinterlaceParity ¶ 

func PossibleValuesForDeinterlaceParity() []string

func PossibleValuesForEncoderNamedPreset ¶ 

func PossibleValuesForEncoderNamedPreset() []string

func PossibleValuesForEncryptionScheme ¶ 

func PossibleValuesForEncryptionScheme() []string

func PossibleValuesForFaceRedactorMode ¶ 

func PossibleValuesForFaceRedactorMode() []string

func PossibleValuesForFilterTrackPropertyCompareOperation ¶ 

func PossibleValuesForFilterTrackPropertyCompareOperation() []string

func PossibleValuesForFilterTrackPropertyType ¶ 

func PossibleValuesForFilterTrackPropertyType() []string

func PossibleValuesForJobErrorCategory ¶ 

func PossibleValuesForJobErrorCategory() []string

func PossibleValuesForJobErrorCode ¶ 

func PossibleValuesForJobErrorCode() []string

func PossibleValuesForJobRetry ¶ 

func PossibleValuesForJobRetry() []string

func PossibleValuesForJobState ¶ 

func PossibleValuesForJobState() []string

func PossibleValuesForOnErrorType ¶ 

func PossibleValuesForOnErrorType() []string

func PossibleValuesForPriority ¶ 

func PossibleValuesForPriority() []string

func PossibleValuesForPrivateEndpointConnectionProvisioningState ¶ 

func PossibleValuesForPrivateEndpointConnectionProvisioningState() []string

func PossibleValuesForPrivateEndpointServiceConnectionStatus ¶ 

func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string

func PossibleValuesForRotation ¶ 

func PossibleValuesForRotation() []string

func PossibleValuesForStorageAccountType ¶ 

func PossibleValuesForStorageAccountType() []string

func PossibleValuesForStorageAuthentication ¶ 

func PossibleValuesForStorageAuthentication() []string

func PossibleValuesForStreamingLocatorContentKeyType ¶ 

func PossibleValuesForStreamingLocatorContentKeyType() []string

func PossibleValuesForStreamingPolicyStreamingProtocol ¶ 

func PossibleValuesForStreamingPolicyStreamingProtocol() []string

func PossibleValuesForStretchMode ¶ 

func PossibleValuesForStretchMode() []string

func PossibleValuesForTrackPropertyCompareOperation ¶ 

func PossibleValuesForTrackPropertyCompareOperation() []string

func PossibleValuesForTrackPropertyType ¶ 

func PossibleValuesForTrackPropertyType() []string

func PossibleValuesForVideoSyncMode ¶ 

func PossibleValuesForVideoSyncMode() []string

func ValidateAccountFilterID ¶ 

func ValidateAccountFilterID(input interface{}, key string) (warnings []string, errors []error)

ValidateAccountFilterID checks that 'input' can be parsed as a Account Filter ID

func ValidateAssetFilterID ¶ 

func ValidateAssetFilterID(input interface{}, key string) (warnings []string, errors []error)

ValidateAssetFilterID checks that 'input' can be parsed as a Asset Filter ID

func ValidateAssetID ¶ 

func ValidateAssetID(input interface{}, key string) (warnings []string, errors []error)

ValidateAssetID checks that 'input' can be parsed as a Asset ID

func ValidateContentKeyPoliciesID ¶ 

func ValidateContentKeyPoliciesID(input interface{}, key string) (warnings []string, errors []error)

ValidateContentKeyPoliciesID checks that 'input' can be parsed as a Content Key Policies ID

func ValidateJobID ¶ 

func ValidateJobID(input interface{}, key string) (warnings []string, errors []error)

ValidateJobID checks that 'input' can be parsed as a Job ID

func ValidateLocationID ¶ 

func ValidateLocationID(input interface{}, key string) (warnings []string, errors []error)

ValidateLocationID checks that 'input' can be parsed as a Location ID

func ValidateMediaServiceID ¶ 

func ValidateMediaServiceID(input interface{}, key string) (warnings []string, errors []error)

ValidateMediaServiceID checks that 'input' can be parsed as a Media Service ID

func ValidatePrivateEndpointConnectionID ¶ 

func ValidatePrivateEndpointConnectionID(input interface{}, key string) (warnings []string, errors []error)

ValidatePrivateEndpointConnectionID checks that 'input' can be parsed as a Private Endpoint Connection ID

func ValidatePrivateLinkResourceID ¶ 

func ValidatePrivateLinkResourceID(input interface{}, key string) (warnings []string, errors []error)

ValidatePrivateLinkResourceID checks that 'input' can be parsed as a Private Link Resource ID

func ValidateProviderMediaServiceID ¶ 

func ValidateProviderMediaServiceID(input interface{}, key string) (warnings []string, errors []error)

ValidateProviderMediaServiceID checks that 'input' can be parsed as a Provider Media Service ID

func ValidateStreamingLocatorID ¶ 

func ValidateStreamingLocatorID(input interface{}, key string) (warnings []string, errors []error)

ValidateStreamingLocatorID checks that 'input' can be parsed as a Streaming Locator ID

func ValidateStreamingPoliciesID ¶ 

func ValidateStreamingPoliciesID(input interface{}, key string) (warnings []string, errors []error)

ValidateStreamingPoliciesID checks that 'input' can be parsed as a Streaming Policies ID

func ValidateTransformID ¶ 

func ValidateTransformID(input interface{}, key string) (warnings []string, errors []error)

ValidateTransformID checks that 'input' can be parsed as a Transform ID

Types ¶

type AbsoluteClipTime ¶ 

type AbsoluteClipTime struct {
	Time string `json:"time"`
}

func (AbsoluteClipTime) MarshalJSON ¶ 

func (s AbsoluteClipTime) MarshalJSON() ([]byte, error)

type AccountEncryption ¶ 

type AccountEncryption struct {
	KeyVaultProperties *KeyVaultProperties      `json:"keyVaultProperties,omitempty"`
	Type               AccountEncryptionKeyType `json:"type"`
}

type AccountEncryptionKeyType ¶ 

type AccountEncryptionKeyType string
const (
	AccountEncryptionKeyTypeCustomerKey AccountEncryptionKeyType = "CustomerKey"
	AccountEncryptionKeyTypeSystemKey   AccountEncryptionKeyType = "SystemKey"
)

type AccountFilter ¶ 

type AccountFilter struct {
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *MediaFilterProperties `json:"properties,omitempty"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type AccountFilterId ¶ 

type AccountFilterId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	FilterName        string
}

AccountFilterId is a struct representing the Resource ID for a Account Filter

func NewAccountFilterID ¶ 

func NewAccountFilterID(subscriptionId string, resourceGroupName string, accountName string, filterName string) AccountFilterId

NewAccountFilterID returns a new AccountFilterId struct

func ParseAccountFilterID ¶ 

func ParseAccountFilterID(input string) (*AccountFilterId, error)

ParseAccountFilterID parses 'input' into a AccountFilterId

func ParseAccountFilterIDInsensitively ¶ 

func ParseAccountFilterIDInsensitively(input string) (*AccountFilterId, error)

ParseAccountFilterIDInsensitively parses 'input' case-insensitively into a AccountFilterId note: this method should only be used for API response data and not user input

func (AccountFilterId) ID ¶ 

func (id AccountFilterId) ID() string

ID returns the formatted Account Filter ID

func (AccountFilterId) Segments ¶ 

func (id AccountFilterId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Account Filter ID

func (AccountFilterId) String ¶ 

func (id AccountFilterId) String() string

String returns a human-readable description of this Account Filter ID

type AccountFilterOperationPredicate ¶ 

type AccountFilterOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (AccountFilterOperationPredicate) Matches ¶ 

func (p AccountFilterOperationPredicate) Matches(input AccountFilter) bool

type AccountFiltersCreateOrUpdateOperationResponse ¶ 

type AccountFiltersCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *AccountFilter
}

type AccountFiltersDeleteOperationResponse ¶ 

type AccountFiltersDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type AccountFiltersGetOperationResponse ¶ 

type AccountFiltersGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *AccountFilter
}

type AccountFiltersListCompleteResult ¶ 

type AccountFiltersListCompleteResult struct {
	Items []AccountFilter
}

type AccountFiltersListOperationResponse ¶ 

type AccountFiltersListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]AccountFilter
	// contains filtered or unexported fields
}

func (AccountFiltersListOperationResponse) HasMore ¶ 

func (r AccountFiltersListOperationResponse) HasMore() bool

func (AccountFiltersListOperationResponse) LoadMore ¶ 

func (r AccountFiltersListOperationResponse) LoadMore(ctx context.Context) (resp AccountFiltersListOperationResponse, err error)

type AccountFiltersUpdateOperationResponse ¶ 

type AccountFiltersUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *AccountFilter
}

type AnalysisResolution ¶ 

type AnalysisResolution string
const (
	AnalysisResolutionSourceResolution   AnalysisResolution = "SourceResolution"
	AnalysisResolutionStandardDefinition AnalysisResolution = "StandardDefinition"
)

type Asset ¶ 

type Asset struct {
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *AssetProperties       `json:"properties,omitempty"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type AssetContainerPermission ¶ 

type AssetContainerPermission string
const (
	AssetContainerPermissionRead            AssetContainerPermission = "Read"
	AssetContainerPermissionReadWrite       AssetContainerPermission = "ReadWrite"
	AssetContainerPermissionReadWriteDelete AssetContainerPermission = "ReadWriteDelete"
)

type AssetContainerSas ¶ 

type AssetContainerSas struct {
	AssetContainerSasUrls *[]string `json:"assetContainerSasUrls,omitempty"`
}

type AssetFileEncryptionMetadata ¶ 

type AssetFileEncryptionMetadata struct {
	AssetFileId          string  `json:"assetFileId"`
	AssetFileName        *string `json:"assetFileName,omitempty"`
	InitializationVector *string `json:"initializationVector,omitempty"`
}

type AssetFilter ¶ 

type AssetFilter struct {
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *MediaFilterProperties `json:"properties,omitempty"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type AssetFilterId ¶ 

type AssetFilterId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	AssetName         string
	FilterName        string
}

AssetFilterId is a struct representing the Resource ID for a Asset Filter

func NewAssetFilterID ¶ 

func NewAssetFilterID(subscriptionId string, resourceGroupName string, accountName string, assetName string, filterName string) AssetFilterId

NewAssetFilterID returns a new AssetFilterId struct

func ParseAssetFilterID ¶ 

func ParseAssetFilterID(input string) (*AssetFilterId, error)

ParseAssetFilterID parses 'input' into a AssetFilterId

func ParseAssetFilterIDInsensitively ¶ 

func ParseAssetFilterIDInsensitively(input string) (*AssetFilterId, error)

ParseAssetFilterIDInsensitively parses 'input' case-insensitively into a AssetFilterId note: this method should only be used for API response data and not user input

func (AssetFilterId) ID ¶ 

func (id AssetFilterId) ID() string

ID returns the formatted Asset Filter ID

func (AssetFilterId) Segments ¶ 

func (id AssetFilterId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Asset Filter ID

func (AssetFilterId) String ¶ 

func (id AssetFilterId) String() string

String returns a human-readable description of this Asset Filter ID

type AssetFilterOperationPredicate ¶ 

type AssetFilterOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (AssetFilterOperationPredicate) Matches ¶ 

func (p AssetFilterOperationPredicate) Matches(input AssetFilter) bool

type AssetFiltersCreateOrUpdateOperationResponse ¶ 

type AssetFiltersCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *AssetFilter
}

type AssetFiltersDeleteOperationResponse ¶ 

type AssetFiltersDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type AssetFiltersGetOperationResponse ¶ 

type AssetFiltersGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *AssetFilter
}

type AssetFiltersListCompleteResult ¶ 

type AssetFiltersListCompleteResult struct {
	Items []AssetFilter
}

type AssetFiltersListOperationResponse ¶ 

type AssetFiltersListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]AssetFilter
	// contains filtered or unexported fields
}

func (AssetFiltersListOperationResponse) HasMore ¶ 

func (r AssetFiltersListOperationResponse) HasMore() bool

func (AssetFiltersListOperationResponse) LoadMore ¶ 

func (r AssetFiltersListOperationResponse) LoadMore(ctx context.Context) (resp AssetFiltersListOperationResponse, err error)

type AssetFiltersUpdateOperationResponse ¶ 

type AssetFiltersUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *AssetFilter
}

type AssetId ¶ 

type AssetId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	AssetName         string
}

AssetId is a struct representing the Resource ID for a Asset

func NewAssetID ¶ 

func NewAssetID(subscriptionId string, resourceGroupName string, accountName string, assetName string) AssetId

NewAssetID returns a new AssetId struct

func ParseAssetID ¶ 

func ParseAssetID(input string) (*AssetId, error)

ParseAssetID parses 'input' into a AssetId

func ParseAssetIDInsensitively ¶ 

func ParseAssetIDInsensitively(input string) (*AssetId, error)

ParseAssetIDInsensitively parses 'input' case-insensitively into a AssetId note: this method should only be used for API response data and not user input

func (AssetId) ID ¶ 

func (id AssetId) ID() string

ID returns the formatted Asset ID

func (AssetId) Segments ¶ 

func (id AssetId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Asset ID

func (AssetId) String ¶ 

func (id AssetId) String() string

String returns a human-readable description of this Asset ID

type AssetOperationPredicate ¶ 

type AssetOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (AssetOperationPredicate) Matches ¶ 

func (p AssetOperationPredicate) Matches(input Asset) bool

type AssetProperties ¶ 

type AssetProperties struct {
	AlternateId             *string                       `json:"alternateId,omitempty"`
	AssetId                 *string                       `json:"assetId,omitempty"`
	Container               *string                       `json:"container,omitempty"`
	Created                 *string                       `json:"created,omitempty"`
	Description             *string                       `json:"description,omitempty"`
	LastModified            *string                       `json:"lastModified,omitempty"`
	StorageAccountName      *string                       `json:"storageAccountName,omitempty"`
	StorageEncryptionFormat *AssetStorageEncryptionFormat `json:"storageEncryptionFormat,omitempty"`
}

func (*AssetProperties) GetCreatedAsTime ¶ 

func (o *AssetProperties) GetCreatedAsTime() (*time.Time, error)

func (*AssetProperties) GetLastModifiedAsTime ¶ 

func (o *AssetProperties) GetLastModifiedAsTime() (*time.Time, error)

func (*AssetProperties) SetCreatedAsTime ¶ 

func (o *AssetProperties) SetCreatedAsTime(input time.Time)

func (*AssetProperties) SetLastModifiedAsTime ¶ 

func (o *AssetProperties) SetLastModifiedAsTime(input time.Time)

type AssetStorageEncryptionFormat ¶ 

type AssetStorageEncryptionFormat string
const (
	AssetStorageEncryptionFormatMediaStorageClientEncryption AssetStorageEncryptionFormat = "MediaStorageClientEncryption"
	AssetStorageEncryptionFormatNone                         AssetStorageEncryptionFormat = "None"
)

type AssetStreamingLocator ¶ 

type AssetStreamingLocator struct {
	AssetName                   *string `json:"assetName,omitempty"`
	Created                     *string `json:"created,omitempty"`
	DefaultContentKeyPolicyName *string `json:"defaultContentKeyPolicyName,omitempty"`
	EndTime                     *string `json:"endTime,omitempty"`
	Name                        *string `json:"name,omitempty"`
	StartTime                   *string `json:"startTime,omitempty"`
	StreamingLocatorId          *string `json:"streamingLocatorId,omitempty"`
	StreamingPolicyName         *string `json:"streamingPolicyName,omitempty"`
}

func (*AssetStreamingLocator) GetCreatedAsTime ¶ 

func (o *AssetStreamingLocator) GetCreatedAsTime() (*time.Time, error)

func (*AssetStreamingLocator) GetEndTimeAsTime ¶ 

func (o *AssetStreamingLocator) GetEndTimeAsTime() (*time.Time, error)

func (*AssetStreamingLocator) GetStartTimeAsTime ¶ 

func (o *AssetStreamingLocator) GetStartTimeAsTime() (*time.Time, error)

func (*AssetStreamingLocator) SetCreatedAsTime ¶ 

func (o *AssetStreamingLocator) SetCreatedAsTime(input time.Time)

func (*AssetStreamingLocator) SetEndTimeAsTime ¶ 

func (o *AssetStreamingLocator) SetEndTimeAsTime(input time.Time)

func (*AssetStreamingLocator) SetStartTimeAsTime ¶ 

func (o *AssetStreamingLocator) SetStartTimeAsTime(input time.Time)

type AssetsCreateOrUpdateOperationResponse ¶ 

type AssetsCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *Asset
}

type AssetsDeleteOperationResponse ¶ 

type AssetsDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type AssetsGetEncryptionKeyOperationResponse ¶ 

type AssetsGetEncryptionKeyOperationResponse struct {
	HttpResponse *http.Response
	Model        *StorageEncryptedAssetDecryptionData
}

type AssetsGetOperationResponse ¶ 

type AssetsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *Asset
}

type AssetsListCompleteResult ¶ 

type AssetsListCompleteResult struct {
	Items []Asset
}

type AssetsListContainerSasOperationResponse ¶ 

type AssetsListContainerSasOperationResponse struct {
	HttpResponse *http.Response
	Model        *AssetContainerSas
}

type AssetsListOperationOptions ¶ 

type AssetsListOperationOptions struct {
	Filter  *string
	Orderby *string
	Top     *int64
}

func DefaultAssetsListOperationOptions ¶ 

func DefaultAssetsListOperationOptions() AssetsListOperationOptions

type AssetsListOperationResponse ¶ 

type AssetsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]Asset
	// contains filtered or unexported fields
}

func (AssetsListOperationResponse) HasMore ¶ 

func (r AssetsListOperationResponse) HasMore() bool

func (AssetsListOperationResponse) LoadMore ¶ 

func (r AssetsListOperationResponse) LoadMore(ctx context.Context) (resp AssetsListOperationResponse, err error)

type AssetsListStreamingLocatorsOperationResponse ¶ 

type AssetsListStreamingLocatorsOperationResponse struct {
	HttpResponse *http.Response
	Model        *ListStreamingLocatorsResponse
}

type AssetsUpdateOperationResponse ¶ 

type AssetsUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *Asset
}

type Audio ¶ 

type Audio struct {
	Bitrate      *int64 `json:"bitrate,omitempty"`
	Channels     *int64 `json:"channels,omitempty"`
	SamplingRate *int64 `json:"samplingRate,omitempty"`

	// Fields inherited from Codec
	Label *string `json:"label,omitempty"`
}

func (Audio) MarshalJSON ¶ 

func (s Audio) MarshalJSON() ([]byte, error)

type AudioAnalysisMode ¶ 

type AudioAnalysisMode string
const (
	AudioAnalysisModeBasic    AudioAnalysisMode = "Basic"
	AudioAnalysisModeStandard AudioAnalysisMode = "Standard"
)

type AudioAnalyzerPreset ¶ 

type AudioAnalyzerPreset struct {
	AudioLanguage       *string            `json:"audioLanguage,omitempty"`
	ExperimentalOptions *map[string]string `json:"experimentalOptions,omitempty"`
	Mode                *AudioAnalysisMode `json:"mode,omitempty"`
}

func (AudioAnalyzerPreset) MarshalJSON ¶ 

func (s AudioAnalyzerPreset) MarshalJSON() ([]byte, error)

type AudioOverlay ¶ 

type AudioOverlay struct {

	// Fields inherited from Overlay
	AudioGainLevel  *float64 `json:"audioGainLevel,omitempty"`
	End             *string  `json:"end,omitempty"`
	FadeInDuration  *string  `json:"fadeInDuration,omitempty"`
	FadeOutDuration *string  `json:"fadeOutDuration,omitempty"`
	InputLabel      string   `json:"inputLabel"`
	Start           *string  `json:"start,omitempty"`
}

func (AudioOverlay) MarshalJSON ¶ 

func (s AudioOverlay) MarshalJSON() ([]byte, error)

type AudioTrackDescriptor ¶ 

type AudioTrackDescriptor struct {
	ChannelMapping *ChannelMapping `json:"channelMapping,omitempty"`
}

func (AudioTrackDescriptor) MarshalJSON ¶ 

func (s AudioTrackDescriptor) MarshalJSON() ([]byte, error)

type BlurType ¶ 

type BlurType string
const (
	BlurTypeBlack BlurType = "Black"
	BlurTypeBox   BlurType = "Box"
	BlurTypeHigh  BlurType = "High"
	BlurTypeLow   BlurType = "Low"
	BlurTypeMed   BlurType = "Med"
)

type BuiltInStandardEncoderPreset ¶ 

type BuiltInStandardEncoderPreset struct {
	PresetName EncoderNamedPreset `json:"presetName"`
}

func (BuiltInStandardEncoderPreset) MarshalJSON ¶ 

func (s BuiltInStandardEncoderPreset) MarshalJSON() ([]byte, error)

type CbcsDrmConfiguration ¶ 

type CbcsDrmConfiguration struct {
	FairPlay  *StreamingPolicyFairPlayConfiguration  `json:"fairPlay,omitempty"`
	PlayReady *StreamingPolicyPlayReadyConfiguration `json:"playReady,omitempty"`
	Widevine  *StreamingPolicyWidevineConfiguration  `json:"widevine,omitempty"`
}

type CencDrmConfiguration ¶ 

type CencDrmConfiguration struct {
	PlayReady *StreamingPolicyPlayReadyConfiguration `json:"playReady,omitempty"`
	Widevine  *StreamingPolicyWidevineConfiguration  `json:"widevine,omitempty"`
}

type ChannelMapping ¶ 

type ChannelMapping string
const (
	ChannelMappingBackLeft            ChannelMapping = "BackLeft"
	ChannelMappingBackRight           ChannelMapping = "BackRight"
	ChannelMappingCenter              ChannelMapping = "Center"
	ChannelMappingFrontLeft           ChannelMapping = "FrontLeft"
	ChannelMappingFrontRight          ChannelMapping = "FrontRight"
	ChannelMappingLowFrequencyEffects ChannelMapping = "LowFrequencyEffects"
	ChannelMappingStereoLeft          ChannelMapping = "StereoLeft"
	ChannelMappingStereoRight         ChannelMapping = "StereoRight"
)

type CheckNameAvailabilityInput ¶ 

type CheckNameAvailabilityInput struct {
	Name *string `json:"name,omitempty"`
	Type *string `json:"type,omitempty"`
}

type ClipTime ¶ 

type ClipTime interface {
}

type Codec ¶ 

type Codec interface {
}

type CommonEncryptionCbcs ¶ 

type CommonEncryptionCbcs struct {
	ClearTracks      *[]TrackSelection           `json:"clearTracks,omitempty"`
	ContentKeys      *StreamingPolicyContentKeys `json:"contentKeys,omitempty"`
	Drm              *CbcsDrmConfiguration       `json:"drm,omitempty"`
	EnabledProtocols *EnabledProtocols           `json:"enabledProtocols,omitempty"`
}

type CommonEncryptionCenc ¶ 

type CommonEncryptionCenc struct {
	ClearTracks      *[]TrackSelection           `json:"clearTracks,omitempty"`
	ContentKeys      *StreamingPolicyContentKeys `json:"contentKeys,omitempty"`
	Drm              *CencDrmConfiguration       `json:"drm,omitempty"`
	EnabledProtocols *EnabledProtocols           `json:"enabledProtocols,omitempty"`
}

type ContentKeyPoliciesCreateOrUpdateOperationResponse ¶ 

type ContentKeyPoliciesCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *ContentKeyPolicy
}

type ContentKeyPoliciesDeleteOperationResponse ¶ 

type ContentKeyPoliciesDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type ContentKeyPoliciesGetOperationResponse ¶ 

type ContentKeyPoliciesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *ContentKeyPolicy
}

type ContentKeyPoliciesGetPolicyPropertiesWithSecretsOperationResponse ¶ 

type ContentKeyPoliciesGetPolicyPropertiesWithSecretsOperationResponse struct {
	HttpResponse *http.Response
	Model        *ContentKeyPolicyProperties
}

type ContentKeyPoliciesId ¶ 

type ContentKeyPoliciesId struct {
	SubscriptionId       string
	ResourceGroupName    string
	AccountName          string
	ContentKeyPolicyName string
}

ContentKeyPoliciesId is a struct representing the Resource ID for a Content Key Policies

func NewContentKeyPoliciesID ¶ 

func NewContentKeyPoliciesID(subscriptionId string, resourceGroupName string, accountName string, contentKeyPolicyName string) ContentKeyPoliciesId

NewContentKeyPoliciesID returns a new ContentKeyPoliciesId struct

func ParseContentKeyPoliciesID ¶ 

func ParseContentKeyPoliciesID(input string) (*ContentKeyPoliciesId, error)

ParseContentKeyPoliciesID parses 'input' into a ContentKeyPoliciesId

func ParseContentKeyPoliciesIDInsensitively ¶ 

func ParseContentKeyPoliciesIDInsensitively(input string) (*ContentKeyPoliciesId, error)

ParseContentKeyPoliciesIDInsensitively parses 'input' case-insensitively into a ContentKeyPoliciesId note: this method should only be used for API response data and not user input

func (ContentKeyPoliciesId) ID ¶ 

func (id ContentKeyPoliciesId) ID() string

ID returns the formatted Content Key Policies ID

func (ContentKeyPoliciesId) Segments ¶ 

func (id ContentKeyPoliciesId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Content Key Policies ID

func (ContentKeyPoliciesId) String ¶ 

func (id ContentKeyPoliciesId) String() string

String returns a human-readable description of this Content Key Policies ID

type ContentKeyPoliciesListCompleteResult ¶ 

type ContentKeyPoliciesListCompleteResult struct {
	Items []ContentKeyPolicy
}

type ContentKeyPoliciesListOperationOptions ¶ 

type ContentKeyPoliciesListOperationOptions struct {
	Filter  *string
	Orderby *string
	Top     *int64
}

func DefaultContentKeyPoliciesListOperationOptions ¶ 

func DefaultContentKeyPoliciesListOperationOptions() ContentKeyPoliciesListOperationOptions

type ContentKeyPoliciesListOperationResponse ¶ 

type ContentKeyPoliciesListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]ContentKeyPolicy
	// contains filtered or unexported fields
}

func (ContentKeyPoliciesListOperationResponse) HasMore ¶ 

func (r ContentKeyPoliciesListOperationResponse) HasMore() bool

func (ContentKeyPoliciesListOperationResponse) LoadMore ¶ 

func (r ContentKeyPoliciesListOperationResponse) LoadMore(ctx context.Context) (resp ContentKeyPoliciesListOperationResponse, err error)

type ContentKeyPoliciesUpdateOperationResponse ¶ 

type ContentKeyPoliciesUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *ContentKeyPolicy
}

type ContentKeyPolicy ¶ 

type ContentKeyPolicy struct {
	Id         *string                     `json:"id,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties *ContentKeyPolicyProperties `json:"properties,omitempty"`
	SystemData *systemdata.SystemData      `json:"systemData,omitempty"`
	Type       *string                     `json:"type,omitempty"`
}

type ContentKeyPolicyClearKeyConfiguration ¶ 

type ContentKeyPolicyClearKeyConfiguration struct {
}

func (ContentKeyPolicyClearKeyConfiguration) MarshalJSON ¶ 

func (s ContentKeyPolicyClearKeyConfiguration) MarshalJSON() ([]byte, error)

type ContentKeyPolicyConfiguration ¶ 

type ContentKeyPolicyConfiguration interface {
}

type ContentKeyPolicyFairPlayConfiguration ¶ 

type ContentKeyPolicyFairPlayConfiguration struct {
	Ask                        string                                              `json:"ask"`
	FairPlayPfx                string                                              `json:"fairPlayPfx"`
	FairPlayPfxPassword        string                                              `json:"fairPlayPfxPassword"`
	OfflineRentalConfiguration *ContentKeyPolicyFairPlayOfflineRentalConfiguration `json:"offlineRentalConfiguration,omitempty"`
	RentalAndLeaseKeyType      ContentKeyPolicyFairPlayRentalAndLeaseKeyType       `json:"rentalAndLeaseKeyType"`
	RentalDuration             int64                                               `json:"rentalDuration"`
}

func (ContentKeyPolicyFairPlayConfiguration) MarshalJSON ¶ 

func (s ContentKeyPolicyFairPlayConfiguration) MarshalJSON() ([]byte, error)

type ContentKeyPolicyFairPlayOfflineRentalConfiguration ¶ 

type ContentKeyPolicyFairPlayOfflineRentalConfiguration struct {
	PlaybackDurationSeconds int64 `json:"playbackDurationSeconds"`
	StorageDurationSeconds  int64 `json:"storageDurationSeconds"`
}

type ContentKeyPolicyFairPlayRentalAndLeaseKeyType ¶ 

type ContentKeyPolicyFairPlayRentalAndLeaseKeyType string
const (
	ContentKeyPolicyFairPlayRentalAndLeaseKeyTypeDualExpiry          ContentKeyPolicyFairPlayRentalAndLeaseKeyType = "DualExpiry"
	ContentKeyPolicyFairPlayRentalAndLeaseKeyTypePersistentLimited   ContentKeyPolicyFairPlayRentalAndLeaseKeyType = "PersistentLimited"
	ContentKeyPolicyFairPlayRentalAndLeaseKeyTypePersistentUnlimited ContentKeyPolicyFairPlayRentalAndLeaseKeyType = "PersistentUnlimited"
	ContentKeyPolicyFairPlayRentalAndLeaseKeyTypeUndefined           ContentKeyPolicyFairPlayRentalAndLeaseKeyType = "Undefined"
	ContentKeyPolicyFairPlayRentalAndLeaseKeyTypeUnknown             ContentKeyPolicyFairPlayRentalAndLeaseKeyType = "Unknown"
)

type ContentKeyPolicyOpenRestriction ¶ 

type ContentKeyPolicyOpenRestriction struct {
}

func (ContentKeyPolicyOpenRestriction) MarshalJSON ¶ 

func (s ContentKeyPolicyOpenRestriction) MarshalJSON() ([]byte, error)

type ContentKeyPolicyOperationPredicate ¶ 

type ContentKeyPolicyOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (ContentKeyPolicyOperationPredicate) Matches ¶ 

func (p ContentKeyPolicyOperationPredicate) Matches(input ContentKeyPolicy) bool

type ContentKeyPolicyOption ¶ 

type ContentKeyPolicyOption struct {
	Configuration  ContentKeyPolicyConfiguration `json:"configuration"`
	Name           *string                       `json:"name,omitempty"`
	PolicyOptionId *string                       `json:"policyOptionId,omitempty"`
	Restriction    ContentKeyPolicyRestriction   `json:"restriction"`
}

func (*ContentKeyPolicyOption) UnmarshalJSON ¶ 

func (s *ContentKeyPolicyOption) UnmarshalJSON(bytes []byte) error

type ContentKeyPolicyPlayReadyConfiguration ¶ 

type ContentKeyPolicyPlayReadyConfiguration struct {
	Licenses           []ContentKeyPolicyPlayReadyLicense `json:"licenses"`
	ResponseCustomData *string                            `json:"responseCustomData,omitempty"`
}

func (ContentKeyPolicyPlayReadyConfiguration) MarshalJSON ¶ 

func (s ContentKeyPolicyPlayReadyConfiguration) MarshalJSON() ([]byte, error)

type ContentKeyPolicyPlayReadyContentEncryptionKeyFromHeader ¶ 

type ContentKeyPolicyPlayReadyContentEncryptionKeyFromHeader struct {
}

func (ContentKeyPolicyPlayReadyContentEncryptionKeyFromHeader) MarshalJSON ¶ 

func (s ContentKeyPolicyPlayReadyContentEncryptionKeyFromHeader) MarshalJSON() ([]byte, error)

type ContentKeyPolicyPlayReadyContentEncryptionKeyFromKeyIdentifier ¶ 

type ContentKeyPolicyPlayReadyContentEncryptionKeyFromKeyIdentifier struct {
	KeyId string `json:"keyId"`
}

func (ContentKeyPolicyPlayReadyContentEncryptionKeyFromKeyIdentifier) MarshalJSON ¶ 

func (s ContentKeyPolicyPlayReadyContentEncryptionKeyFromKeyIdentifier) MarshalJSON() ([]byte, error)

type ContentKeyPolicyPlayReadyContentKeyLocation ¶ 

type ContentKeyPolicyPlayReadyContentKeyLocation interface {
}

type ContentKeyPolicyPlayReadyContentType ¶ 

type ContentKeyPolicyPlayReadyContentType string
const (
	ContentKeyPolicyPlayReadyContentTypeUltraVioletDownload  ContentKeyPolicyPlayReadyContentType = "UltraVioletDownload"
	ContentKeyPolicyPlayReadyContentTypeUltraVioletStreaming ContentKeyPolicyPlayReadyContentType = "UltraVioletStreaming"
	ContentKeyPolicyPlayReadyContentTypeUnknown              ContentKeyPolicyPlayReadyContentType = "Unknown"
	ContentKeyPolicyPlayReadyContentTypeUnspecified          ContentKeyPolicyPlayReadyContentType = "Unspecified"
)

type ContentKeyPolicyPlayReadyExplicitAnalogTelevisionRestriction ¶ 

type ContentKeyPolicyPlayReadyExplicitAnalogTelevisionRestriction struct {
	BestEffort        bool  `json:"bestEffort"`
	ConfigurationData int64 `json:"configurationData"`
}

type ContentKeyPolicyPlayReadyLicense ¶ 

type ContentKeyPolicyPlayReadyLicense struct {
	AllowTestDevices       bool                                        `json:"allowTestDevices"`
	BeginDate              *string                                     `json:"beginDate,omitempty"`
	ContentKeyLocation     ContentKeyPolicyPlayReadyContentKeyLocation `json:"contentKeyLocation"`
	ContentType            ContentKeyPolicyPlayReadyContentType        `json:"contentType"`
	ExpirationDate         *string                                     `json:"expirationDate,omitempty"`
	GracePeriod            *string                                     `json:"gracePeriod,omitempty"`
	LicenseType            ContentKeyPolicyPlayReadyLicenseType        `json:"licenseType"`
	PlayRight              *ContentKeyPolicyPlayReadyPlayRight         `json:"playRight,omitempty"`
	RelativeBeginDate      *string                                     `json:"relativeBeginDate,omitempty"`
	RelativeExpirationDate *string                                     `json:"relativeExpirationDate,omitempty"`
}

func (*ContentKeyPolicyPlayReadyLicense) GetBeginDateAsTime ¶ 

func (o *ContentKeyPolicyPlayReadyLicense) GetBeginDateAsTime() (*time.Time, error)

func (*ContentKeyPolicyPlayReadyLicense) GetExpirationDateAsTime ¶ 

func (o *ContentKeyPolicyPlayReadyLicense) GetExpirationDateAsTime() (*time.Time, error)

func (*ContentKeyPolicyPlayReadyLicense) SetBeginDateAsTime ¶ 

func (o *ContentKeyPolicyPlayReadyLicense) SetBeginDateAsTime(input time.Time)

func (*ContentKeyPolicyPlayReadyLicense) SetExpirationDateAsTime ¶ 

func (o *ContentKeyPolicyPlayReadyLicense) SetExpirationDateAsTime(input time.Time)

func (*ContentKeyPolicyPlayReadyLicense) UnmarshalJSON ¶ 

func (s *ContentKeyPolicyPlayReadyLicense) UnmarshalJSON(bytes []byte) error

type ContentKeyPolicyPlayReadyLicenseType ¶ 

type ContentKeyPolicyPlayReadyLicenseType string
const (
	ContentKeyPolicyPlayReadyLicenseTypeNonPersistent ContentKeyPolicyPlayReadyLicenseType = "NonPersistent"
	ContentKeyPolicyPlayReadyLicenseTypePersistent    ContentKeyPolicyPlayReadyLicenseType = "Persistent"
	ContentKeyPolicyPlayReadyLicenseTypeUnknown       ContentKeyPolicyPlayReadyLicenseType = "Unknown"
)

type ContentKeyPolicyPlayReadyPlayRight ¶ 

type ContentKeyPolicyPlayReadyPlayRight struct {
	AgcAndColorStripeRestriction                       *int64                                                        `json:"agcAndColorStripeRestriction,omitempty"`
	AllowPassingVideoContentToUnknownOutput            ContentKeyPolicyPlayReadyUnknownOutputPassingOption           `json:"allowPassingVideoContentToUnknownOutput"`
	AnalogVideoOpl                                     *int64                                                        `json:"analogVideoOpl,omitempty"`
	CompressedDigitalAudioOpl                          *int64                                                        `json:"compressedDigitalAudioOpl,omitempty"`
	CompressedDigitalVideoOpl                          *int64                                                        `json:"compressedDigitalVideoOpl,omitempty"`
	DigitalVideoOnlyContentRestriction                 bool                                                          `json:"digitalVideoOnlyContentRestriction"`
	ExplicitAnalogTelevisionOutputRestriction          *ContentKeyPolicyPlayReadyExplicitAnalogTelevisionRestriction `json:"explicitAnalogTelevisionOutputRestriction,omitempty"`
	FirstPlayExpiration                                *string                                                       `json:"firstPlayExpiration,omitempty"`
	ImageConstraintForAnalogComponentVideoRestriction  bool                                                          `json:"imageConstraintForAnalogComponentVideoRestriction"`
	ImageConstraintForAnalogComputerMonitorRestriction bool                                                          `json:"imageConstraintForAnalogComputerMonitorRestriction"`
	ScmsRestriction                                    *int64                                                        `json:"scmsRestriction,omitempty"`
	UncompressedDigitalAudioOpl                        *int64                                                        `json:"uncompressedDigitalAudioOpl,omitempty"`
	UncompressedDigitalVideoOpl                        *int64                                                        `json:"uncompressedDigitalVideoOpl,omitempty"`
}

type ContentKeyPolicyPlayReadyUnknownOutputPassingOption ¶ 

type ContentKeyPolicyPlayReadyUnknownOutputPassingOption string
const (
	ContentKeyPolicyPlayReadyUnknownOutputPassingOptionAllowed                      ContentKeyPolicyPlayReadyUnknownOutputPassingOption = "Allowed"
	ContentKeyPolicyPlayReadyUnknownOutputPassingOptionAllowedWithVideoConstriction ContentKeyPolicyPlayReadyUnknownOutputPassingOption = "AllowedWithVideoConstriction"
	ContentKeyPolicyPlayReadyUnknownOutputPassingOptionNotAllowed                   ContentKeyPolicyPlayReadyUnknownOutputPassingOption = "NotAllowed"
	ContentKeyPolicyPlayReadyUnknownOutputPassingOptionUnknown                      ContentKeyPolicyPlayReadyUnknownOutputPassingOption = "Unknown"
)

type ContentKeyPolicyProperties ¶ 

type ContentKeyPolicyProperties struct {
	Created      *string                  `json:"created,omitempty"`
	Description  *string                  `json:"description,omitempty"`
	LastModified *string                  `json:"lastModified,omitempty"`
	Options      []ContentKeyPolicyOption `json:"options"`
	PolicyId     *string                  `json:"policyId,omitempty"`
}

func (*ContentKeyPolicyProperties) GetCreatedAsTime ¶ 

func (o *ContentKeyPolicyProperties) GetCreatedAsTime() (*time.Time, error)

func (*ContentKeyPolicyProperties) GetLastModifiedAsTime ¶ 

func (o *ContentKeyPolicyProperties) GetLastModifiedAsTime() (*time.Time, error)

func (*ContentKeyPolicyProperties) SetCreatedAsTime ¶ 

func (o *ContentKeyPolicyProperties) SetCreatedAsTime(input time.Time)

func (*ContentKeyPolicyProperties) SetLastModifiedAsTime ¶ 

func (o *ContentKeyPolicyProperties) SetLastModifiedAsTime(input time.Time)

type ContentKeyPolicyRestriction ¶ 

type ContentKeyPolicyRestriction interface {
}

type ContentKeyPolicyRestrictionTokenKey ¶ 

type ContentKeyPolicyRestrictionTokenKey interface {
}

type ContentKeyPolicyRestrictionTokenType ¶ 

type ContentKeyPolicyRestrictionTokenType string
const (
	ContentKeyPolicyRestrictionTokenTypeJwt     ContentKeyPolicyRestrictionTokenType = "Jwt"
	ContentKeyPolicyRestrictionTokenTypeSwt     ContentKeyPolicyRestrictionTokenType = "Swt"
	ContentKeyPolicyRestrictionTokenTypeUnknown ContentKeyPolicyRestrictionTokenType = "Unknown"
)

type ContentKeyPolicyRsaTokenKey ¶ 

type ContentKeyPolicyRsaTokenKey struct {
	Exponent string `json:"exponent"`
	Modulus  string `json:"modulus"`
}

func (ContentKeyPolicyRsaTokenKey) MarshalJSON ¶ 

func (s ContentKeyPolicyRsaTokenKey) MarshalJSON() ([]byte, error)

type ContentKeyPolicySymmetricTokenKey ¶ 

type ContentKeyPolicySymmetricTokenKey struct {
	KeyValue string `json:"keyValue"`
}

func (ContentKeyPolicySymmetricTokenKey) MarshalJSON ¶ 

func (s ContentKeyPolicySymmetricTokenKey) MarshalJSON() ([]byte, error)

type ContentKeyPolicyTokenClaim ¶ 

type ContentKeyPolicyTokenClaim struct {
	ClaimType  *string `json:"claimType,omitempty"`
	ClaimValue *string `json:"claimValue,omitempty"`
}

type ContentKeyPolicyTokenRestriction ¶ 

type ContentKeyPolicyTokenRestriction struct {
	AlternateVerificationKeys      *[]ContentKeyPolicyRestrictionTokenKey `json:"alternateVerificationKeys,omitempty"`
	Audience                       string                                 `json:"audience"`
	Issuer                         string                                 `json:"issuer"`
	OpenIdConnectDiscoveryDocument *string                                `json:"openIdConnectDiscoveryDocument,omitempty"`
	PrimaryVerificationKey         ContentKeyPolicyRestrictionTokenKey    `json:"primaryVerificationKey"`
	RequiredClaims                 *[]ContentKeyPolicyTokenClaim          `json:"requiredClaims,omitempty"`
	RestrictionTokenType           ContentKeyPolicyRestrictionTokenType   `json:"restrictionTokenType"`
}

func (ContentKeyPolicyTokenRestriction) MarshalJSON ¶ 

func (s ContentKeyPolicyTokenRestriction) MarshalJSON() ([]byte, error)

func (*ContentKeyPolicyTokenRestriction) UnmarshalJSON ¶ 

func (s *ContentKeyPolicyTokenRestriction) UnmarshalJSON(bytes []byte) error

type ContentKeyPolicyUnknownConfiguration ¶ 

type ContentKeyPolicyUnknownConfiguration struct {
}

func (ContentKeyPolicyUnknownConfiguration) MarshalJSON ¶ 

func (s ContentKeyPolicyUnknownConfiguration) MarshalJSON() ([]byte, error)

type ContentKeyPolicyUnknownRestriction ¶ 

type ContentKeyPolicyUnknownRestriction struct {
}

func (ContentKeyPolicyUnknownRestriction) MarshalJSON ¶ 

func (s ContentKeyPolicyUnknownRestriction) MarshalJSON() ([]byte, error)

type ContentKeyPolicyWidevineConfiguration ¶ 

type ContentKeyPolicyWidevineConfiguration struct {
	WidevineTemplate string `json:"widevineTemplate"`
}

func (ContentKeyPolicyWidevineConfiguration) MarshalJSON ¶ 

func (s ContentKeyPolicyWidevineConfiguration) MarshalJSON() ([]byte, error)

type ContentKeyPolicyX509CertificateTokenKey ¶ 

type ContentKeyPolicyX509CertificateTokenKey struct {
	RawBody string `json:"rawBody"`
}

func (ContentKeyPolicyX509CertificateTokenKey) MarshalJSON ¶ 

func (s ContentKeyPolicyX509CertificateTokenKey) MarshalJSON() ([]byte, error)

type CopyAudio ¶ 

type CopyAudio struct {

	// Fields inherited from Codec
	Label *string `json:"label,omitempty"`
}

func (CopyAudio) MarshalJSON ¶ 

func (s CopyAudio) MarshalJSON() ([]byte, error)

type CopyVideo ¶ 

type CopyVideo struct {

	// Fields inherited from Codec
	Label *string `json:"label,omitempty"`
}

func (CopyVideo) MarshalJSON ¶ 

func (s CopyVideo) MarshalJSON() ([]byte, error)

type DefaultKey ¶ 

type DefaultKey struct {
	Label      *string `json:"label,omitempty"`
	PolicyName *string `json:"policyName,omitempty"`
}

type Deinterlace ¶ 

type Deinterlace struct {
	Mode   *DeinterlaceMode   `json:"mode,omitempty"`
	Parity *DeinterlaceParity `json:"parity,omitempty"`
}

type DeinterlaceMode ¶ 

type DeinterlaceMode string
const (
	DeinterlaceModeAutoPixelAdaptive DeinterlaceMode = "AutoPixelAdaptive"
	DeinterlaceModeOff               DeinterlaceMode = "Off"
)

type DeinterlaceParity ¶ 

type DeinterlaceParity string
const (
	DeinterlaceParityAuto             DeinterlaceParity = "Auto"
	DeinterlaceParityBottomFieldFirst DeinterlaceParity = "BottomFieldFirst"
	DeinterlaceParityTopFieldFirst    DeinterlaceParity = "TopFieldFirst"
)

type EdgePolicies ¶ 

type EdgePolicies struct {
	UsageDataCollectionPolicy *EdgeUsageDataCollectionPolicy `json:"usageDataCollectionPolicy,omitempty"`
}

type EdgeUsageDataCollectionPolicy ¶ 

type EdgeUsageDataCollectionPolicy struct {
	DataCollectionFrequency           *string                `json:"dataCollectionFrequency,omitempty"`
	DataReportingFrequency            *string                `json:"dataReportingFrequency,omitempty"`
	EventHubDetails                   *EdgeUsageDataEventHub `json:"eventHubDetails,omitempty"`
	MaxAllowedUnreportedUsageDuration *string                `json:"maxAllowedUnreportedUsageDuration,omitempty"`
}

type EdgeUsageDataEventHub ¶ 

type EdgeUsageDataEventHub struct {
	Name      *string `json:"name,omitempty"`
	Namespace *string `json:"namespace,omitempty"`
	Token     *string `json:"token,omitempty"`
}

type EnabledProtocols ¶ 

type EnabledProtocols struct {
	Dash            bool `json:"dash"`
	Download        bool `json:"download"`
	Hls             bool `json:"hls"`
	SmoothStreaming bool `json:"smoothStreaming"`
}

type EncoderNamedPreset ¶ 

type EncoderNamedPreset string
const (
	EncoderNamedPresetAACGoodQualityAudio                         EncoderNamedPreset = "AACGoodQualityAudio"
	EncoderNamedPresetAdaptiveStreaming                           EncoderNamedPreset = "AdaptiveStreaming"
	EncoderNamedPresetContentAwareEncoding                        EncoderNamedPreset = "ContentAwareEncoding"
	EncoderNamedPresetContentAwareEncodingExperimental            EncoderNamedPreset = "ContentAwareEncodingExperimental"
	EncoderNamedPresetCopyAllBitrateNonInterleaved                EncoderNamedPreset = "CopyAllBitrateNonInterleaved"
	EncoderNamedPresetHTwoSixFiveAdaptiveStreaming                EncoderNamedPreset = "H265AdaptiveStreaming"
	EncoderNamedPresetHTwoSixFiveContentAwareEncoding             EncoderNamedPreset = "H265ContentAwareEncoding"
	EncoderNamedPresetHTwoSixFiveSingleBitrateFourK               EncoderNamedPreset = "H265SingleBitrate4K"
	EncoderNamedPresetHTwoSixFiveSingleBitrateOneZeroEightZerop   EncoderNamedPreset = "H265SingleBitrate1080p"
	EncoderNamedPresetHTwoSixFiveSingleBitrateSevenTwoZerop       EncoderNamedPreset = "H265SingleBitrate720p"
	EncoderNamedPresetHTwoSixFourMultipleBitrateOneZeroEightZerop EncoderNamedPreset = "H264MultipleBitrate1080p"
	EncoderNamedPresetHTwoSixFourMultipleBitrateSD                EncoderNamedPreset = "H264MultipleBitrateSD"
	EncoderNamedPresetHTwoSixFourMultipleBitrateSevenTwoZerop     EncoderNamedPreset = "H264MultipleBitrate720p"
	EncoderNamedPresetHTwoSixFourSingleBitrateOneZeroEightZerop   EncoderNamedPreset = "H264SingleBitrate1080p"
	EncoderNamedPresetHTwoSixFourSingleBitrateSD                  EncoderNamedPreset = "H264SingleBitrateSD"
	EncoderNamedPresetHTwoSixFourSingleBitrateSevenTwoZerop       EncoderNamedPreset = "H264SingleBitrate720p"
)

type EncryptionScheme ¶ 

type EncryptionScheme string
const (
	EncryptionSchemeCommonEncryptionCbcs EncryptionScheme = "CommonEncryptionCbcs"
	EncryptionSchemeCommonEncryptionCenc EncryptionScheme = "CommonEncryptionCenc"
	EncryptionSchemeEnvelopeEncryption   EncryptionScheme = "EnvelopeEncryption"
	EncryptionSchemeNoEncryption         EncryptionScheme = "NoEncryption"
)

type EntityNameAvailabilityCheckOutput ¶ 

type EntityNameAvailabilityCheckOutput struct {
	Message       *string `json:"message,omitempty"`
	NameAvailable bool    `json:"nameAvailable"`
	Reason        *string `json:"reason,omitempty"`
}

type EnvelopeEncryption ¶ 

type EnvelopeEncryption struct {
	ClearTracks                     *[]TrackSelection           `json:"clearTracks,omitempty"`
	ContentKeys                     *StreamingPolicyContentKeys `json:"contentKeys,omitempty"`
	CustomKeyAcquisitionUrlTemplate *string                     `json:"customKeyAcquisitionUrlTemplate,omitempty"`
	EnabledProtocols                *EnabledProtocols           `json:"enabledProtocols,omitempty"`
}

type FaceDetectorPreset ¶ 

type FaceDetectorPreset struct {
	BlurType            *BlurType           `json:"blurType,omitempty"`
	ExperimentalOptions *map[string]string  `json:"experimentalOptions,omitempty"`
	Mode                *FaceRedactorMode   `json:"mode,omitempty"`
	Resolution          *AnalysisResolution `json:"resolution,omitempty"`
}

func (FaceDetectorPreset) MarshalJSON ¶ 

func (s FaceDetectorPreset) MarshalJSON() ([]byte, error)

type FaceRedactorMode ¶ 

type FaceRedactorMode string
const (
	FaceRedactorModeAnalyze  FaceRedactorMode = "Analyze"
	FaceRedactorModeCombined FaceRedactorMode = "Combined"
	FaceRedactorModeRedact   FaceRedactorMode = "Redact"
)

type FilterTrackPropertyCompareOperation ¶ 

type FilterTrackPropertyCompareOperation string
const (
	FilterTrackPropertyCompareOperationEqual    FilterTrackPropertyCompareOperation = "Equal"
	FilterTrackPropertyCompareOperationNotEqual FilterTrackPropertyCompareOperation = "NotEqual"
)

type FilterTrackPropertyCondition ¶ 

type FilterTrackPropertyCondition struct {
	Operation FilterTrackPropertyCompareOperation `json:"operation"`
	Property  FilterTrackPropertyType             `json:"property"`
	Value     string                              `json:"value"`
}

type FilterTrackPropertyType ¶ 

type FilterTrackPropertyType string
const (
	FilterTrackPropertyTypeBitrate  FilterTrackPropertyType = "Bitrate"
	FilterTrackPropertyTypeFourCC   FilterTrackPropertyType = "FourCC"
	FilterTrackPropertyTypeLanguage FilterTrackPropertyType = "Language"
	FilterTrackPropertyTypeName     FilterTrackPropertyType = "Name"
	FilterTrackPropertyTypeType     FilterTrackPropertyType = "Type"
	FilterTrackPropertyTypeUnknown  FilterTrackPropertyType = "Unknown"
)

type FilterTrackSelection ¶ 

type FilterTrackSelection struct {
	TrackSelections []FilterTrackPropertyCondition `json:"trackSelections"`
}

type Filters ¶ 

type Filters struct {
	Crop        *Rectangle   `json:"crop,omitempty"`
	Deinterlace *Deinterlace `json:"deinterlace,omitempty"`
	Overlays    *[]Overlay   `json:"overlays,omitempty"`
	Rotation    *Rotation    `json:"rotation,omitempty"`
}

func (*Filters) UnmarshalJSON ¶ 

func (s *Filters) UnmarshalJSON(bytes []byte) error

type FirstQuality ¶ 

type FirstQuality struct {
	Bitrate int64 `json:"bitrate"`
}

type Format ¶ 

type Format interface {
}

type FromAllInputFile ¶ 

type FromAllInputFile struct {

	// Fields inherited from InputDefinition
	IncludedTracks *[]TrackDescriptor `json:"includedTracks,omitempty"`
}

func (FromAllInputFile) MarshalJSON ¶ 

func (s FromAllInputFile) MarshalJSON() ([]byte, error)

func (*FromAllInputFile) UnmarshalJSON ¶ added in v0.20220704.1074157 

func (s *FromAllInputFile) UnmarshalJSON(bytes []byte) error

type FromEachInputFile ¶ 

type FromEachInputFile struct {

	// Fields inherited from InputDefinition
	IncludedTracks *[]TrackDescriptor `json:"includedTracks,omitempty"`
}

func (FromEachInputFile) MarshalJSON ¶ 

func (s FromEachInputFile) MarshalJSON() ([]byte, error)

func (*FromEachInputFile) UnmarshalJSON ¶ added in v0.20220704.1074157 

func (s *FromEachInputFile) UnmarshalJSON(bytes []byte) error

type ImageFormat ¶ 

type ImageFormat struct {

	// Fields inherited from Format
	FilenamePattern string `json:"filenamePattern"`
}

func (ImageFormat) MarshalJSON ¶ 

func (s ImageFormat) MarshalJSON() ([]byte, error)

type InputDefinition ¶ 

type InputDefinition interface {
}

type InputFile ¶ 

type InputFile struct {
	Filename *string `json:"filename,omitempty"`

	// Fields inherited from InputDefinition
	IncludedTracks *[]TrackDescriptor `json:"includedTracks,omitempty"`
}

func (InputFile) MarshalJSON ¶ 

func (s InputFile) MarshalJSON() ([]byte, error)

func (*InputFile) UnmarshalJSON ¶ added in v0.20220704.1074157 

func (s *InputFile) UnmarshalJSON(bytes []byte) error

type Job ¶ 

type Job struct {
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *JobProperties         `json:"properties,omitempty"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type JobError ¶ 

type JobError struct {
	Category *JobErrorCategory `json:"category,omitempty"`
	Code     *JobErrorCode     `json:"code,omitempty"`
	Details  *[]JobErrorDetail `json:"details,omitempty"`
	Message  *string           `json:"message,omitempty"`
	Retry    *JobRetry         `json:"retry,omitempty"`
}

type JobErrorCategory ¶ 

type JobErrorCategory string
const (
	JobErrorCategoryConfiguration JobErrorCategory = "Configuration"
	JobErrorCategoryContent       JobErrorCategory = "Content"
	JobErrorCategoryDownload      JobErrorCategory = "Download"
	JobErrorCategoryService       JobErrorCategory = "Service"
	JobErrorCategoryUpload        JobErrorCategory = "Upload"
)

type JobErrorCode ¶ 

type JobErrorCode string
const (
	JobErrorCodeConfigurationUnsupported JobErrorCode = "ConfigurationUnsupported"
	JobErrorCodeContentMalformed         JobErrorCode = "ContentMalformed"
	JobErrorCodeContentUnsupported       JobErrorCode = "ContentUnsupported"
	JobErrorCodeDownloadNotAccessible    JobErrorCode = "DownloadNotAccessible"
	JobErrorCodeDownloadTransientError   JobErrorCode = "DownloadTransientError"
	JobErrorCodeServiceError             JobErrorCode = "ServiceError"
	JobErrorCodeServiceTransientError    JobErrorCode = "ServiceTransientError"
	JobErrorCodeUploadNotAccessible      JobErrorCode = "UploadNotAccessible"
	JobErrorCodeUploadTransientError     JobErrorCode = "UploadTransientError"
)

type JobErrorDetail ¶ 

type JobErrorDetail struct {
	Code    *string `json:"code,omitempty"`
	Message *string `json:"message,omitempty"`
}

type JobId ¶ 

type JobId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	TransformName     string
	JobName           string
}

JobId is a struct representing the Resource ID for a Job

func NewJobID ¶ 

func NewJobID(subscriptionId string, resourceGroupName string, accountName string, transformName string, jobName string) JobId

NewJobID returns a new JobId struct

func ParseJobID ¶ 

func ParseJobID(input string) (*JobId, error)

ParseJobID parses 'input' into a JobId

func ParseJobIDInsensitively ¶ 

func ParseJobIDInsensitively(input string) (*JobId, error)

ParseJobIDInsensitively parses 'input' case-insensitively into a JobId note: this method should only be used for API response data and not user input

func (JobId) ID ¶ 

func (id JobId) ID() string

ID returns the formatted Job ID

func (JobId) Segments ¶ 

func (id JobId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Job ID

func (JobId) String ¶ 

func (id JobId) String() string

String returns a human-readable description of this Job ID

type JobInput ¶ 

type JobInput interface {
}

type JobInputClip ¶ 

type JobInputClip struct {
	End              ClipTime           `json:"end"`
	Files            *[]string          `json:"files,omitempty"`
	InputDefinitions *[]InputDefinition `json:"inputDefinitions,omitempty"`
	Label            *string            `json:"label,omitempty"`
	Start            ClipTime           `json:"start"`
}

func (JobInputClip) MarshalJSON ¶ 

func (s JobInputClip) MarshalJSON() ([]byte, error)

func (*JobInputClip) UnmarshalJSON ¶ 

func (s *JobInputClip) UnmarshalJSON(bytes []byte) error

type JobInputSequence ¶ 

type JobInputSequence struct {
	Inputs *[]JobInput `json:"inputs,omitempty"`
}

func (JobInputSequence) MarshalJSON ¶ 

func (s JobInputSequence) MarshalJSON() ([]byte, error)

func (*JobInputSequence) UnmarshalJSON ¶ 

func (s *JobInputSequence) UnmarshalJSON(bytes []byte) error

type JobInputs ¶ 

type JobInputs struct {
	Inputs *[]JobInput `json:"inputs,omitempty"`
}

func (JobInputs) MarshalJSON ¶ 

func (s JobInputs) MarshalJSON() ([]byte, error)

func (*JobInputs) UnmarshalJSON ¶ 

func (s *JobInputs) UnmarshalJSON(bytes []byte) error

type JobOperationPredicate ¶ 

type JobOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (JobOperationPredicate) Matches ¶ 

func (p JobOperationPredicate) Matches(input Job) bool

type JobOutput ¶ 

type JobOutput interface {
}

type JobOutputAsset ¶ 

type JobOutputAsset struct {
	AssetName string `json:"assetName"`

	// Fields inherited from JobOutput
	EndTime   *string   `json:"endTime,omitempty"`
	Error     *JobError `json:"error,omitempty"`
	Label     *string   `json:"label,omitempty"`
	Progress  *int64    `json:"progress,omitempty"`
	StartTime *string   `json:"startTime,omitempty"`
	State     *JobState `json:"state,omitempty"`
}

func (*JobOutputAsset) GetEndTimeAsTime ¶ 

func (o *JobOutputAsset) GetEndTimeAsTime() (*time.Time, error)

func (*JobOutputAsset) GetStartTimeAsTime ¶ 

func (o *JobOutputAsset) GetStartTimeAsTime() (*time.Time, error)

func (JobOutputAsset) MarshalJSON ¶ 

func (s JobOutputAsset) MarshalJSON() ([]byte, error)

func (*JobOutputAsset) SetEndTimeAsTime ¶ 

func (o *JobOutputAsset) SetEndTimeAsTime(input time.Time)

func (*JobOutputAsset) SetStartTimeAsTime ¶ 

func (o *JobOutputAsset) SetStartTimeAsTime(input time.Time)

type JobProperties ¶ 

type JobProperties struct {
	CorrelationData *map[string]string `json:"correlationData,omitempty"`
	Created         *string            `json:"created,omitempty"`
	Description     *string            `json:"description,omitempty"`
	EndTime         *string            `json:"endTime,omitempty"`
	Input           JobInput           `json:"input"`
	LastModified    *string            `json:"lastModified,omitempty"`
	Outputs         []JobOutput        `json:"outputs"`
	Priority        *Priority          `json:"priority,omitempty"`
	StartTime       *string            `json:"startTime,omitempty"`
	State           *JobState          `json:"state,omitempty"`
}

func (*JobProperties) GetCreatedAsTime ¶ 

func (o *JobProperties) GetCreatedAsTime() (*time.Time, error)

func (*JobProperties) GetEndTimeAsTime ¶ 

func (o *JobProperties) GetEndTimeAsTime() (*time.Time, error)

func (*JobProperties) GetLastModifiedAsTime ¶ 

func (o *JobProperties) GetLastModifiedAsTime() (*time.Time, error)

func (*JobProperties) GetStartTimeAsTime ¶ 

func (o *JobProperties) GetStartTimeAsTime() (*time.Time, error)

func (*JobProperties) SetCreatedAsTime ¶ 

func (o *JobProperties) SetCreatedAsTime(input time.Time)

func (*JobProperties) SetEndTimeAsTime ¶ 

func (o *JobProperties) SetEndTimeAsTime(input time.Time)

func (*JobProperties) SetLastModifiedAsTime ¶ 

func (o *JobProperties) SetLastModifiedAsTime(input time.Time)

func (*JobProperties) SetStartTimeAsTime ¶ 

func (o *JobProperties) SetStartTimeAsTime(input time.Time)

func (*JobProperties) UnmarshalJSON ¶ 

func (s *JobProperties) UnmarshalJSON(bytes []byte) error

type JobRetry ¶ 

type JobRetry string
const (
	JobRetryDoNotRetry JobRetry = "DoNotRetry"
	JobRetryMayRetry   JobRetry = "MayRetry"
)

type JobState ¶ 

type JobState string
const (
	JobStateCanceled   JobState = "Canceled"
	JobStateCanceling  JobState = "Canceling"
	JobStateError      JobState = "Error"
	JobStateFinished   JobState = "Finished"
	JobStateProcessing JobState = "Processing"
	JobStateQueued     JobState = "Queued"
	JobStateScheduled  JobState = "Scheduled"
)

type JobsCancelJobOperationResponse ¶ 

type JobsCancelJobOperationResponse struct {
	HttpResponse *http.Response
}

type JobsCreateOperationResponse ¶ 

type JobsCreateOperationResponse struct {
	HttpResponse *http.Response
	Model        *Job
}

type JobsDeleteOperationResponse ¶ 

type JobsDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type JobsGetOperationResponse ¶ 

type JobsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *Job
}

type JobsListCompleteResult ¶ 

type JobsListCompleteResult struct {
	Items []Job
}

type JobsListOperationOptions ¶ 

type JobsListOperationOptions struct {
	Filter  *string
	Orderby *string
}

func DefaultJobsListOperationOptions ¶ 

func DefaultJobsListOperationOptions() JobsListOperationOptions

type JobsListOperationResponse ¶ 

type JobsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]Job
	// contains filtered or unexported fields
}

func (JobsListOperationResponse) HasMore ¶ 

func (r JobsListOperationResponse) HasMore() bool

func (JobsListOperationResponse) LoadMore ¶ 

func (r JobsListOperationResponse) LoadMore(ctx context.Context) (resp JobsListOperationResponse, err error)

type JobsUpdateOperationResponse ¶ 

type JobsUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *Job
}

type KeyVaultProperties ¶ 

type KeyVaultProperties struct {
	CurrentKeyIdentifier *string `json:"currentKeyIdentifier,omitempty"`
	KeyIdentifier        *string `json:"keyIdentifier,omitempty"`
}

type ListContainerSasInput ¶ 

type ListContainerSasInput struct {
	ExpiryTime  *string                   `json:"expiryTime,omitempty"`
	Permissions *AssetContainerPermission `json:"permissions,omitempty"`
}

func (*ListContainerSasInput) GetExpiryTimeAsTime ¶ 

func (o *ListContainerSasInput) GetExpiryTimeAsTime() (*time.Time, error)

func (*ListContainerSasInput) SetExpiryTimeAsTime ¶ 

func (o *ListContainerSasInput) SetExpiryTimeAsTime(input time.Time)

type ListContentKeysResponse ¶ 

type ListContentKeysResponse struct {
	ContentKeys *[]StreamingLocatorContentKey `json:"contentKeys,omitempty"`
}

type ListEdgePoliciesInput ¶ 

type ListEdgePoliciesInput struct {
	DeviceId *string `json:"deviceId,omitempty"`
}

type ListPathsResponse ¶ 

type ListPathsResponse struct {
	DownloadPaths  *[]string        `json:"downloadPaths,omitempty"`
	StreamingPaths *[]StreamingPath `json:"streamingPaths,omitempty"`
}

type ListStreamingLocatorsResponse ¶ 

type ListStreamingLocatorsResponse struct {
	StreamingLocators *[]AssetStreamingLocator `json:"streamingLocators,omitempty"`
}

type LocationId ¶ 

type LocationId struct {
	SubscriptionId string
	LocationName   string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID ¶ 

func NewLocationID(subscriptionId string, locationName string) LocationId

NewLocationID returns a new LocationId struct

func ParseLocationID ¶ 

func ParseLocationID(input string) (*LocationId, error)

ParseLocationID parses 'input' into a LocationId

func ParseLocationIDInsensitively ¶ 

func ParseLocationIDInsensitively(input string) (*LocationId, error)

ParseLocationIDInsensitively parses 'input' case-insensitively into a LocationId note: this method should only be used for API response data and not user input

func (LocationId) ID ¶ 

func (id LocationId) ID() string

ID returns the formatted Location ID

func (LocationId) Segments ¶ 

func (id LocationId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Location ID

func (LocationId) String ¶ 

func (id LocationId) String() string

String returns a human-readable description of this Location ID

type LocationsCheckNameAvailabilityOperationResponse ¶ 

type LocationsCheckNameAvailabilityOperationResponse struct {
	HttpResponse *http.Response
	Model        *EntityNameAvailabilityCheckOutput
}

type MediaClient ¶ 

type MediaClient struct {
	Client autorest.Client
	// contains filtered or unexported fields
}

func NewMediaClientWithBaseURI ¶ 

func NewMediaClientWithBaseURI(endpoint string) MediaClient

func (MediaClient) AccountFiltersCreateOrUpdate ¶ 

func (c MediaClient) AccountFiltersCreateOrUpdate(ctx context.Context, id AccountFilterId, input AccountFilter) (result AccountFiltersCreateOrUpdateOperationResponse, err error)

AccountFiltersCreateOrUpdate ...

func (MediaClient) AccountFiltersDelete ¶ 

func (c MediaClient) AccountFiltersDelete(ctx context.Context, id AccountFilterId) (result AccountFiltersDeleteOperationResponse, err error)

AccountFiltersDelete ...

func (MediaClient) AccountFiltersGet ¶ 

func (c MediaClient) AccountFiltersGet(ctx context.Context, id AccountFilterId) (result AccountFiltersGetOperationResponse, err error)

AccountFiltersGet ...

func (MediaClient) AccountFiltersList ¶ 

func (c MediaClient) AccountFiltersList(ctx context.Context, id MediaServiceId) (resp AccountFiltersListOperationResponse, err error)

AccountFiltersList ...

func (MediaClient) AccountFiltersListComplete ¶ 

func (c MediaClient) AccountFiltersListComplete(ctx context.Context, id MediaServiceId) (AccountFiltersListCompleteResult, error)

AccountFiltersListComplete retrieves all of the results into a single object

func (MediaClient) AccountFiltersListCompleteMatchingPredicate ¶ 

func (c MediaClient) AccountFiltersListCompleteMatchingPredicate(ctx context.Context, id MediaServiceId, predicate AccountFilterOperationPredicate) (resp AccountFiltersListCompleteResult, err error)

AccountFiltersListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) AccountFiltersUpdate ¶ 

func (c MediaClient) AccountFiltersUpdate(ctx context.Context, id AccountFilterId, input AccountFilter) (result AccountFiltersUpdateOperationResponse, err error)

AccountFiltersUpdate ...

func (MediaClient) AssetFiltersCreateOrUpdate ¶ 

func (c MediaClient) AssetFiltersCreateOrUpdate(ctx context.Context, id AssetFilterId, input AssetFilter) (result AssetFiltersCreateOrUpdateOperationResponse, err error)

AssetFiltersCreateOrUpdate ...

func (MediaClient) AssetFiltersDelete ¶ 

func (c MediaClient) AssetFiltersDelete(ctx context.Context, id AssetFilterId) (result AssetFiltersDeleteOperationResponse, err error)

AssetFiltersDelete ...

func (MediaClient) AssetFiltersGet ¶ 

func (c MediaClient) AssetFiltersGet(ctx context.Context, id AssetFilterId) (result AssetFiltersGetOperationResponse, err error)

AssetFiltersGet ...

func (MediaClient) AssetFiltersList ¶ 

func (c MediaClient) AssetFiltersList(ctx context.Context, id AssetId) (resp AssetFiltersListOperationResponse, err error)

AssetFiltersList ...

func (MediaClient) AssetFiltersListComplete ¶ 

func (c MediaClient) AssetFiltersListComplete(ctx context.Context, id AssetId) (AssetFiltersListCompleteResult, error)

AssetFiltersListComplete retrieves all of the results into a single object

func (MediaClient) AssetFiltersListCompleteMatchingPredicate ¶ 

func (c MediaClient) AssetFiltersListCompleteMatchingPredicate(ctx context.Context, id AssetId, predicate AssetFilterOperationPredicate) (resp AssetFiltersListCompleteResult, err error)

AssetFiltersListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) AssetFiltersUpdate ¶ 

func (c MediaClient) AssetFiltersUpdate(ctx context.Context, id AssetFilterId, input AssetFilter) (result AssetFiltersUpdateOperationResponse, err error)

AssetFiltersUpdate ...

func (MediaClient) AssetsCreateOrUpdate ¶ 

func (c MediaClient) AssetsCreateOrUpdate(ctx context.Context, id AssetId, input Asset) (result AssetsCreateOrUpdateOperationResponse, err error)

AssetsCreateOrUpdate ...

func (MediaClient) AssetsDelete ¶ 

func (c MediaClient) AssetsDelete(ctx context.Context, id AssetId) (result AssetsDeleteOperationResponse, err error)

AssetsDelete ...

func (MediaClient) AssetsGet ¶ 

func (c MediaClient) AssetsGet(ctx context.Context, id AssetId) (result AssetsGetOperationResponse, err error)

AssetsGet ...

func (MediaClient) AssetsGetEncryptionKey ¶ 

func (c MediaClient) AssetsGetEncryptionKey(ctx context.Context, id AssetId) (result AssetsGetEncryptionKeyOperationResponse, err error)

AssetsGetEncryptionKey ...

func (MediaClient) AssetsList ¶ 

func (c MediaClient) AssetsList(ctx context.Context, id MediaServiceId, options AssetsListOperationOptions) (resp AssetsListOperationResponse, err error)

AssetsList ...

func (MediaClient) AssetsListComplete ¶ 

func (c MediaClient) AssetsListComplete(ctx context.Context, id MediaServiceId, options AssetsListOperationOptions) (AssetsListCompleteResult, error)

AssetsListComplete retrieves all of the results into a single object

func (MediaClient) AssetsListCompleteMatchingPredicate ¶ 

func (c MediaClient) AssetsListCompleteMatchingPredicate(ctx context.Context, id MediaServiceId, options AssetsListOperationOptions, predicate AssetOperationPredicate) (resp AssetsListCompleteResult, err error)

AssetsListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) AssetsListContainerSas ¶ 

func (c MediaClient) AssetsListContainerSas(ctx context.Context, id AssetId, input ListContainerSasInput) (result AssetsListContainerSasOperationResponse, err error)

AssetsListContainerSas ...

func (MediaClient) AssetsListStreamingLocators ¶ 

func (c MediaClient) AssetsListStreamingLocators(ctx context.Context, id AssetId) (result AssetsListStreamingLocatorsOperationResponse, err error)

AssetsListStreamingLocators ...

func (MediaClient) AssetsUpdate ¶ 

func (c MediaClient) AssetsUpdate(ctx context.Context, id AssetId, input Asset) (result AssetsUpdateOperationResponse, err error)

AssetsUpdate ...

func (MediaClient) ContentKeyPoliciesCreateOrUpdate ¶ 

func (c MediaClient) ContentKeyPoliciesCreateOrUpdate(ctx context.Context, id ContentKeyPoliciesId, input ContentKeyPolicy) (result ContentKeyPoliciesCreateOrUpdateOperationResponse, err error)

ContentKeyPoliciesCreateOrUpdate ...

func (MediaClient) ContentKeyPoliciesDelete ¶ 

func (c MediaClient) ContentKeyPoliciesDelete(ctx context.Context, id ContentKeyPoliciesId) (result ContentKeyPoliciesDeleteOperationResponse, err error)

ContentKeyPoliciesDelete ...

func (MediaClient) ContentKeyPoliciesGet ¶ 

func (c MediaClient) ContentKeyPoliciesGet(ctx context.Context, id ContentKeyPoliciesId) (result ContentKeyPoliciesGetOperationResponse, err error)

ContentKeyPoliciesGet ...

func (MediaClient) ContentKeyPoliciesGetPolicyPropertiesWithSecrets ¶ 

func (c MediaClient) ContentKeyPoliciesGetPolicyPropertiesWithSecrets(ctx context.Context, id ContentKeyPoliciesId) (result ContentKeyPoliciesGetPolicyPropertiesWithSecretsOperationResponse, err error)

ContentKeyPoliciesGetPolicyPropertiesWithSecrets ...

func (MediaClient) ContentKeyPoliciesList ¶ 

func (c MediaClient) ContentKeyPoliciesList(ctx context.Context, id MediaServiceId, options ContentKeyPoliciesListOperationOptions) (resp ContentKeyPoliciesListOperationResponse, err error)

ContentKeyPoliciesList ...

func (MediaClient) ContentKeyPoliciesListComplete ¶ 

func (c MediaClient) ContentKeyPoliciesListComplete(ctx context.Context, id MediaServiceId, options ContentKeyPoliciesListOperationOptions) (ContentKeyPoliciesListCompleteResult, error)

ContentKeyPoliciesListComplete retrieves all of the results into a single object

func (MediaClient) ContentKeyPoliciesListCompleteMatchingPredicate ¶ 

func (c MediaClient) ContentKeyPoliciesListCompleteMatchingPredicate(ctx context.Context, id MediaServiceId, options ContentKeyPoliciesListOperationOptions, predicate ContentKeyPolicyOperationPredicate) (resp ContentKeyPoliciesListCompleteResult, err error)

ContentKeyPoliciesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) ContentKeyPoliciesUpdate ¶ 

func (c MediaClient) ContentKeyPoliciesUpdate(ctx context.Context, id ContentKeyPoliciesId, input ContentKeyPolicy) (result ContentKeyPoliciesUpdateOperationResponse, err error)

ContentKeyPoliciesUpdate ...

func (MediaClient) JobsCancelJob ¶ 

func (c MediaClient) JobsCancelJob(ctx context.Context, id JobId) (result JobsCancelJobOperationResponse, err error)

JobsCancelJob ...

func (MediaClient) JobsCreate ¶ 

func (c MediaClient) JobsCreate(ctx context.Context, id JobId, input Job) (result JobsCreateOperationResponse, err error)

JobsCreate ...

func (MediaClient) JobsDelete ¶ 

func (c MediaClient) JobsDelete(ctx context.Context, id JobId) (result JobsDeleteOperationResponse, err error)

JobsDelete ...

func (MediaClient) JobsGet ¶ 

func (c MediaClient) JobsGet(ctx context.Context, id JobId) (result JobsGetOperationResponse, err error)

JobsGet ...

func (MediaClient) JobsList ¶ 

func (c MediaClient) JobsList(ctx context.Context, id TransformId, options JobsListOperationOptions) (resp JobsListOperationResponse, err error)

JobsList ...

func (MediaClient) JobsListComplete ¶ 

func (c MediaClient) JobsListComplete(ctx context.Context, id TransformId, options JobsListOperationOptions) (JobsListCompleteResult, error)

JobsListComplete retrieves all of the results into a single object

func (MediaClient) JobsListCompleteMatchingPredicate ¶ 

func (c MediaClient) JobsListCompleteMatchingPredicate(ctx context.Context, id TransformId, options JobsListOperationOptions, predicate JobOperationPredicate) (resp JobsListCompleteResult, err error)

JobsListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) JobsUpdate ¶ 

func (c MediaClient) JobsUpdate(ctx context.Context, id JobId, input Job) (result JobsUpdateOperationResponse, err error)

JobsUpdate ...

func (MediaClient) LocationsCheckNameAvailability ¶ 

func (c MediaClient) LocationsCheckNameAvailability(ctx context.Context, id LocationId, input CheckNameAvailabilityInput) (result LocationsCheckNameAvailabilityOperationResponse, err error)

LocationsCheckNameAvailability ...

func (MediaClient) MediaservicesCreateOrUpdate ¶ 

func (c MediaClient) MediaservicesCreateOrUpdate(ctx context.Context, id ProviderMediaServiceId, input MediaService) (result MediaservicesCreateOrUpdateOperationResponse, err error)

MediaservicesCreateOrUpdate ...

func (MediaClient) MediaservicesDelete ¶ 

func (c MediaClient) MediaservicesDelete(ctx context.Context, id ProviderMediaServiceId) (result MediaservicesDeleteOperationResponse, err error)

MediaservicesDelete ...

func (MediaClient) MediaservicesGet ¶ 

func (c MediaClient) MediaservicesGet(ctx context.Context, id ProviderMediaServiceId) (result MediaservicesGetOperationResponse, err error)

MediaservicesGet ...

func (MediaClient) MediaservicesGetBySubscription ¶ 

func (c MediaClient) MediaservicesGetBySubscription(ctx context.Context, id MediaServiceId) (result MediaservicesGetBySubscriptionOperationResponse, err error)

MediaservicesGetBySubscription ...

func (MediaClient) MediaservicesList ¶ 

func (c MediaClient) MediaservicesList(ctx context.Context, id commonids.ResourceGroupId) (resp MediaservicesListOperationResponse, err error)

MediaservicesList ...

func (MediaClient) MediaservicesListBySubscription ¶ 

func (c MediaClient) MediaservicesListBySubscription(ctx context.Context, id commonids.SubscriptionId) (resp MediaservicesListBySubscriptionOperationResponse, err error)

MediaservicesListBySubscription ...

func (MediaClient) MediaservicesListBySubscriptionComplete ¶ 

func (c MediaClient) MediaservicesListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (MediaservicesListBySubscriptionCompleteResult, error)

MediaservicesListBySubscriptionComplete retrieves all of the results into a single object

func (MediaClient) MediaservicesListBySubscriptionCompleteMatchingPredicate ¶ 

func (c MediaClient) MediaservicesListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate MediaServiceOperationPredicate) (resp MediaservicesListBySubscriptionCompleteResult, err error)

MediaservicesListBySubscriptionCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) MediaservicesListComplete ¶ 

func (c MediaClient) MediaservicesListComplete(ctx context.Context, id commonids.ResourceGroupId) (MediaservicesListCompleteResult, error)

MediaservicesListComplete retrieves all of the results into a single object

func (MediaClient) MediaservicesListCompleteMatchingPredicate ¶ 

func (c MediaClient) MediaservicesListCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate MediaServiceOperationPredicate) (resp MediaservicesListCompleteResult, err error)

MediaservicesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) MediaservicesListEdgePolicies ¶ 

func (c MediaClient) MediaservicesListEdgePolicies(ctx context.Context, id ProviderMediaServiceId, input ListEdgePoliciesInput) (result MediaservicesListEdgePoliciesOperationResponse, err error)

MediaservicesListEdgePolicies ...

func (MediaClient) MediaservicesSyncStorageKeys ¶ 

func (c MediaClient) MediaservicesSyncStorageKeys(ctx context.Context, id ProviderMediaServiceId, input SyncStorageKeysInput) (result MediaservicesSyncStorageKeysOperationResponse, err error)

MediaservicesSyncStorageKeys ...

func (MediaClient) MediaservicesUpdate ¶ 

func (c MediaClient) MediaservicesUpdate(ctx context.Context, id ProviderMediaServiceId, input MediaService) (result MediaservicesUpdateOperationResponse, err error)

MediaservicesUpdate ...

func (MediaClient) PrivateEndpointConnectionsCreateOrUpdate ¶ 

func (c MediaClient) PrivateEndpointConnectionsCreateOrUpdate(ctx context.Context, id PrivateEndpointConnectionId, input PrivateEndpointConnection) (result PrivateEndpointConnectionsCreateOrUpdateOperationResponse, err error)

PrivateEndpointConnectionsCreateOrUpdate ...

func (MediaClient) PrivateEndpointConnectionsDelete ¶ 

func (c MediaClient) PrivateEndpointConnectionsDelete(ctx context.Context, id PrivateEndpointConnectionId) (result PrivateEndpointConnectionsDeleteOperationResponse, err error)

PrivateEndpointConnectionsDelete ...

func (MediaClient) PrivateEndpointConnectionsGet ¶ 

func (c MediaClient) PrivateEndpointConnectionsGet(ctx context.Context, id PrivateEndpointConnectionId) (result PrivateEndpointConnectionsGetOperationResponse, err error)

PrivateEndpointConnectionsGet ...

func (MediaClient) PrivateEndpointConnectionsList ¶ 

func (c MediaClient) PrivateEndpointConnectionsList(ctx context.Context, id ProviderMediaServiceId) (result PrivateEndpointConnectionsListOperationResponse, err error)

PrivateEndpointConnectionsList ...

func (MediaClient) PrivateLinkResourcesGet ¶ 

func (c MediaClient) PrivateLinkResourcesGet(ctx context.Context, id PrivateLinkResourceId) (result PrivateLinkResourcesGetOperationResponse, err error)

PrivateLinkResourcesGet ...

func (MediaClient) PrivateLinkResourcesList ¶ 

func (c MediaClient) PrivateLinkResourcesList(ctx context.Context, id ProviderMediaServiceId) (result PrivateLinkResourcesListOperationResponse, err error)

PrivateLinkResourcesList ...

func (MediaClient) StreamingLocatorsCreate ¶ 

func (c MediaClient) StreamingLocatorsCreate(ctx context.Context, id StreamingLocatorId, input StreamingLocator) (result StreamingLocatorsCreateOperationResponse, err error)

StreamingLocatorsCreate ...

func (MediaClient) StreamingLocatorsDelete ¶ 

func (c MediaClient) StreamingLocatorsDelete(ctx context.Context, id StreamingLocatorId) (result StreamingLocatorsDeleteOperationResponse, err error)

StreamingLocatorsDelete ...

func (MediaClient) StreamingLocatorsGet ¶ 

func (c MediaClient) StreamingLocatorsGet(ctx context.Context, id StreamingLocatorId) (result StreamingLocatorsGetOperationResponse, err error)

StreamingLocatorsGet ...

func (MediaClient) StreamingLocatorsList ¶ 

func (c MediaClient) StreamingLocatorsList(ctx context.Context, id MediaServiceId, options StreamingLocatorsListOperationOptions) (resp StreamingLocatorsListOperationResponse, err error)

StreamingLocatorsList ...

func (MediaClient) StreamingLocatorsListComplete ¶ 

func (c MediaClient) StreamingLocatorsListComplete(ctx context.Context, id MediaServiceId, options StreamingLocatorsListOperationOptions) (StreamingLocatorsListCompleteResult, error)

StreamingLocatorsListComplete retrieves all of the results into a single object

func (MediaClient) StreamingLocatorsListCompleteMatchingPredicate ¶ 

func (c MediaClient) StreamingLocatorsListCompleteMatchingPredicate(ctx context.Context, id MediaServiceId, options StreamingLocatorsListOperationOptions, predicate StreamingLocatorOperationPredicate) (resp StreamingLocatorsListCompleteResult, err error)

StreamingLocatorsListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) StreamingLocatorsListContentKeys ¶ 

func (c MediaClient) StreamingLocatorsListContentKeys(ctx context.Context, id StreamingLocatorId) (result StreamingLocatorsListContentKeysOperationResponse, err error)

StreamingLocatorsListContentKeys ...

func (MediaClient) StreamingLocatorsListPaths ¶ 

func (c MediaClient) StreamingLocatorsListPaths(ctx context.Context, id StreamingLocatorId) (result StreamingLocatorsListPathsOperationResponse, err error)

StreamingLocatorsListPaths ...

func (MediaClient) StreamingPoliciesCreate ¶ 

func (c MediaClient) StreamingPoliciesCreate(ctx context.Context, id StreamingPoliciesId, input StreamingPolicy) (result StreamingPoliciesCreateOperationResponse, err error)

StreamingPoliciesCreate ...

func (MediaClient) StreamingPoliciesDelete ¶ 

func (c MediaClient) StreamingPoliciesDelete(ctx context.Context, id StreamingPoliciesId) (result StreamingPoliciesDeleteOperationResponse, err error)

StreamingPoliciesDelete ...

func (MediaClient) StreamingPoliciesGet ¶ 

func (c MediaClient) StreamingPoliciesGet(ctx context.Context, id StreamingPoliciesId) (result StreamingPoliciesGetOperationResponse, err error)

StreamingPoliciesGet ...

func (MediaClient) StreamingPoliciesList ¶ 

func (c MediaClient) StreamingPoliciesList(ctx context.Context, id MediaServiceId, options StreamingPoliciesListOperationOptions) (resp StreamingPoliciesListOperationResponse, err error)

StreamingPoliciesList ...

func (MediaClient) StreamingPoliciesListComplete ¶ 

func (c MediaClient) StreamingPoliciesListComplete(ctx context.Context, id MediaServiceId, options StreamingPoliciesListOperationOptions) (StreamingPoliciesListCompleteResult, error)

StreamingPoliciesListComplete retrieves all of the results into a single object

func (MediaClient) StreamingPoliciesListCompleteMatchingPredicate ¶ 

func (c MediaClient) StreamingPoliciesListCompleteMatchingPredicate(ctx context.Context, id MediaServiceId, options StreamingPoliciesListOperationOptions, predicate StreamingPolicyOperationPredicate) (resp StreamingPoliciesListCompleteResult, err error)

StreamingPoliciesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) TransformsCreateOrUpdate ¶ 

func (c MediaClient) TransformsCreateOrUpdate(ctx context.Context, id TransformId, input Transform) (result TransformsCreateOrUpdateOperationResponse, err error)

TransformsCreateOrUpdate ...

func (MediaClient) TransformsDelete ¶ 

func (c MediaClient) TransformsDelete(ctx context.Context, id TransformId) (result TransformsDeleteOperationResponse, err error)

TransformsDelete ...

func (MediaClient) TransformsGet ¶ 

func (c MediaClient) TransformsGet(ctx context.Context, id TransformId) (result TransformsGetOperationResponse, err error)

TransformsGet ...

func (MediaClient) TransformsList ¶ 

func (c MediaClient) TransformsList(ctx context.Context, id MediaServiceId, options TransformsListOperationOptions) (resp TransformsListOperationResponse, err error)

TransformsList ...

func (MediaClient) TransformsListComplete ¶ 

func (c MediaClient) TransformsListComplete(ctx context.Context, id MediaServiceId, options TransformsListOperationOptions) (TransformsListCompleteResult, error)

TransformsListComplete retrieves all of the results into a single object

func (MediaClient) TransformsListCompleteMatchingPredicate ¶ 

func (c MediaClient) TransformsListCompleteMatchingPredicate(ctx context.Context, id MediaServiceId, options TransformsListOperationOptions, predicate TransformOperationPredicate) (resp TransformsListCompleteResult, err error)

TransformsListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (MediaClient) TransformsUpdate ¶ 

func (c MediaClient) TransformsUpdate(ctx context.Context, id TransformId, input Transform) (result TransformsUpdateOperationResponse, err error)

TransformsUpdate ...

type MediaFilterProperties ¶ 

type MediaFilterProperties struct {
	FirstQuality          *FirstQuality           `json:"firstQuality,omitempty"`
	PresentationTimeRange *PresentationTimeRange  `json:"presentationTimeRange,omitempty"`
	Tracks                *[]FilterTrackSelection `json:"tracks,omitempty"`
}

type MediaService ¶ 

type MediaService struct {
	Id         *string                  `json:"id,omitempty"`
	Identity   *identity.SystemAssigned `json:"identity,omitempty"`
	Location   string                   `json:"location"`
	Name       *string                  `json:"name,omitempty"`
	Properties *MediaServiceProperties  `json:"properties,omitempty"`
	SystemData *systemdata.SystemData   `json:"systemData,omitempty"`
	Tags       *map[string]string       `json:"tags,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type MediaServiceId ¶ 

type MediaServiceId struct {
	SubscriptionId string
	AccountName    string
}

MediaServiceId is a struct representing the Resource ID for a Media Service

func NewMediaServiceID ¶ 

func NewMediaServiceID(subscriptionId string, accountName string) MediaServiceId

NewMediaServiceID returns a new MediaServiceId struct

func ParseMediaServiceID ¶ 

func ParseMediaServiceID(input string) (*MediaServiceId, error)

ParseMediaServiceID parses 'input' into a MediaServiceId

func ParseMediaServiceIDInsensitively ¶ 

func ParseMediaServiceIDInsensitively(input string) (*MediaServiceId, error)

ParseMediaServiceIDInsensitively parses 'input' case-insensitively into a MediaServiceId note: this method should only be used for API response data and not user input

func (MediaServiceId) ID ¶ 

func (id MediaServiceId) ID() string

ID returns the formatted Media Service ID

func (MediaServiceId) Segments ¶ 

func (id MediaServiceId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Media Service ID

func (MediaServiceId) String ¶ 

func (id MediaServiceId) String() string

String returns a human-readable description of this Media Service ID

type MediaServiceOperationPredicate ¶ 

type MediaServiceOperationPredicate struct {
	Id       *string
	Location *string
	Name     *string
	Type     *string
}

func (MediaServiceOperationPredicate) Matches ¶ 

func (p MediaServiceOperationPredicate) Matches(input MediaService) bool

type MediaServiceProperties ¶ 

type MediaServiceProperties struct {
	Encryption            *AccountEncryption     `json:"encryption,omitempty"`
	MediaServiceId        *string                `json:"mediaServiceId,omitempty"`
	StorageAccounts       *[]StorageAccount      `json:"storageAccounts,omitempty"`
	StorageAuthentication *StorageAuthentication `json:"storageAuthentication,omitempty"`
}

type MediaservicesCreateOrUpdateOperationResponse ¶ 

type MediaservicesCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *MediaService
}

type MediaservicesDeleteOperationResponse ¶ 

type MediaservicesDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type MediaservicesGetBySubscriptionOperationResponse ¶ 

type MediaservicesGetBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	Model        *MediaService
}

type MediaservicesGetOperationResponse ¶ 

type MediaservicesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *MediaService
}

type MediaservicesListBySubscriptionCompleteResult ¶ 

type MediaservicesListBySubscriptionCompleteResult struct {
	Items []MediaService
}

type MediaservicesListBySubscriptionOperationResponse ¶ 

type MediaservicesListBySubscriptionOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]MediaService
	// contains filtered or unexported fields
}

func (MediaservicesListBySubscriptionOperationResponse) HasMore ¶ 

func (r MediaservicesListBySubscriptionOperationResponse) HasMore() bool

func (MediaservicesListBySubscriptionOperationResponse) LoadMore ¶ 

func (r MediaservicesListBySubscriptionOperationResponse) LoadMore(ctx context.Context) (resp MediaservicesListBySubscriptionOperationResponse, err error)

type MediaservicesListCompleteResult ¶ 

type MediaservicesListCompleteResult struct {
	Items []MediaService
}

type MediaservicesListEdgePoliciesOperationResponse ¶ 

type MediaservicesListEdgePoliciesOperationResponse struct {
	HttpResponse *http.Response
	Model        *EdgePolicies
}

type MediaservicesListOperationResponse ¶ 

type MediaservicesListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]MediaService
	// contains filtered or unexported fields
}

func (MediaservicesListOperationResponse) HasMore ¶ 

func (r MediaservicesListOperationResponse) HasMore() bool

func (MediaservicesListOperationResponse) LoadMore ¶ 

func (r MediaservicesListOperationResponse) LoadMore(ctx context.Context) (resp MediaservicesListOperationResponse, err error)

type MediaservicesSyncStorageKeysOperationResponse ¶ 

type MediaservicesSyncStorageKeysOperationResponse struct {
	HttpResponse *http.Response
}

type MediaservicesUpdateOperationResponse ¶ 

type MediaservicesUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *MediaService
}

type MultiBitrateFormat ¶ 

type MultiBitrateFormat struct {
	OutputFiles *[]OutputFile `json:"outputFiles,omitempty"`

	// Fields inherited from Format
	FilenamePattern string `json:"filenamePattern"`
}

func (MultiBitrateFormat) MarshalJSON ¶ 

func (s MultiBitrateFormat) MarshalJSON() ([]byte, error)

type NoEncryption ¶ 

type NoEncryption struct {
	EnabledProtocols *EnabledProtocols `json:"enabledProtocols,omitempty"`
}

type OnErrorType ¶ 

type OnErrorType string
const (
	OnErrorTypeContinueJob       OnErrorType = "ContinueJob"
	OnErrorTypeStopProcessingJob OnErrorType = "StopProcessingJob"
)

type OutputFile ¶ 

type OutputFile struct {
	Labels []string `json:"labels"`
}

type Overlay ¶ 

type Overlay interface {
}

type PresentationTimeRange ¶ 

type PresentationTimeRange struct {
	EndTimestamp               *int64 `json:"endTimestamp,omitempty"`
	ForceEndTimestamp          *bool  `json:"forceEndTimestamp,omitempty"`
	LiveBackoffDuration        *int64 `json:"liveBackoffDuration,omitempty"`
	PresentationWindowDuration *int64 `json:"presentationWindowDuration,omitempty"`
	StartTimestamp             *int64 `json:"startTimestamp,omitempty"`
	Timescale                  *int64 `json:"timescale,omitempty"`
}

type Preset ¶ 

type Preset interface {
}

type Priority ¶ 

type Priority string
const (
	PriorityHigh   Priority = "High"
	PriorityLow    Priority = "Low"
	PriorityNormal Priority = "Normal"
)

type PrivateEndpoint ¶ 

type PrivateEndpoint struct {
	Id *string `json:"id,omitempty"`
}

type PrivateEndpointConnection ¶ 

type PrivateEndpointConnection struct {
	Id         *string                              `json:"id,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type PrivateEndpointConnectionId ¶ 

type PrivateEndpointConnectionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	Name              string
}

PrivateEndpointConnectionId is a struct representing the Resource ID for a Private Endpoint Connection

func NewPrivateEndpointConnectionID ¶ 

func NewPrivateEndpointConnectionID(subscriptionId string, resourceGroupName string, accountName string, name string) PrivateEndpointConnectionId

NewPrivateEndpointConnectionID returns a new PrivateEndpointConnectionId struct

func ParsePrivateEndpointConnectionID ¶ 

func ParsePrivateEndpointConnectionID(input string) (*PrivateEndpointConnectionId, error)

ParsePrivateEndpointConnectionID parses 'input' into a PrivateEndpointConnectionId

func ParsePrivateEndpointConnectionIDInsensitively ¶ 

func ParsePrivateEndpointConnectionIDInsensitively(input string) (*PrivateEndpointConnectionId, error)

ParsePrivateEndpointConnectionIDInsensitively parses 'input' case-insensitively into a PrivateEndpointConnectionId note: this method should only be used for API response data and not user input

func (PrivateEndpointConnectionId) ID ¶ 

func (id PrivateEndpointConnectionId) ID() string

ID returns the formatted Private Endpoint Connection ID

func (PrivateEndpointConnectionId) Segments ¶ 

func (id PrivateEndpointConnectionId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Private Endpoint Connection ID

func (PrivateEndpointConnectionId) String ¶ 

func (id PrivateEndpointConnectionId) String() string

String returns a human-readable description of this Private Endpoint Connection ID

type PrivateEndpointConnectionListResult ¶ 

type PrivateEndpointConnectionListResult struct {
	Value *[]PrivateEndpointConnection `json:"value,omitempty"`
}

type PrivateEndpointConnectionProperties ¶ 

type PrivateEndpointConnectionProperties struct {
	PrivateEndpoint                   *PrivateEndpoint                            `json:"privateEndpoint,omitempty"`
	PrivateLinkServiceConnectionState PrivateLinkServiceConnectionState           `json:"privateLinkServiceConnectionState"`
	ProvisioningState                 *PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty"`
}

type PrivateEndpointConnectionProvisioningState ¶ 

type PrivateEndpointConnectionProvisioningState string
const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

type PrivateEndpointConnectionsCreateOrUpdateOperationResponse ¶ 

type PrivateEndpointConnectionsCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *PrivateEndpointConnection
}

type PrivateEndpointConnectionsDeleteOperationResponse ¶ 

type PrivateEndpointConnectionsDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type PrivateEndpointConnectionsGetOperationResponse ¶ 

type PrivateEndpointConnectionsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *PrivateEndpointConnection
}

type PrivateEndpointConnectionsListOperationResponse ¶ 

type PrivateEndpointConnectionsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *PrivateEndpointConnectionListResult
}

type PrivateEndpointServiceConnectionStatus ¶ 

type PrivateEndpointServiceConnectionStatus string
const (
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
)

type PrivateLinkResource ¶ 

type PrivateLinkResource struct {
	Id         *string                        `json:"id,omitempty"`
	Name       *string                        `json:"name,omitempty"`
	Properties *PrivateLinkResourceProperties `json:"properties,omitempty"`
	Type       *string                        `json:"type,omitempty"`
}

type PrivateLinkResourceId ¶ 

type PrivateLinkResourceId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	Name              string
}

PrivateLinkResourceId is a struct representing the Resource ID for a Private Link Resource

func NewPrivateLinkResourceID ¶ 

func NewPrivateLinkResourceID(subscriptionId string, resourceGroupName string, accountName string, name string) PrivateLinkResourceId

NewPrivateLinkResourceID returns a new PrivateLinkResourceId struct

func ParsePrivateLinkResourceID ¶ 

func ParsePrivateLinkResourceID(input string) (*PrivateLinkResourceId, error)

ParsePrivateLinkResourceID parses 'input' into a PrivateLinkResourceId

func ParsePrivateLinkResourceIDInsensitively ¶ 

func ParsePrivateLinkResourceIDInsensitively(input string) (*PrivateLinkResourceId, error)

ParsePrivateLinkResourceIDInsensitively parses 'input' case-insensitively into a PrivateLinkResourceId note: this method should only be used for API response data and not user input

func (PrivateLinkResourceId) ID ¶ 

func (id PrivateLinkResourceId) ID() string

ID returns the formatted Private Link Resource ID

func (PrivateLinkResourceId) Segments ¶ 

func (id PrivateLinkResourceId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Private Link Resource ID

func (PrivateLinkResourceId) String ¶ 

func (id PrivateLinkResourceId) String() string

String returns a human-readable description of this Private Link Resource ID

type PrivateLinkResourceListResult ¶ 

type PrivateLinkResourceListResult struct {
	Value *[]PrivateLinkResource `json:"value,omitempty"`
}

type PrivateLinkResourceProperties ¶ 

type PrivateLinkResourceProperties struct {
	GroupId           *string   `json:"groupId,omitempty"`
	RequiredMembers   *[]string `json:"requiredMembers,omitempty"`
	RequiredZoneNames *[]string `json:"requiredZoneNames,omitempty"`
}

type PrivateLinkResourcesGetOperationResponse ¶ 

type PrivateLinkResourcesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *PrivateLinkResource
}

type PrivateLinkResourcesListOperationResponse ¶ 

type PrivateLinkResourcesListOperationResponse struct {
	HttpResponse *http.Response
	Model        *PrivateLinkResourceListResult
}

type PrivateLinkServiceConnectionState ¶ 

type PrivateLinkServiceConnectionState struct {
	ActionsRequired *string                                 `json:"actionsRequired,omitempty"`
	Description     *string                                 `json:"description,omitempty"`
	Status          *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"`
}

type ProviderMediaServiceId ¶ 

type ProviderMediaServiceId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
}

ProviderMediaServiceId is a struct representing the Resource ID for a Provider Media Service

func NewProviderMediaServiceID ¶ 

func NewProviderMediaServiceID(subscriptionId string, resourceGroupName string, accountName string) ProviderMediaServiceId

NewProviderMediaServiceID returns a new ProviderMediaServiceId struct

func ParseProviderMediaServiceID ¶ 

func ParseProviderMediaServiceID(input string) (*ProviderMediaServiceId, error)

ParseProviderMediaServiceID parses 'input' into a ProviderMediaServiceId

func ParseProviderMediaServiceIDInsensitively ¶ 

func ParseProviderMediaServiceIDInsensitively(input string) (*ProviderMediaServiceId, error)

ParseProviderMediaServiceIDInsensitively parses 'input' case-insensitively into a ProviderMediaServiceId note: this method should only be used for API response data and not user input

func (ProviderMediaServiceId) ID ¶ 

func (id ProviderMediaServiceId) ID() string

ID returns the formatted Provider Media Service ID

func (ProviderMediaServiceId) Segments ¶ 

func (id ProviderMediaServiceId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Provider Media Service ID

func (ProviderMediaServiceId) String ¶ 

func (id ProviderMediaServiceId) String() string

String returns a human-readable description of this Provider Media Service ID

type Rectangle ¶ 

type Rectangle struct {
	Height *string `json:"height,omitempty"`
	Left   *string `json:"left,omitempty"`
	Top    *string `json:"top,omitempty"`
	Width  *string `json:"width,omitempty"`
}

type Rotation ¶ 

type Rotation string
const (
	RotationAuto               Rotation = "Auto"
	RotationNone               Rotation = "None"
	RotationRotateNineZero     Rotation = "Rotate90"
	RotationRotateOneEightZero Rotation = "Rotate180"
	RotationRotateTwoSevenZero Rotation = "Rotate270"
	RotationRotateZero         Rotation = "Rotate0"
)

type StandardEncoderPreset ¶ 

type StandardEncoderPreset struct {
	Codecs  []Codec  `json:"codecs"`
	Filters *Filters `json:"filters,omitempty"`
	Formats []Format `json:"formats"`
}

func (StandardEncoderPreset) MarshalJSON ¶ 

func (s StandardEncoderPreset) MarshalJSON() ([]byte, error)

func (*StandardEncoderPreset) UnmarshalJSON ¶ 

func (s *StandardEncoderPreset) UnmarshalJSON(bytes []byte) error

type StorageAccount ¶ 

type StorageAccount struct {
	Id   *string            `json:"id,omitempty"`
	Type StorageAccountType `json:"type"`
}

type StorageAccountType ¶ 

type StorageAccountType string
const (
	StorageAccountTypePrimary   StorageAccountType = "Primary"
	StorageAccountTypeSecondary StorageAccountType = "Secondary"
)

type StorageAuthentication ¶ 

type StorageAuthentication string
const (
	StorageAuthenticationManagedIdentity StorageAuthentication = "ManagedIdentity"
	StorageAuthenticationSystem          StorageAuthentication = "System"
)

type StorageEncryptedAssetDecryptionData ¶ 

type StorageEncryptedAssetDecryptionData struct {
	AssetFileEncryptionMetadata *[]AssetFileEncryptionMetadata `json:"assetFileEncryptionMetadata,omitempty"`
	Key                         *string                        `json:"key,omitempty"`
}

type StreamingLocator ¶ 

type StreamingLocator struct {
	Id         *string                     `json:"id,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties *StreamingLocatorProperties `json:"properties,omitempty"`
	SystemData *systemdata.SystemData      `json:"systemData,omitempty"`
	Type       *string                     `json:"type,omitempty"`
}

type StreamingLocatorContentKey ¶ 

type StreamingLocatorContentKey struct {
	Id                              string                          `json:"id"`
	LabelReferenceInStreamingPolicy *string                         `json:"labelReferenceInStreamingPolicy,omitempty"`
	PolicyName                      *string                         `json:"policyName,omitempty"`
	Tracks                          *[]TrackSelection               `json:"tracks,omitempty"`
	Type                            *StreamingLocatorContentKeyType `json:"type,omitempty"`
	Value                           *string                         `json:"value,omitempty"`
}

type StreamingLocatorContentKeyType ¶ 

type StreamingLocatorContentKeyType string
const (
	StreamingLocatorContentKeyTypeCommonEncryptionCbcs StreamingLocatorContentKeyType = "CommonEncryptionCbcs"
	StreamingLocatorContentKeyTypeCommonEncryptionCenc StreamingLocatorContentKeyType = "CommonEncryptionCenc"
	StreamingLocatorContentKeyTypeEnvelopeEncryption   StreamingLocatorContentKeyType = "EnvelopeEncryption"
)

type StreamingLocatorId ¶ 

type StreamingLocatorId struct {
	SubscriptionId       string
	ResourceGroupName    string
	AccountName          string
	StreamingLocatorName string
}

StreamingLocatorId is a struct representing the Resource ID for a Streaming Locator

func NewStreamingLocatorID ¶ 

func NewStreamingLocatorID(subscriptionId string, resourceGroupName string, accountName string, streamingLocatorName string) StreamingLocatorId

NewStreamingLocatorID returns a new StreamingLocatorId struct

func ParseStreamingLocatorID ¶ 

func ParseStreamingLocatorID(input string) (*StreamingLocatorId, error)

ParseStreamingLocatorID parses 'input' into a StreamingLocatorId

func ParseStreamingLocatorIDInsensitively ¶ 

func ParseStreamingLocatorIDInsensitively(input string) (*StreamingLocatorId, error)

ParseStreamingLocatorIDInsensitively parses 'input' case-insensitively into a StreamingLocatorId note: this method should only be used for API response data and not user input

func (StreamingLocatorId) ID ¶ 

func (id StreamingLocatorId) ID() string

ID returns the formatted Streaming Locator ID

func (StreamingLocatorId) Segments ¶ 

func (id StreamingLocatorId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Streaming Locator ID

func (StreamingLocatorId) String ¶ 

func (id StreamingLocatorId) String() string

String returns a human-readable description of this Streaming Locator ID

type StreamingLocatorOperationPredicate ¶ 

type StreamingLocatorOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (StreamingLocatorOperationPredicate) Matches ¶ 

func (p StreamingLocatorOperationPredicate) Matches(input StreamingLocator) bool

type StreamingLocatorProperties ¶ 

type StreamingLocatorProperties struct {
	AlternativeMediaId          *string                       `json:"alternativeMediaId,omitempty"`
	AssetName                   string                        `json:"assetName"`
	ContentKeys                 *[]StreamingLocatorContentKey `json:"contentKeys,omitempty"`
	Created                     *string                       `json:"created,omitempty"`
	DefaultContentKeyPolicyName *string                       `json:"defaultContentKeyPolicyName,omitempty"`
	EndTime                     *string                       `json:"endTime,omitempty"`
	Filters                     *[]string                     `json:"filters,omitempty"`
	StartTime                   *string                       `json:"startTime,omitempty"`
	StreamingLocatorId          *string                       `json:"streamingLocatorId,omitempty"`
	StreamingPolicyName         string                        `json:"streamingPolicyName"`
}

func (*StreamingLocatorProperties) GetCreatedAsTime ¶ 

func (o *StreamingLocatorProperties) GetCreatedAsTime() (*time.Time, error)

func (*StreamingLocatorProperties) GetEndTimeAsTime ¶ 

func (o *StreamingLocatorProperties) GetEndTimeAsTime() (*time.Time, error)

func (*StreamingLocatorProperties) GetStartTimeAsTime ¶ 

func (o *StreamingLocatorProperties) GetStartTimeAsTime() (*time.Time, error)

func (*StreamingLocatorProperties) SetCreatedAsTime ¶ 

func (o *StreamingLocatorProperties) SetCreatedAsTime(input time.Time)

func (*StreamingLocatorProperties) SetEndTimeAsTime ¶ 

func (o *StreamingLocatorProperties) SetEndTimeAsTime(input time.Time)

func (*StreamingLocatorProperties) SetStartTimeAsTime ¶ 

func (o *StreamingLocatorProperties) SetStartTimeAsTime(input time.Time)

type StreamingLocatorsCreateOperationResponse ¶ 

type StreamingLocatorsCreateOperationResponse struct {
	HttpResponse *http.Response
	Model        *StreamingLocator
}

type StreamingLocatorsDeleteOperationResponse ¶ 

type StreamingLocatorsDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type StreamingLocatorsGetOperationResponse ¶ 

type StreamingLocatorsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *StreamingLocator
}

type StreamingLocatorsListCompleteResult ¶ 

type StreamingLocatorsListCompleteResult struct {
	Items []StreamingLocator
}

type StreamingLocatorsListContentKeysOperationResponse ¶ 

type StreamingLocatorsListContentKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *ListContentKeysResponse
}

type StreamingLocatorsListOperationOptions ¶ 

type StreamingLocatorsListOperationOptions struct {
	Filter  *string
	Orderby *string
	Top     *int64
}

func DefaultStreamingLocatorsListOperationOptions ¶ 

func DefaultStreamingLocatorsListOperationOptions() StreamingLocatorsListOperationOptions

type StreamingLocatorsListOperationResponse ¶ 

type StreamingLocatorsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]StreamingLocator
	// contains filtered or unexported fields
}

func (StreamingLocatorsListOperationResponse) HasMore ¶ 

func (r StreamingLocatorsListOperationResponse) HasMore() bool

func (StreamingLocatorsListOperationResponse) LoadMore ¶ 

func (r StreamingLocatorsListOperationResponse) LoadMore(ctx context.Context) (resp StreamingLocatorsListOperationResponse, err error)

type StreamingLocatorsListPathsOperationResponse ¶ 

type StreamingLocatorsListPathsOperationResponse struct {
	HttpResponse *http.Response
	Model        *ListPathsResponse
}

type StreamingPath ¶ 

type StreamingPath struct {
	EncryptionScheme  EncryptionScheme                 `json:"encryptionScheme"`
	Paths             *[]string                        `json:"paths,omitempty"`
	StreamingProtocol StreamingPolicyStreamingProtocol `json:"streamingProtocol"`
}

type StreamingPoliciesCreateOperationResponse ¶ 

type StreamingPoliciesCreateOperationResponse struct {
	HttpResponse *http.Response
	Model        *StreamingPolicy
}

type StreamingPoliciesDeleteOperationResponse ¶ 

type StreamingPoliciesDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type StreamingPoliciesGetOperationResponse ¶ 

type StreamingPoliciesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *StreamingPolicy
}

type StreamingPoliciesId ¶ 

type StreamingPoliciesId struct {
	SubscriptionId      string
	ResourceGroupName   string
	AccountName         string
	StreamingPolicyName string
}

StreamingPoliciesId is a struct representing the Resource ID for a Streaming Policies

func NewStreamingPoliciesID ¶ 

func NewStreamingPoliciesID(subscriptionId string, resourceGroupName string, accountName string, streamingPolicyName string) StreamingPoliciesId

NewStreamingPoliciesID returns a new StreamingPoliciesId struct

func ParseStreamingPoliciesID ¶ 

func ParseStreamingPoliciesID(input string) (*StreamingPoliciesId, error)

ParseStreamingPoliciesID parses 'input' into a StreamingPoliciesId

func ParseStreamingPoliciesIDInsensitively ¶ 

func ParseStreamingPoliciesIDInsensitively(input string) (*StreamingPoliciesId, error)

ParseStreamingPoliciesIDInsensitively parses 'input' case-insensitively into a StreamingPoliciesId note: this method should only be used for API response data and not user input

func (StreamingPoliciesId) ID ¶ 

func (id StreamingPoliciesId) ID() string

ID returns the formatted Streaming Policies ID

func (StreamingPoliciesId) Segments ¶ 

func (id StreamingPoliciesId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Streaming Policies ID

func (StreamingPoliciesId) String ¶ 

func (id StreamingPoliciesId) String() string

String returns a human-readable description of this Streaming Policies ID

type StreamingPoliciesListCompleteResult ¶ 

type StreamingPoliciesListCompleteResult struct {
	Items []StreamingPolicy
}

type StreamingPoliciesListOperationOptions ¶ 

type StreamingPoliciesListOperationOptions struct {
	Filter  *string
	Orderby *string
	Top     *int64
}

func DefaultStreamingPoliciesListOperationOptions ¶ 

func DefaultStreamingPoliciesListOperationOptions() StreamingPoliciesListOperationOptions

type StreamingPoliciesListOperationResponse ¶ 

type StreamingPoliciesListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]StreamingPolicy
	// contains filtered or unexported fields
}

func (StreamingPoliciesListOperationResponse) HasMore ¶ 

func (r StreamingPoliciesListOperationResponse) HasMore() bool

func (StreamingPoliciesListOperationResponse) LoadMore ¶ 

func (r StreamingPoliciesListOperationResponse) LoadMore(ctx context.Context) (resp StreamingPoliciesListOperationResponse, err error)

type StreamingPolicy ¶ 

type StreamingPolicy struct {
	Id         *string                    `json:"id,omitempty"`
	Name       *string                    `json:"name,omitempty"`
	Properties *StreamingPolicyProperties `json:"properties,omitempty"`
	SystemData *systemdata.SystemData     `json:"systemData,omitempty"`
	Type       *string                    `json:"type,omitempty"`
}

type StreamingPolicyContentKey ¶ 

type StreamingPolicyContentKey struct {
	Label      *string           `json:"label,omitempty"`
	PolicyName *string           `json:"policyName,omitempty"`
	Tracks     *[]TrackSelection `json:"tracks,omitempty"`
}

type StreamingPolicyContentKeys ¶ 

type StreamingPolicyContentKeys struct {
	DefaultKey         *DefaultKey                  `json:"defaultKey,omitempty"`
	KeyToTrackMappings *[]StreamingPolicyContentKey `json:"keyToTrackMappings,omitempty"`
}

type StreamingPolicyFairPlayConfiguration ¶ 

type StreamingPolicyFairPlayConfiguration struct {
	AllowPersistentLicense              bool    `json:"allowPersistentLicense"`
	CustomLicenseAcquisitionUrlTemplate *string `json:"customLicenseAcquisitionUrlTemplate,omitempty"`
}

type StreamingPolicyOperationPredicate ¶ 

type StreamingPolicyOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (StreamingPolicyOperationPredicate) Matches ¶ 

func (p StreamingPolicyOperationPredicate) Matches(input StreamingPolicy) bool

type StreamingPolicyPlayReadyConfiguration ¶ 

type StreamingPolicyPlayReadyConfiguration struct {
	CustomLicenseAcquisitionUrlTemplate *string `json:"customLicenseAcquisitionUrlTemplate,omitempty"`
	PlayReadyCustomAttributes           *string `json:"playReadyCustomAttributes,omitempty"`
}

type StreamingPolicyProperties ¶ 

type StreamingPolicyProperties struct {
	CommonEncryptionCbcs        *CommonEncryptionCbcs `json:"commonEncryptionCbcs,omitempty"`
	CommonEncryptionCenc        *CommonEncryptionCenc `json:"commonEncryptionCenc,omitempty"`
	Created                     *string               `json:"created,omitempty"`
	DefaultContentKeyPolicyName *string               `json:"defaultContentKeyPolicyName,omitempty"`
	EnvelopeEncryption          *EnvelopeEncryption   `json:"envelopeEncryption,omitempty"`
	NoEncryption                *NoEncryption         `json:"noEncryption,omitempty"`
}

func (*StreamingPolicyProperties) GetCreatedAsTime ¶ 

func (o *StreamingPolicyProperties) GetCreatedAsTime() (*time.Time, error)

func (*StreamingPolicyProperties) SetCreatedAsTime ¶ 

func (o *StreamingPolicyProperties) SetCreatedAsTime(input time.Time)

type StreamingPolicyStreamingProtocol ¶ 

type StreamingPolicyStreamingProtocol string
const (
	StreamingPolicyStreamingProtocolDash            StreamingPolicyStreamingProtocol = "Dash"
	StreamingPolicyStreamingProtocolDownload        StreamingPolicyStreamingProtocol = "Download"
	StreamingPolicyStreamingProtocolHls             StreamingPolicyStreamingProtocol = "Hls"
	StreamingPolicyStreamingProtocolSmoothStreaming StreamingPolicyStreamingProtocol = "SmoothStreaming"
)

type StreamingPolicyWidevineConfiguration ¶ 

type StreamingPolicyWidevineConfiguration struct {
	CustomLicenseAcquisitionUrlTemplate *string `json:"customLicenseAcquisitionUrlTemplate,omitempty"`
}

type StretchMode ¶ 

type StretchMode string
const (
	StretchModeAutoFit  StretchMode = "AutoFit"
	StretchModeAutoSize StretchMode = "AutoSize"
	StretchModeNone     StretchMode = "None"
)

type SyncStorageKeysInput ¶ 

type SyncStorageKeysInput struct {
	Id *string `json:"id,omitempty"`
}

type TrackDescriptor ¶ 

type TrackDescriptor interface {
}

type TrackPropertyCompareOperation ¶ 

type TrackPropertyCompareOperation string
const (
	TrackPropertyCompareOperationEqual   TrackPropertyCompareOperation = "Equal"
	TrackPropertyCompareOperationUnknown TrackPropertyCompareOperation = "Unknown"
)

type TrackPropertyCondition ¶ 

type TrackPropertyCondition struct {
	Operation TrackPropertyCompareOperation `json:"operation"`
	Property  TrackPropertyType             `json:"property"`
	Value     *string                       `json:"value,omitempty"`
}

type TrackPropertyType ¶ 

type TrackPropertyType string
const (
	TrackPropertyTypeFourCC  TrackPropertyType = "FourCC"
	TrackPropertyTypeUnknown TrackPropertyType = "Unknown"
)

type TrackSelection ¶ 

type TrackSelection struct {
	TrackSelections *[]TrackPropertyCondition `json:"trackSelections,omitempty"`
}

type Transform ¶ 

type Transform struct {
	Id         *string                `json:"id,omitempty"`
	Name       *string                `json:"name,omitempty"`
	Properties *TransformProperties   `json:"properties,omitempty"`
	SystemData *systemdata.SystemData `json:"systemData,omitempty"`
	Type       *string                `json:"type,omitempty"`
}

type TransformId ¶ 

type TransformId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	TransformName     string
}

TransformId is a struct representing the Resource ID for a Transform

func NewTransformID ¶ 

func NewTransformID(subscriptionId string, resourceGroupName string, accountName string, transformName string) TransformId

NewTransformID returns a new TransformId struct

func ParseTransformID ¶ 

func ParseTransformID(input string) (*TransformId, error)

ParseTransformID parses 'input' into a TransformId

func ParseTransformIDInsensitively ¶ 

func ParseTransformIDInsensitively(input string) (*TransformId, error)

ParseTransformIDInsensitively parses 'input' case-insensitively into a TransformId note: this method should only be used for API response data and not user input

func (TransformId) ID ¶ 

func (id TransformId) ID() string

ID returns the formatted Transform ID

func (TransformId) Segments ¶ 

func (id TransformId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Transform ID

func (TransformId) String ¶ 

func (id TransformId) String() string

String returns a human-readable description of this Transform ID

type TransformOperationPredicate ¶ 

type TransformOperationPredicate struct {
	Id   *string
	Name *string
	Type *string
}

func (TransformOperationPredicate) Matches ¶ 

func (p TransformOperationPredicate) Matches(input Transform) bool

type TransformOutput ¶ 

type TransformOutput struct {
	OnError          *OnErrorType `json:"onError,omitempty"`
	Preset           Preset       `json:"preset"`
	RelativePriority *Priority    `json:"relativePriority,omitempty"`
}

func (*TransformOutput) UnmarshalJSON ¶ 

func (s *TransformOutput) UnmarshalJSON(bytes []byte) error

type TransformProperties ¶ 

type TransformProperties struct {
	Created      *string           `json:"created,omitempty"`
	Description  *string           `json:"description,omitempty"`
	LastModified *string           `json:"lastModified,omitempty"`
	Outputs      []TransformOutput `json:"outputs"`
}

func (*TransformProperties) GetCreatedAsTime ¶ 

func (o *TransformProperties) GetCreatedAsTime() (*time.Time, error)

func (*TransformProperties) GetLastModifiedAsTime ¶ 

func (o *TransformProperties) GetLastModifiedAsTime() (*time.Time, error)

func (*TransformProperties) SetCreatedAsTime ¶ 

func (o *TransformProperties) SetCreatedAsTime(input time.Time)

func (*TransformProperties) SetLastModifiedAsTime ¶ 

func (o *TransformProperties) SetLastModifiedAsTime(input time.Time)

type TransformsCreateOrUpdateOperationResponse ¶ 

type TransformsCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *Transform
}

type TransformsDeleteOperationResponse ¶ 

type TransformsDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type TransformsGetOperationResponse ¶ 

type TransformsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *Transform
}

type TransformsListCompleteResult ¶ 

type TransformsListCompleteResult struct {
	Items []Transform
}

type TransformsListOperationOptions ¶ 

type TransformsListOperationOptions struct {
	Filter  *string
	Orderby *string
}

func DefaultTransformsListOperationOptions ¶ 

func DefaultTransformsListOperationOptions() TransformsListOperationOptions

type TransformsListOperationResponse ¶ 

type TransformsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]Transform
	// contains filtered or unexported fields
}

func (TransformsListOperationResponse) HasMore ¶ 

func (r TransformsListOperationResponse) HasMore() bool

func (TransformsListOperationResponse) LoadMore ¶ 

func (r TransformsListOperationResponse) LoadMore(ctx context.Context) (resp TransformsListOperationResponse, err error)

type TransformsUpdateOperationResponse ¶ 

type TransformsUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *Transform
}

type UtcClipTime ¶ 

type UtcClipTime struct {
	Time string `json:"time"`
}

func (UtcClipTime) MarshalJSON ¶ 

func (s UtcClipTime) MarshalJSON() ([]byte, error)

type Video ¶ 

type Video struct {
	KeyFrameInterval *string        `json:"keyFrameInterval,omitempty"`
	StretchMode      *StretchMode   `json:"stretchMode,omitempty"`
	SyncMode         *VideoSyncMode `json:"syncMode,omitempty"`

	// Fields inherited from Codec
	Label *string `json:"label,omitempty"`
}

func (Video) MarshalJSON ¶ 

func (s Video) MarshalJSON() ([]byte, error)

type VideoOverlay ¶ 

type VideoOverlay struct {
	CropRectangle *Rectangle `json:"cropRectangle,omitempty"`
	Opacity       *float64   `json:"opacity,omitempty"`
	Position      *Rectangle `json:"position,omitempty"`

	// Fields inherited from Overlay
	AudioGainLevel  *float64 `json:"audioGainLevel,omitempty"`
	End             *string  `json:"end,omitempty"`
	FadeInDuration  *string  `json:"fadeInDuration,omitempty"`
	FadeOutDuration *string  `json:"fadeOutDuration,omitempty"`
	InputLabel      string   `json:"inputLabel"`
	Start           *string  `json:"start,omitempty"`
}

func (VideoOverlay) MarshalJSON ¶ 

func (s VideoOverlay) MarshalJSON() ([]byte, error)

type VideoSyncMode ¶ 

type VideoSyncMode string
const (
	VideoSyncModeAuto        VideoSyncMode = "Auto"
	VideoSyncModeCfr         VideoSyncMode = "Cfr"
	VideoSyncModePassthrough VideoSyncMode = "Passthrough"
	VideoSyncModeVfr         VideoSyncMode = "Vfr"
)

type VideoTrackDescriptor ¶ 

type VideoTrackDescriptor struct {
}

func (VideoTrackDescriptor) MarshalJSON ¶ 

func (s VideoTrackDescriptor) MarshalJSON() ([]byte, error)

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.