cosmosdb

package
v0.20221216.1110338 Latest Latest
Warning

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

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

README ¶

github.com/hashicorp/go-azure-sdk/resource-manager/cosmosdb/2022-08-15/cosmosdb Documentation

The cosmosdb SDK allows for interaction with the Azure Resource Manager Service cosmosdb (API Version 2022-08-15).

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/cosmosdb/2022-08-15/cosmosdb"

Client Initialization

client := cosmosdb.NewCosmosDBClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: CosmosDBClient.CassandraResourcesCreateUpdateCassandraKeyspace

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

payload := cosmosdb.CassandraKeyspaceCreateUpdateParameters{
	// ...
}


if err := client.CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesCreateUpdateCassandraTable

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

payload := cosmosdb.CassandraTableCreateUpdateParameters{
	// ...
}


if err := client.CassandraResourcesCreateUpdateCassandraTableThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesDeleteCassandraKeyspace

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

if err := client.CassandraResourcesDeleteCassandraKeyspaceThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesDeleteCassandraTable

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

if err := client.CassandraResourcesDeleteCassandraTableThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraKeyspace

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

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

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraKeyspaceThroughput

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

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

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraTable

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

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

Example Usage: CosmosDBClient.CassandraResourcesGetCassandraTableThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

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

Example Usage: CosmosDBClient.CassandraResourcesListCassandraKeyspaces

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

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

Example Usage: CosmosDBClient.CassandraResourcesListCassandraTables

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

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

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraKeyspaceToAutoscale

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

if err := client.CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraKeyspaceToManualThroughput

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

if err := client.CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraTableToAutoscale

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

if err := client.CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesMigrateCassandraTableToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

if err := client.CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesUpdateCassandraKeyspaceThroughput

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

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CassandraResourcesUpdateCassandraTableThroughput

ctx := context.TODO()
id := cosmosdb.NewCassandraKeyspaceTableID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "keyspaceValue", "tableValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.CassandraResourcesUpdateCassandraTableThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.CollectionListMetricDefinitions

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.CollectionListMetrics

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.CollectionListUsages

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.CollectionPartitionListMetrics

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.CollectionPartitionListUsages

ctx := context.TODO()
id := cosmosdb.NewCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.CollectionPartitionRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "regionValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.CollectionRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "regionValue", "databaseRidValue", "collectionRidValue")

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

Example Usage: CosmosDBClient.DatabaseAccountRegionListMetrics

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

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

Example Usage: CosmosDBClient.DatabaseAccountsCheckNameExists

ctx := context.TODO()
id := cosmosdb.NewDatabaseAccountNameID("accountValue")

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

Example Usage: CosmosDBClient.DatabaseAccountsCreateOrUpdate

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

payload := cosmosdb.DatabaseAccountCreateUpdateParameters{
	// ...
}


if err := client.DatabaseAccountsCreateOrUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsDelete

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

if err := client.DatabaseAccountsDeleteThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsFailoverPriorityChange

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

payload := cosmosdb.FailoverPolicies{
	// ...
}


if err := client.DatabaseAccountsFailoverPriorityChangeThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsGet

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

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

Example Usage: CosmosDBClient.DatabaseAccountsGetReadOnlyKeys

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

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

Example Usage: CosmosDBClient.DatabaseAccountsList

ctx := context.TODO()
id := cosmosdb.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

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

Example Usage: CosmosDBClient.DatabaseAccountsListByResourceGroup

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

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

Example Usage: CosmosDBClient.DatabaseAccountsListConnectionStrings

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

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

Example Usage: CosmosDBClient.DatabaseAccountsListKeys

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

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

Example Usage: CosmosDBClient.DatabaseAccountsListMetricDefinitions

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

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

Example Usage: CosmosDBClient.DatabaseAccountsListMetrics

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

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

Example Usage: CosmosDBClient.DatabaseAccountsListReadOnlyKeys

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

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

Example Usage: CosmosDBClient.DatabaseAccountsListUsages

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

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

Example Usage: CosmosDBClient.DatabaseAccountsOfflineRegion

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

payload := cosmosdb.RegionForOnlineOffline{
	// ...
}


if err := client.DatabaseAccountsOfflineRegionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsOnlineRegion

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

payload := cosmosdb.RegionForOnlineOffline{
	// ...
}


if err := client.DatabaseAccountsOnlineRegionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsRegenerateKey

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

payload := cosmosdb.DatabaseAccountRegenerateKeyParameters{
	// ...
}


if err := client.DatabaseAccountsRegenerateKeyThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseAccountsUpdate

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

payload := cosmosdb.DatabaseAccountUpdateParameters{
	// ...
}


if err := client.DatabaseAccountsUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.DatabaseListMetricDefinitions

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

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

Example Usage: CosmosDBClient.DatabaseListMetrics

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

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

Example Usage: CosmosDBClient.DatabaseListUsages

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

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

Example Usage: CosmosDBClient.GremlinResourcesCreateUpdateGremlinDatabase

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

payload := cosmosdb.GremlinDatabaseCreateUpdateParameters{
	// ...
}


if err := client.GremlinResourcesCreateUpdateGremlinDatabaseThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesCreateUpdateGremlinGraph

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

payload := cosmosdb.GremlinGraphCreateUpdateParameters{
	// ...
}


if err := client.GremlinResourcesCreateUpdateGremlinGraphThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesDeleteGremlinDatabase

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

if err := client.GremlinResourcesDeleteGremlinDatabaseThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesDeleteGremlinGraph

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

if err := client.GremlinResourcesDeleteGremlinGraphThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinDatabase

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

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

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinDatabaseThroughput

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

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

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinGraph

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

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

Example Usage: CosmosDBClient.GremlinResourcesGetGremlinGraphThroughput

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

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

Example Usage: CosmosDBClient.GremlinResourcesListGremlinDatabases

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

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

Example Usage: CosmosDBClient.GremlinResourcesListGremlinGraphs

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

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

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinDatabaseToAutoscale

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

if err := client.GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinDatabaseToManualThroughput

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

if err := client.GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinGraphToAutoscale

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

if err := client.GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesMigrateGremlinGraphToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

if err := client.GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesUpdateGremlinDatabaseThroughput

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

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.GremlinResourcesUpdateGremlinGraphThroughput

ctx := context.TODO()
id := cosmosdb.NewGraphID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "graphValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.GremlinResourcesUpdateGremlinGraphThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.LocationsGet

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

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

Example Usage: CosmosDBClient.LocationsList

ctx := context.TODO()
id := cosmosdb.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

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

Example Usage: CosmosDBClient.MongoDBResourcesCreateUpdateMongoDBCollection

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

payload := cosmosdb.MongoDBCollectionCreateUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesCreateUpdateMongoDBDatabase

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

payload := cosmosdb.MongoDBDatabaseCreateUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesDeleteMongoDBCollection

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

if err := client.MongoDBResourcesDeleteMongoDBCollectionThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesDeleteMongoDBDatabase

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

if err := client.MongoDBResourcesDeleteMongoDBDatabaseThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBCollection

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

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

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBCollectionThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

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

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBDatabase

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

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

Example Usage: CosmosDBClient.MongoDBResourcesGetMongoDBDatabaseThroughput

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

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

Example Usage: CosmosDBClient.MongoDBResourcesListMongoDBCollections

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

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

Example Usage: CosmosDBClient.MongoDBResourcesListMongoDBDatabases

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

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

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBCollectionToAutoscale

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

if err := client.MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBCollectionToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

if err := client.MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBDatabaseToAutoscale

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

if err := client.MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput

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

if err := client.MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesUpdateMongoDBCollectionThroughput

ctx := context.TODO()
id := cosmosdb.NewMongodbDatabaseCollectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "collectionValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.MongoDBResourcesUpdateMongoDBDatabaseThroughput

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

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.PartitionKeyRangeIdListMetrics

ctx := context.TODO()
id := cosmosdb.NewPartitionKeyRangeIdID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseRidValue", "collectionRidValue", "partitionKeyRangeIdValue")

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

Example Usage: CosmosDBClient.PartitionKeyRangeIdRegionListMetrics

ctx := context.TODO()
id := cosmosdb.NewCollectionPartitionKeyRangeIdID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "regionValue", "databaseRidValue", "collectionRidValue", "partitionKeyRangeIdValue")

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

Example Usage: CosmosDBClient.PercentileListMetrics

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

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

Example Usage: CosmosDBClient.PercentileSourceTargetListMetrics

ctx := context.TODO()
id := cosmosdb.NewSourceRegionTargetRegionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "sourceRegionValue", "targetRegionValue")

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

Example Usage: CosmosDBClient.PercentileTargetListMetrics

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

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

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlContainer

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

payload := cosmosdb.SqlContainerCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlContainerThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlDatabase

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

payload := cosmosdb.SqlDatabaseCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlDatabaseThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlStoredProcedure

ctx := context.TODO()
id := cosmosdb.NewStoredProcedureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "storedProcedureValue")

payload := cosmosdb.SqlStoredProcedureCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlStoredProcedureThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlTrigger

ctx := context.TODO()
id := cosmosdb.NewTriggerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "triggerValue")

payload := cosmosdb.SqlTriggerCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlTriggerThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesCreateUpdateSqlUserDefinedFunction

ctx := context.TODO()
id := cosmosdb.NewUserDefinedFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "userDefinedFunctionValue")

payload := cosmosdb.SqlUserDefinedFunctionCreateUpdateParameters{
	// ...
}


if err := client.SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlContainer

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

if err := client.SqlResourcesDeleteSqlContainerThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlDatabase

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

if err := client.SqlResourcesDeleteSqlDatabaseThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlStoredProcedure

ctx := context.TODO()
id := cosmosdb.NewStoredProcedureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "storedProcedureValue")

if err := client.SqlResourcesDeleteSqlStoredProcedureThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlTrigger

ctx := context.TODO()
id := cosmosdb.NewTriggerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "triggerValue")

if err := client.SqlResourcesDeleteSqlTriggerThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesDeleteSqlUserDefinedFunction

ctx := context.TODO()
id := cosmosdb.NewUserDefinedFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "userDefinedFunctionValue")

if err := client.SqlResourcesDeleteSqlUserDefinedFunctionThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesGetSqlContainer

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

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

Example Usage: CosmosDBClient.SqlResourcesGetSqlContainerThroughput

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

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

Example Usage: CosmosDBClient.SqlResourcesGetSqlDatabase

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

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

Example Usage: CosmosDBClient.SqlResourcesGetSqlDatabaseThroughput

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

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

Example Usage: CosmosDBClient.SqlResourcesGetSqlStoredProcedure

ctx := context.TODO()
id := cosmosdb.NewStoredProcedureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "storedProcedureValue")

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

Example Usage: CosmosDBClient.SqlResourcesGetSqlTrigger

ctx := context.TODO()
id := cosmosdb.NewTriggerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "triggerValue")

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

Example Usage: CosmosDBClient.SqlResourcesGetSqlUserDefinedFunction

ctx := context.TODO()
id := cosmosdb.NewUserDefinedFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue", "userDefinedFunctionValue")

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

Example Usage: CosmosDBClient.SqlResourcesListSqlContainers

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

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

Example Usage: CosmosDBClient.SqlResourcesListSqlDatabases

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

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

Example Usage: CosmosDBClient.SqlResourcesListSqlStoredProcedures

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

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

Example Usage: CosmosDBClient.SqlResourcesListSqlTriggers

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

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

Example Usage: CosmosDBClient.SqlResourcesListSqlUserDefinedFunctions

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

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

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlContainerToAutoscale

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

if err := client.SqlResourcesMigrateSqlContainerToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlContainerToManualThroughput

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

if err := client.SqlResourcesMigrateSqlContainerToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlDatabaseToAutoscale

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

if err := client.SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesMigrateSqlDatabaseToManualThroughput

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

if err := client.SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesUpdateSqlContainerThroughput

ctx := context.TODO()
id := cosmosdb.NewContainerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "accountValue", "databaseValue", "containerValue")

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.SqlResourcesUpdateSqlContainerThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.SqlResourcesUpdateSqlDatabaseThroughput

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

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.SqlResourcesUpdateSqlDatabaseThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesCreateUpdateTable

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

payload := cosmosdb.TableCreateUpdateParameters{
	// ...
}


if err := client.TableResourcesCreateUpdateTableThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesDeleteTable

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

if err := client.TableResourcesDeleteTableThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesGetTable

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

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

Example Usage: CosmosDBClient.TableResourcesGetTableThroughput

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

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

Example Usage: CosmosDBClient.TableResourcesListTables

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

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

Example Usage: CosmosDBClient.TableResourcesMigrateTableToAutoscale

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

if err := client.TableResourcesMigrateTableToAutoscaleThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesMigrateTableToManualThroughput

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

if err := client.TableResourcesMigrateTableToManualThroughputThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: CosmosDBClient.TableResourcesUpdateTableThroughput

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

payload := cosmosdb.ThroughputSettingsUpdateParameters{
	// ...
}


if err := client.TableResourcesUpdateTableThroughputThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func PossibleValuesForAnalyticalStorageSchemaType ¶ 

func PossibleValuesForAnalyticalStorageSchemaType() []string

func PossibleValuesForBackupPolicyMigrationStatus ¶ 

func PossibleValuesForBackupPolicyMigrationStatus() []string

func PossibleValuesForBackupPolicyType ¶ 

func PossibleValuesForBackupPolicyType() []string

func PossibleValuesForBackupStorageRedundancy ¶ 

func PossibleValuesForBackupStorageRedundancy() []string

func PossibleValuesForCompositePathSortOrder ¶ 

func PossibleValuesForCompositePathSortOrder() []string

func PossibleValuesForConflictResolutionMode ¶ 

func PossibleValuesForConflictResolutionMode() []string

func PossibleValuesForConnectorOffer ¶ 

func PossibleValuesForConnectorOffer() []string

func PossibleValuesForCreateMode ¶ 

func PossibleValuesForCreateMode() []string

func PossibleValuesForDataType ¶ 

func PossibleValuesForDataType() []string

func PossibleValuesForDatabaseAccountKind ¶ 

func PossibleValuesForDatabaseAccountKind() []string

func PossibleValuesForDatabaseAccountOfferType ¶ 

func PossibleValuesForDatabaseAccountOfferType() []string

func PossibleValuesForDefaultConsistencyLevel ¶ 

func PossibleValuesForDefaultConsistencyLevel() []string

func PossibleValuesForIndexKind ¶ 

func PossibleValuesForIndexKind() []string

func PossibleValuesForIndexingMode ¶ 

func PossibleValuesForIndexingMode() []string

func PossibleValuesForKeyKind ¶ 

func PossibleValuesForKeyKind() []string

func PossibleValuesForNetworkAclBypass ¶ 

func PossibleValuesForNetworkAclBypass() []string

func PossibleValuesForPartitionKind ¶ 

func PossibleValuesForPartitionKind() []string

func PossibleValuesForPrimaryAggregationType ¶ 

func PossibleValuesForPrimaryAggregationType() []string

func PossibleValuesForPublicNetworkAccess ¶ 

func PossibleValuesForPublicNetworkAccess() []string

func PossibleValuesForRestoreMode ¶ 

func PossibleValuesForRestoreMode() []string

func PossibleValuesForServerVersion ¶ 

func PossibleValuesForServerVersion() []string

func PossibleValuesForSpatialType ¶ 

func PossibleValuesForSpatialType() []string

func PossibleValuesForTriggerOperation ¶ 

func PossibleValuesForTriggerOperation() []string

func PossibleValuesForTriggerType ¶ 

func PossibleValuesForTriggerType() []string

func PossibleValuesForUnitType ¶ 

func PossibleValuesForUnitType() []string

func ValidateCassandraKeyspaceID ¶ 

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

ValidateCassandraKeyspaceID checks that 'input' can be parsed as a Cassandra Keyspace ID

func ValidateCassandraKeyspaceTableID ¶ 

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

ValidateCassandraKeyspaceTableID checks that 'input' can be parsed as a Cassandra Keyspace Table ID

func ValidateCollectionID ¶ 

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

ValidateCollectionID checks that 'input' can be parsed as a Collection ID

func ValidateCollectionPartitionKeyRangeIdID ¶ 

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

ValidateCollectionPartitionKeyRangeIdID checks that 'input' can be parsed as a Collection Partition Key Range Id ID

func ValidateContainerID ¶ 

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

ValidateContainerID checks that 'input' can be parsed as a Container ID

func ValidateDatabaseAccountID ¶ 

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

ValidateDatabaseAccountID checks that 'input' can be parsed as a Database Account ID

func ValidateDatabaseAccountNameID ¶ 

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

ValidateDatabaseAccountNameID checks that 'input' can be parsed as a Database Account Name ID

func ValidateDatabaseCollectionID ¶ 

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

ValidateDatabaseCollectionID checks that 'input' can be parsed as a Database Collection ID

func ValidateDatabaseID ¶ 

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

ValidateDatabaseID checks that 'input' can be parsed as a Database ID

func ValidateGraphID ¶ 

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

ValidateGraphID checks that 'input' can be parsed as a Graph ID

func ValidateGremlinDatabaseID ¶ 

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

ValidateGremlinDatabaseID checks that 'input' can be parsed as a Gremlin Database 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 ValidateMongodbDatabaseCollectionID ¶ 

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

ValidateMongodbDatabaseCollectionID checks that 'input' can be parsed as a Mongodb Database Collection ID

func ValidateMongodbDatabaseID ¶ 

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

ValidateMongodbDatabaseID checks that 'input' can be parsed as a Mongodb Database ID

func ValidatePartitionKeyRangeIdID ¶ 

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

ValidatePartitionKeyRangeIdID checks that 'input' can be parsed as a Partition Key Range Id ID

func ValidateRegionID ¶ 

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

ValidateRegionID checks that 'input' can be parsed as a Region ID

func ValidateSourceRegionTargetRegionID ¶ 

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

ValidateSourceRegionTargetRegionID checks that 'input' can be parsed as a Source Region Target Region ID

func ValidateSqlDatabaseID ¶ 

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

ValidateSqlDatabaseID checks that 'input' can be parsed as a Sql Database ID

func ValidateStoredProcedureID ¶ 

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

ValidateStoredProcedureID checks that 'input' can be parsed as a Stored Procedure ID

func ValidateTableID ¶ 

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

ValidateTableID checks that 'input' can be parsed as a Table ID

func ValidateTargetRegionID ¶ 

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

ValidateTargetRegionID checks that 'input' can be parsed as a Target Region ID

func ValidateTriggerID ¶ 

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

ValidateTriggerID checks that 'input' can be parsed as a Trigger ID

func ValidateUserDefinedFunctionID ¶ 

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

ValidateUserDefinedFunctionID checks that 'input' can be parsed as a User Defined Function ID

Types ¶

type AccountKeyMetadata ¶ 

type AccountKeyMetadata struct {
	GenerationTime *string `json:"generationTime,omitempty"`
}

func (*AccountKeyMetadata) GetGenerationTimeAsTime ¶ 

func (o *AccountKeyMetadata) GetGenerationTimeAsTime() (*time.Time, error)

func (*AccountKeyMetadata) SetGenerationTimeAsTime ¶ 

func (o *AccountKeyMetadata) SetGenerationTimeAsTime(input time.Time)

type AnalyticalStorageConfiguration ¶ 

type AnalyticalStorageConfiguration struct {
	SchemaType *AnalyticalStorageSchemaType `json:"schemaType,omitempty"`
}

type AnalyticalStorageSchemaType ¶ 

type AnalyticalStorageSchemaType string
const (
	AnalyticalStorageSchemaTypeFullFidelity AnalyticalStorageSchemaType = "FullFidelity"
	AnalyticalStorageSchemaTypeWellDefined  AnalyticalStorageSchemaType = "WellDefined"
)

type ApiProperties ¶ 

type ApiProperties struct {
	ServerVersion *ServerVersion `json:"serverVersion,omitempty"`
}

type AutoScaleSettings ¶ 

type AutoScaleSettings struct {
	MaxThroughput *int64 `json:"maxThroughput,omitempty"`
}

type AutoUpgradePolicyResource ¶ 

type AutoUpgradePolicyResource struct {
	ThroughputPolicy *ThroughputPolicyResource `json:"throughputPolicy,omitempty"`
}

type AutoscaleSettingsResource ¶ 

type AutoscaleSettingsResource struct {
	AutoUpgradePolicy   *AutoUpgradePolicyResource `json:"autoUpgradePolicy,omitempty"`
	MaxThroughput       int64                      `json:"maxThroughput"`
	TargetMaxThroughput *int64                     `json:"targetMaxThroughput,omitempty"`
}

type BackupPolicy ¶ 

type BackupPolicy interface {
}

type BackupPolicyMigrationState ¶ 

type BackupPolicyMigrationState struct {
	StartTime  *string                      `json:"startTime,omitempty"`
	Status     *BackupPolicyMigrationStatus `json:"status,omitempty"`
	TargetType *BackupPolicyType            `json:"targetType,omitempty"`
}

func (*BackupPolicyMigrationState) GetStartTimeAsTime ¶ 

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

func (*BackupPolicyMigrationState) SetStartTimeAsTime ¶ 

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

type BackupPolicyMigrationStatus ¶ 

type BackupPolicyMigrationStatus string
const (
	BackupPolicyMigrationStatusCompleted  BackupPolicyMigrationStatus = "Completed"
	BackupPolicyMigrationStatusFailed     BackupPolicyMigrationStatus = "Failed"
	BackupPolicyMigrationStatusInProgress BackupPolicyMigrationStatus = "InProgress"
	BackupPolicyMigrationStatusInvalid    BackupPolicyMigrationStatus = "Invalid"
)

type BackupPolicyType ¶ 

type BackupPolicyType string
const (
	BackupPolicyTypeContinuous BackupPolicyType = "Continuous"
	BackupPolicyTypePeriodic   BackupPolicyType = "Periodic"
)

type BackupStorageRedundancy ¶ 

type BackupStorageRedundancy string
const (
	BackupStorageRedundancyGeo   BackupStorageRedundancy = "Geo"
	BackupStorageRedundancyLocal BackupStorageRedundancy = "Local"
	BackupStorageRedundancyZone  BackupStorageRedundancy = "Zone"
)

type Capability ¶ 

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

type Capacity ¶ 

type Capacity struct {
	TotalThroughputLimit *int64 `json:"totalThroughputLimit,omitempty"`
}

type CassandraKeyspaceCreateUpdateParameters ¶ 

type CassandraKeyspaceCreateUpdateParameters struct {
	Id         *string                                 `json:"id,omitempty"`
	Location   *string                                 `json:"location,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties CassandraKeyspaceCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                      `json:"tags,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type CassandraKeyspaceCreateUpdateProperties ¶ 

type CassandraKeyspaceCreateUpdateProperties struct {
	Options  *CreateUpdateOptions      `json:"options,omitempty"`
	Resource CassandraKeyspaceResource `json:"resource"`
}

type CassandraKeyspaceGetProperties ¶ 

type CassandraKeyspaceGetProperties struct {
	Options  *OptionsResource                `json:"options,omitempty"`
	Resource *CassandraKeyspaceGetProperties `json:"resource,omitempty"`
}

type CassandraKeyspaceGetResults ¶ 

type CassandraKeyspaceGetResults struct {
	Id         *string                         `json:"id,omitempty"`
	Location   *string                         `json:"location,omitempty"`
	Name       *string                         `json:"name,omitempty"`
	Properties *CassandraKeyspaceGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string              `json:"tags,omitempty"`
	Type       *string                         `json:"type,omitempty"`
}

type CassandraKeyspaceId ¶ 

type CassandraKeyspaceId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	KeyspaceName      string
}

CassandraKeyspaceId is a struct representing the Resource ID for a Cassandra Keyspace

func NewCassandraKeyspaceID ¶ 

func NewCassandraKeyspaceID(subscriptionId string, resourceGroupName string, accountName string, keyspaceName string) CassandraKeyspaceId

NewCassandraKeyspaceID returns a new CassandraKeyspaceId struct

func ParseCassandraKeyspaceID ¶ 

func ParseCassandraKeyspaceID(input string) (*CassandraKeyspaceId, error)

ParseCassandraKeyspaceID parses 'input' into a CassandraKeyspaceId

func ParseCassandraKeyspaceIDInsensitively ¶ 

func ParseCassandraKeyspaceIDInsensitively(input string) (*CassandraKeyspaceId, error)

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

func (CassandraKeyspaceId) ID ¶ 

func (id CassandraKeyspaceId) ID() string

ID returns the formatted Cassandra Keyspace ID

func (CassandraKeyspaceId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Cassandra Keyspace ID

func (CassandraKeyspaceId) String ¶ 

func (id CassandraKeyspaceId) String() string

String returns a human-readable description of this Cassandra Keyspace ID

type CassandraKeyspaceListResult ¶ 

type CassandraKeyspaceListResult struct {
	Value *[]CassandraKeyspaceGetResults `json:"value,omitempty"`
}

type CassandraKeyspaceResource ¶ 

type CassandraKeyspaceResource struct {
	Id string `json:"id"`
}

type CassandraKeyspaceTableId ¶ 

type CassandraKeyspaceTableId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	KeyspaceName      string
	TableName         string
}

CassandraKeyspaceTableId is a struct representing the Resource ID for a Cassandra Keyspace Table

func NewCassandraKeyspaceTableID ¶ 

func NewCassandraKeyspaceTableID(subscriptionId string, resourceGroupName string, accountName string, keyspaceName string, tableName string) CassandraKeyspaceTableId

NewCassandraKeyspaceTableID returns a new CassandraKeyspaceTableId struct

func ParseCassandraKeyspaceTableID ¶ 

func ParseCassandraKeyspaceTableID(input string) (*CassandraKeyspaceTableId, error)

ParseCassandraKeyspaceTableID parses 'input' into a CassandraKeyspaceTableId

func ParseCassandraKeyspaceTableIDInsensitively ¶ 

func ParseCassandraKeyspaceTableIDInsensitively(input string) (*CassandraKeyspaceTableId, error)

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

func (CassandraKeyspaceTableId) ID ¶ 

func (id CassandraKeyspaceTableId) ID() string

ID returns the formatted Cassandra Keyspace Table ID

func (CassandraKeyspaceTableId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Cassandra Keyspace Table ID

func (CassandraKeyspaceTableId) String ¶ 

func (id CassandraKeyspaceTableId) String() string

String returns a human-readable description of this Cassandra Keyspace Table ID

type CassandraPartitionKey ¶ 

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

type CassandraResourcesCreateUpdateCassandraKeyspaceOperationResponse ¶ 

type CassandraResourcesCreateUpdateCassandraKeyspaceOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesCreateUpdateCassandraTableOperationResponse ¶ 

type CassandraResourcesCreateUpdateCassandraTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesDeleteCassandraKeyspaceOperationResponse ¶ 

type CassandraResourcesDeleteCassandraKeyspaceOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesDeleteCassandraTableOperationResponse ¶ 

type CassandraResourcesDeleteCassandraTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesGetCassandraKeyspaceOperationResponse ¶ 

type CassandraResourcesGetCassandraKeyspaceOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraKeyspaceGetResults
}

type CassandraResourcesGetCassandraKeyspaceThroughputOperationResponse ¶ 

type CassandraResourcesGetCassandraKeyspaceThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type CassandraResourcesGetCassandraTableOperationResponse ¶ 

type CassandraResourcesGetCassandraTableOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraTableGetResults
}

type CassandraResourcesGetCassandraTableThroughputOperationResponse ¶ 

type CassandraResourcesGetCassandraTableThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type CassandraResourcesListCassandraKeyspacesOperationResponse ¶ 

type CassandraResourcesListCassandraKeyspacesOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraKeyspaceListResult
}

type CassandraResourcesListCassandraTablesOperationResponse ¶ 

type CassandraResourcesListCassandraTablesOperationResponse struct {
	HttpResponse *http.Response
	Model        *CassandraTableListResult
}

type CassandraResourcesMigrateCassandraKeyspaceToAutoscaleOperationResponse ¶ 

type CassandraResourcesMigrateCassandraKeyspaceToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesMigrateCassandraKeyspaceToManualThroughputOperationResponse ¶ 

type CassandraResourcesMigrateCassandraKeyspaceToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesMigrateCassandraTableToAutoscaleOperationResponse ¶ 

type CassandraResourcesMigrateCassandraTableToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesMigrateCassandraTableToManualThroughputOperationResponse ¶ 

type CassandraResourcesMigrateCassandraTableToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesUpdateCassandraKeyspaceThroughputOperationResponse ¶ 

type CassandraResourcesUpdateCassandraKeyspaceThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraResourcesUpdateCassandraTableThroughputOperationResponse ¶ 

type CassandraResourcesUpdateCassandraTableThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type CassandraSchema ¶ 

type CassandraSchema struct {
	ClusterKeys   *[]ClusterKey            `json:"clusterKeys,omitempty"`
	Columns       *[]Column                `json:"columns,omitempty"`
	PartitionKeys *[]CassandraPartitionKey `json:"partitionKeys,omitempty"`
}

type CassandraTableCreateUpdateParameters ¶ 

type CassandraTableCreateUpdateParameters struct {
	Id         *string                              `json:"id,omitempty"`
	Location   *string                              `json:"location,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties CassandraTableCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                   `json:"tags,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type CassandraTableCreateUpdateProperties ¶ 

type CassandraTableCreateUpdateProperties struct {
	Options  *CreateUpdateOptions   `json:"options,omitempty"`
	Resource CassandraTableResource `json:"resource"`
}

type CassandraTableGetProperties ¶ 

type CassandraTableGetProperties struct {
	Options  *OptionsResource             `json:"options,omitempty"`
	Resource *CassandraTableGetProperties `json:"resource,omitempty"`
}

type CassandraTableGetResults ¶ 

type CassandraTableGetResults struct {
	Id         *string                      `json:"id,omitempty"`
	Location   *string                      `json:"location,omitempty"`
	Name       *string                      `json:"name,omitempty"`
	Properties *CassandraTableGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string           `json:"tags,omitempty"`
	Type       *string                      `json:"type,omitempty"`
}

type CassandraTableListResult ¶ 

type CassandraTableListResult struct {
	Value *[]CassandraTableGetResults `json:"value,omitempty"`
}

type CassandraTableResource ¶ 

type CassandraTableResource struct {
	AnalyticalStorageTtl *int64           `json:"analyticalStorageTtl,omitempty"`
	DefaultTtl           *int64           `json:"defaultTtl,omitempty"`
	Id                   string           `json:"id"`
	Schema               *CassandraSchema `json:"schema,omitempty"`
}

type ClusterKey ¶ 

type ClusterKey struct {
	Name    *string `json:"name,omitempty"`
	OrderBy *string `json:"orderBy,omitempty"`
}

type CollectionId ¶ 

type CollectionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseRid       string
	CollectionRid     string
}

CollectionId is a struct representing the Resource ID for a Collection

func NewCollectionID ¶ 

func NewCollectionID(subscriptionId string, resourceGroupName string, accountName string, databaseRid string, collectionRid string) CollectionId

NewCollectionID returns a new CollectionId struct

func ParseCollectionID ¶ 

func ParseCollectionID(input string) (*CollectionId, error)

ParseCollectionID parses 'input' into a CollectionId

func ParseCollectionIDInsensitively ¶ 

func ParseCollectionIDInsensitively(input string) (*CollectionId, error)

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

func (CollectionId) ID ¶ 

func (id CollectionId) ID() string

ID returns the formatted Collection ID

func (CollectionId) Segments ¶ 

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

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

func (CollectionId) String ¶ 

func (id CollectionId) String() string

String returns a human-readable description of this Collection ID

type CollectionListMetricDefinitionsOperationResponse ¶ 

type CollectionListMetricDefinitionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricDefinitionsListResult
}

type CollectionListMetricsOperationOptions ¶ 

type CollectionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionListMetricsOperationOptions ¶ 

func DefaultCollectionListMetricsOperationOptions() CollectionListMetricsOperationOptions

type CollectionListMetricsOperationResponse ¶ 

type CollectionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type CollectionListUsagesOperationOptions ¶ 

type CollectionListUsagesOperationOptions struct {
	Filter *string
}

func DefaultCollectionListUsagesOperationOptions ¶ 

func DefaultCollectionListUsagesOperationOptions() CollectionListUsagesOperationOptions

type CollectionListUsagesOperationResponse ¶ 

type CollectionListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *UsagesResult
}

type CollectionPartitionKeyRangeIdId ¶ 

type CollectionPartitionKeyRangeIdId struct {
	SubscriptionId      string
	ResourceGroupName   string
	AccountName         string
	Region              string
	DatabaseRid         string
	CollectionRid       string
	PartitionKeyRangeId string
}

CollectionPartitionKeyRangeIdId is a struct representing the Resource ID for a Collection Partition Key Range Id

func NewCollectionPartitionKeyRangeIdID ¶ 

func NewCollectionPartitionKeyRangeIdID(subscriptionId string, resourceGroupName string, accountName string, region string, databaseRid string, collectionRid string, partitionKeyRangeId string) CollectionPartitionKeyRangeIdId

NewCollectionPartitionKeyRangeIdID returns a new CollectionPartitionKeyRangeIdId struct

func ParseCollectionPartitionKeyRangeIdID ¶ 

func ParseCollectionPartitionKeyRangeIdID(input string) (*CollectionPartitionKeyRangeIdId, error)

ParseCollectionPartitionKeyRangeIdID parses 'input' into a CollectionPartitionKeyRangeIdId

func ParseCollectionPartitionKeyRangeIdIDInsensitively ¶ 

func ParseCollectionPartitionKeyRangeIdIDInsensitively(input string) (*CollectionPartitionKeyRangeIdId, error)

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

func (CollectionPartitionKeyRangeIdId) ID ¶ 

func (id CollectionPartitionKeyRangeIdId) ID() string

ID returns the formatted Collection Partition Key Range Id ID

func (CollectionPartitionKeyRangeIdId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Collection Partition Key Range Id ID

func (CollectionPartitionKeyRangeIdId) String ¶ 

func (id CollectionPartitionKeyRangeIdId) String() string

String returns a human-readable description of this Collection Partition Key Range Id ID

type CollectionPartitionListMetricsOperationOptions ¶ 

type CollectionPartitionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionPartitionListMetricsOperationOptions ¶ 

func DefaultCollectionPartitionListMetricsOperationOptions() CollectionPartitionListMetricsOperationOptions

type CollectionPartitionListMetricsOperationResponse ¶ 

type CollectionPartitionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type CollectionPartitionListUsagesOperationOptions ¶ 

type CollectionPartitionListUsagesOperationOptions struct {
	Filter *string
}

func DefaultCollectionPartitionListUsagesOperationOptions ¶ 

func DefaultCollectionPartitionListUsagesOperationOptions() CollectionPartitionListUsagesOperationOptions

type CollectionPartitionListUsagesOperationResponse ¶ 

type CollectionPartitionListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionUsagesResult
}

type CollectionPartitionRegionListMetricsOperationOptions ¶ 

type CollectionPartitionRegionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionPartitionRegionListMetricsOperationOptions ¶ 

func DefaultCollectionPartitionRegionListMetricsOperationOptions() CollectionPartitionRegionListMetricsOperationOptions

type CollectionPartitionRegionListMetricsOperationResponse ¶ 

type CollectionPartitionRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type CollectionRegionListMetricsOperationOptions ¶ 

type CollectionRegionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultCollectionRegionListMetricsOperationOptions ¶ 

func DefaultCollectionRegionListMetricsOperationOptions() CollectionRegionListMetricsOperationOptions

type CollectionRegionListMetricsOperationResponse ¶ 

type CollectionRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type Column ¶ 

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

type CompositePath ¶ 

type CompositePath struct {
	Order *CompositePathSortOrder `json:"order,omitempty"`
	Path  *string                 `json:"path,omitempty"`
}

type CompositePathSortOrder ¶ 

type CompositePathSortOrder string
const (
	CompositePathSortOrderAscending  CompositePathSortOrder = "ascending"
	CompositePathSortOrderDescending CompositePathSortOrder = "descending"
)

type ConflictResolutionMode ¶ 

type ConflictResolutionMode string
const (
	ConflictResolutionModeCustom         ConflictResolutionMode = "Custom"
	ConflictResolutionModeLastWriterWins ConflictResolutionMode = "LastWriterWins"
)

type ConflictResolutionPolicy ¶ 

type ConflictResolutionPolicy struct {
	ConflictResolutionPath      *string                 `json:"conflictResolutionPath,omitempty"`
	ConflictResolutionProcedure *string                 `json:"conflictResolutionProcedure,omitempty"`
	Mode                        *ConflictResolutionMode `json:"mode,omitempty"`
}

type ConnectorOffer ¶ 

type ConnectorOffer string
const (
	ConnectorOfferSmall ConnectorOffer = "Small"
)

type ConsistencyPolicy ¶ 

type ConsistencyPolicy struct {
	DefaultConsistencyLevel DefaultConsistencyLevel `json:"defaultConsistencyLevel"`
	MaxIntervalInSeconds    *int64                  `json:"maxIntervalInSeconds,omitempty"`
	MaxStalenessPrefix      *int64                  `json:"maxStalenessPrefix,omitempty"`
}

type ContainerId ¶ 

type ContainerId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
	ContainerName     string
}

ContainerId is a struct representing the Resource ID for a Container

func NewContainerID ¶ 

func NewContainerID(subscriptionId string, resourceGroupName string, accountName string, databaseName string, containerName string) ContainerId

NewContainerID returns a new ContainerId struct

func ParseContainerID ¶ 

func ParseContainerID(input string) (*ContainerId, error)

ParseContainerID parses 'input' into a ContainerId

func ParseContainerIDInsensitively ¶ 

func ParseContainerIDInsensitively(input string) (*ContainerId, error)

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

func (ContainerId) ID ¶ 

func (id ContainerId) ID() string

ID returns the formatted Container ID

func (ContainerId) Segments ¶ 

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

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

func (ContainerId) String ¶ 

func (id ContainerId) String() string

String returns a human-readable description of this Container ID

type ContainerPartitionKey ¶ 

type ContainerPartitionKey struct {
	Kind      *PartitionKind `json:"kind,omitempty"`
	Paths     *[]string      `json:"paths,omitempty"`
	SystemKey *bool          `json:"systemKey,omitempty"`
	Version   *int64         `json:"version,omitempty"`
}

type ContinuousModeBackupPolicy ¶ 

type ContinuousModeBackupPolicy struct {

	// Fields inherited from BackupPolicy
	MigrationState *BackupPolicyMigrationState `json:"migrationState,omitempty"`
}

func (ContinuousModeBackupPolicy) MarshalJSON ¶ 

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

type CorsPolicy ¶ 

type CorsPolicy struct {
	AllowedHeaders  *string `json:"allowedHeaders,omitempty"`
	AllowedMethods  *string `json:"allowedMethods,omitempty"`
	AllowedOrigins  string  `json:"allowedOrigins"`
	ExposedHeaders  *string `json:"exposedHeaders,omitempty"`
	MaxAgeInSeconds *int64  `json:"maxAgeInSeconds,omitempty"`
}

type CosmosDBClient ¶ 

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

func NewCosmosDBClientWithBaseURI ¶ 

func NewCosmosDBClientWithBaseURI(endpoint string) CosmosDBClient

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspace ¶ 

func (c CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspace(ctx context.Context, id CassandraKeyspaceId, input CassandraKeyspaceCreateUpdateParameters) (result CassandraResourcesCreateUpdateCassandraKeyspaceOperationResponse, err error)

CassandraResourcesCreateUpdateCassandraKeyspace ...

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll(ctx context.Context, id CassandraKeyspaceId, input CassandraKeyspaceCreateUpdateParameters) error

CassandraResourcesCreateUpdateCassandraKeyspaceThenPoll performs CassandraResourcesCreateUpdateCassandraKeyspace then polls until it's completed

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraTable ¶ 

func (c CosmosDBClient) CassandraResourcesCreateUpdateCassandraTable(ctx context.Context, id CassandraKeyspaceTableId, input CassandraTableCreateUpdateParameters) (result CassandraResourcesCreateUpdateCassandraTableOperationResponse, err error)

CassandraResourcesCreateUpdateCassandraTable ...

func (CosmosDBClient) CassandraResourcesCreateUpdateCassandraTableThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesCreateUpdateCassandraTableThenPoll(ctx context.Context, id CassandraKeyspaceTableId, input CassandraTableCreateUpdateParameters) error

CassandraResourcesCreateUpdateCassandraTableThenPoll performs CassandraResourcesCreateUpdateCassandraTable then polls until it's completed

func (CosmosDBClient) CassandraResourcesDeleteCassandraKeyspace ¶ 

func (c CosmosDBClient) CassandraResourcesDeleteCassandraKeyspace(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesDeleteCassandraKeyspaceOperationResponse, err error)

CassandraResourcesDeleteCassandraKeyspace ...

func (CosmosDBClient) CassandraResourcesDeleteCassandraKeyspaceThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesDeleteCassandraKeyspaceThenPoll(ctx context.Context, id CassandraKeyspaceId) error

CassandraResourcesDeleteCassandraKeyspaceThenPoll performs CassandraResourcesDeleteCassandraKeyspace then polls until it's completed

func (CosmosDBClient) CassandraResourcesDeleteCassandraTable ¶ 

func (c CosmosDBClient) CassandraResourcesDeleteCassandraTable(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesDeleteCassandraTableOperationResponse, err error)

CassandraResourcesDeleteCassandraTable ...

func (CosmosDBClient) CassandraResourcesDeleteCassandraTableThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesDeleteCassandraTableThenPoll(ctx context.Context, id CassandraKeyspaceTableId) error

CassandraResourcesDeleteCassandraTableThenPoll performs CassandraResourcesDeleteCassandraTable then polls until it's completed

func (CosmosDBClient) CassandraResourcesGetCassandraKeyspace ¶ 

func (c CosmosDBClient) CassandraResourcesGetCassandraKeyspace(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesGetCassandraKeyspaceOperationResponse, err error)

CassandraResourcesGetCassandraKeyspace ...

func (CosmosDBClient) CassandraResourcesGetCassandraKeyspaceThroughput ¶ 

func (c CosmosDBClient) CassandraResourcesGetCassandraKeyspaceThroughput(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesGetCassandraKeyspaceThroughputOperationResponse, err error)

CassandraResourcesGetCassandraKeyspaceThroughput ...

func (CosmosDBClient) CassandraResourcesGetCassandraTable ¶ 

func (c CosmosDBClient) CassandraResourcesGetCassandraTable(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesGetCassandraTableOperationResponse, err error)

CassandraResourcesGetCassandraTable ...

func (CosmosDBClient) CassandraResourcesGetCassandraTableThroughput ¶ 

func (c CosmosDBClient) CassandraResourcesGetCassandraTableThroughput(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesGetCassandraTableThroughputOperationResponse, err error)

CassandraResourcesGetCassandraTableThroughput ...

func (CosmosDBClient) CassandraResourcesListCassandraKeyspaces ¶ 

func (c CosmosDBClient) CassandraResourcesListCassandraKeyspaces(ctx context.Context, id DatabaseAccountId) (result CassandraResourcesListCassandraKeyspacesOperationResponse, err error)

CassandraResourcesListCassandraKeyspaces ...

func (CosmosDBClient) CassandraResourcesListCassandraTables ¶ 

func (c CosmosDBClient) CassandraResourcesListCassandraTables(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesListCassandraTablesOperationResponse, err error)

CassandraResourcesListCassandraTables ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscale ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscale(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesMigrateCassandraKeyspaceToAutoscaleOperationResponse, err error)

CassandraResourcesMigrateCassandraKeyspaceToAutoscale ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll(ctx context.Context, id CassandraKeyspaceId) error

CassandraResourcesMigrateCassandraKeyspaceToAutoscaleThenPoll performs CassandraResourcesMigrateCassandraKeyspaceToAutoscale then polls until it's completed

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughput ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughput(ctx context.Context, id CassandraKeyspaceId) (result CassandraResourcesMigrateCassandraKeyspaceToManualThroughputOperationResponse, err error)

CassandraResourcesMigrateCassandraKeyspaceToManualThroughput ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll(ctx context.Context, id CassandraKeyspaceId) error

CassandraResourcesMigrateCassandraKeyspaceToManualThroughputThenPoll performs CassandraResourcesMigrateCassandraKeyspaceToManualThroughput then polls until it's completed

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscale ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscale(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesMigrateCassandraTableToAutoscaleOperationResponse, err error)

CassandraResourcesMigrateCassandraTableToAutoscale ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll(ctx context.Context, id CassandraKeyspaceTableId) error

CassandraResourcesMigrateCassandraTableToAutoscaleThenPoll performs CassandraResourcesMigrateCassandraTableToAutoscale then polls until it's completed

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughput ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughput(ctx context.Context, id CassandraKeyspaceTableId) (result CassandraResourcesMigrateCassandraTableToManualThroughputOperationResponse, err error)

CassandraResourcesMigrateCassandraTableToManualThroughput ...

func (CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll(ctx context.Context, id CassandraKeyspaceTableId) error

CassandraResourcesMigrateCassandraTableToManualThroughputThenPoll performs CassandraResourcesMigrateCassandraTableToManualThroughput then polls until it's completed

func (CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughput ¶ 

func (c CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughput(ctx context.Context, id CassandraKeyspaceId, input ThroughputSettingsUpdateParameters) (result CassandraResourcesUpdateCassandraKeyspaceThroughputOperationResponse, err error)

CassandraResourcesUpdateCassandraKeyspaceThroughput ...

func (CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll(ctx context.Context, id CassandraKeyspaceId, input ThroughputSettingsUpdateParameters) error

CassandraResourcesUpdateCassandraKeyspaceThroughputThenPoll performs CassandraResourcesUpdateCassandraKeyspaceThroughput then polls until it's completed

func (CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughput ¶ 

func (c CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughput(ctx context.Context, id CassandraKeyspaceTableId, input ThroughputSettingsUpdateParameters) (result CassandraResourcesUpdateCassandraTableThroughputOperationResponse, err error)

CassandraResourcesUpdateCassandraTableThroughput ...

func (CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughputThenPoll ¶ 

func (c CosmosDBClient) CassandraResourcesUpdateCassandraTableThroughputThenPoll(ctx context.Context, id CassandraKeyspaceTableId, input ThroughputSettingsUpdateParameters) error

CassandraResourcesUpdateCassandraTableThroughputThenPoll performs CassandraResourcesUpdateCassandraTableThroughput then polls until it's completed

func (CosmosDBClient) CollectionListMetricDefinitions ¶ 

func (c CosmosDBClient) CollectionListMetricDefinitions(ctx context.Context, id CollectionId) (result CollectionListMetricDefinitionsOperationResponse, err error)

CollectionListMetricDefinitions ...

func (CosmosDBClient) CollectionListMetrics ¶ 

func (c CosmosDBClient) CollectionListMetrics(ctx context.Context, id CollectionId, options CollectionListMetricsOperationOptions) (result CollectionListMetricsOperationResponse, err error)

CollectionListMetrics ...

func (CosmosDBClient) CollectionListUsages ¶ 

func (c CosmosDBClient) CollectionListUsages(ctx context.Context, id CollectionId, options CollectionListUsagesOperationOptions) (result CollectionListUsagesOperationResponse, err error)

CollectionListUsages ...

func (CosmosDBClient) CollectionPartitionListMetrics ¶ 

func (c CosmosDBClient) CollectionPartitionListMetrics(ctx context.Context, id CollectionId, options CollectionPartitionListMetricsOperationOptions) (result CollectionPartitionListMetricsOperationResponse, err error)

CollectionPartitionListMetrics ...

func (CosmosDBClient) CollectionPartitionListUsages ¶ 

func (c CosmosDBClient) CollectionPartitionListUsages(ctx context.Context, id CollectionId, options CollectionPartitionListUsagesOperationOptions) (result CollectionPartitionListUsagesOperationResponse, err error)

CollectionPartitionListUsages ...

func (CosmosDBClient) CollectionPartitionRegionListMetrics ¶ 

func (c CosmosDBClient) CollectionPartitionRegionListMetrics(ctx context.Context, id DatabaseCollectionId, options CollectionPartitionRegionListMetricsOperationOptions) (result CollectionPartitionRegionListMetricsOperationResponse, err error)

CollectionPartitionRegionListMetrics ...

func (CosmosDBClient) CollectionRegionListMetrics ¶ 

func (c CosmosDBClient) CollectionRegionListMetrics(ctx context.Context, id DatabaseCollectionId, options CollectionRegionListMetricsOperationOptions) (result CollectionRegionListMetricsOperationResponse, err error)

CollectionRegionListMetrics ...

func (CosmosDBClient) DatabaseAccountRegionListMetrics ¶ 

func (c CosmosDBClient) DatabaseAccountRegionListMetrics(ctx context.Context, id RegionId, options DatabaseAccountRegionListMetricsOperationOptions) (result DatabaseAccountRegionListMetricsOperationResponse, err error)

DatabaseAccountRegionListMetrics ...

func (CosmosDBClient) DatabaseAccountsCheckNameExists ¶ 

func (c CosmosDBClient) DatabaseAccountsCheckNameExists(ctx context.Context, id DatabaseAccountNameId) (result DatabaseAccountsCheckNameExistsOperationResponse, err error)

DatabaseAccountsCheckNameExists ...

func (CosmosDBClient) DatabaseAccountsCreateOrUpdate ¶ 

func (c CosmosDBClient) DatabaseAccountsCreateOrUpdate(ctx context.Context, id DatabaseAccountId, input DatabaseAccountCreateUpdateParameters) (result DatabaseAccountsCreateOrUpdateOperationResponse, err error)

DatabaseAccountsCreateOrUpdate ...

func (CosmosDBClient) DatabaseAccountsCreateOrUpdateThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsCreateOrUpdateThenPoll(ctx context.Context, id DatabaseAccountId, input DatabaseAccountCreateUpdateParameters) error

DatabaseAccountsCreateOrUpdateThenPoll performs DatabaseAccountsCreateOrUpdate then polls until it's completed

func (CosmosDBClient) DatabaseAccountsDelete ¶ 

func (c CosmosDBClient) DatabaseAccountsDelete(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsDeleteOperationResponse, err error)

DatabaseAccountsDelete ...

func (CosmosDBClient) DatabaseAccountsDeleteThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsDeleteThenPoll(ctx context.Context, id DatabaseAccountId) error

DatabaseAccountsDeleteThenPoll performs DatabaseAccountsDelete then polls until it's completed

func (CosmosDBClient) DatabaseAccountsFailoverPriorityChange ¶ 

func (c CosmosDBClient) DatabaseAccountsFailoverPriorityChange(ctx context.Context, id DatabaseAccountId, input FailoverPolicies) (result DatabaseAccountsFailoverPriorityChangeOperationResponse, err error)

DatabaseAccountsFailoverPriorityChange ...

func (CosmosDBClient) DatabaseAccountsFailoverPriorityChangeThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsFailoverPriorityChangeThenPoll(ctx context.Context, id DatabaseAccountId, input FailoverPolicies) error

DatabaseAccountsFailoverPriorityChangeThenPoll performs DatabaseAccountsFailoverPriorityChange then polls until it's completed

func (CosmosDBClient) DatabaseAccountsGet ¶ 

func (c CosmosDBClient) DatabaseAccountsGet(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsGetOperationResponse, err error)

DatabaseAccountsGet ...

func (CosmosDBClient) DatabaseAccountsGetReadOnlyKeys ¶ 

func (c CosmosDBClient) DatabaseAccountsGetReadOnlyKeys(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsGetReadOnlyKeysOperationResponse, err error)

DatabaseAccountsGetReadOnlyKeys ...

func (CosmosDBClient) DatabaseAccountsList ¶ 

func (c CosmosDBClient) DatabaseAccountsList(ctx context.Context, id commonids.SubscriptionId) (result DatabaseAccountsListOperationResponse, err error)

DatabaseAccountsList ...

func (CosmosDBClient) DatabaseAccountsListByResourceGroup ¶ 

func (c CosmosDBClient) DatabaseAccountsListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (result DatabaseAccountsListByResourceGroupOperationResponse, err error)

DatabaseAccountsListByResourceGroup ...

func (CosmosDBClient) DatabaseAccountsListConnectionStrings ¶ 

func (c CosmosDBClient) DatabaseAccountsListConnectionStrings(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListConnectionStringsOperationResponse, err error)

DatabaseAccountsListConnectionStrings ...

func (CosmosDBClient) DatabaseAccountsListKeys ¶ 

func (c CosmosDBClient) DatabaseAccountsListKeys(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListKeysOperationResponse, err error)

DatabaseAccountsListKeys ...

func (CosmosDBClient) DatabaseAccountsListMetricDefinitions ¶ 

func (c CosmosDBClient) DatabaseAccountsListMetricDefinitions(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListMetricDefinitionsOperationResponse, err error)

DatabaseAccountsListMetricDefinitions ...

func (CosmosDBClient) DatabaseAccountsListMetrics ¶ 

func (c CosmosDBClient) DatabaseAccountsListMetrics(ctx context.Context, id DatabaseAccountId, options DatabaseAccountsListMetricsOperationOptions) (result DatabaseAccountsListMetricsOperationResponse, err error)

DatabaseAccountsListMetrics ...

func (CosmosDBClient) DatabaseAccountsListReadOnlyKeys ¶ 

func (c CosmosDBClient) DatabaseAccountsListReadOnlyKeys(ctx context.Context, id DatabaseAccountId) (result DatabaseAccountsListReadOnlyKeysOperationResponse, err error)

DatabaseAccountsListReadOnlyKeys ...

func (CosmosDBClient) DatabaseAccountsListUsages ¶ 

func (c CosmosDBClient) DatabaseAccountsListUsages(ctx context.Context, id DatabaseAccountId, options DatabaseAccountsListUsagesOperationOptions) (result DatabaseAccountsListUsagesOperationResponse, err error)

DatabaseAccountsListUsages ...

func (CosmosDBClient) DatabaseAccountsOfflineRegion ¶ 

func (c CosmosDBClient) DatabaseAccountsOfflineRegion(ctx context.Context, id DatabaseAccountId, input RegionForOnlineOffline) (result DatabaseAccountsOfflineRegionOperationResponse, err error)

DatabaseAccountsOfflineRegion ...

func (CosmosDBClient) DatabaseAccountsOfflineRegionThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsOfflineRegionThenPoll(ctx context.Context, id DatabaseAccountId, input RegionForOnlineOffline) error

DatabaseAccountsOfflineRegionThenPoll performs DatabaseAccountsOfflineRegion then polls until it's completed

func (CosmosDBClient) DatabaseAccountsOnlineRegion ¶ 

func (c CosmosDBClient) DatabaseAccountsOnlineRegion(ctx context.Context, id DatabaseAccountId, input RegionForOnlineOffline) (result DatabaseAccountsOnlineRegionOperationResponse, err error)

DatabaseAccountsOnlineRegion ...

func (CosmosDBClient) DatabaseAccountsOnlineRegionThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsOnlineRegionThenPoll(ctx context.Context, id DatabaseAccountId, input RegionForOnlineOffline) error

DatabaseAccountsOnlineRegionThenPoll performs DatabaseAccountsOnlineRegion then polls until it's completed

func (CosmosDBClient) DatabaseAccountsRegenerateKey ¶ 

func (c CosmosDBClient) DatabaseAccountsRegenerateKey(ctx context.Context, id DatabaseAccountId, input DatabaseAccountRegenerateKeyParameters) (result DatabaseAccountsRegenerateKeyOperationResponse, err error)

DatabaseAccountsRegenerateKey ...

func (CosmosDBClient) DatabaseAccountsRegenerateKeyThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsRegenerateKeyThenPoll(ctx context.Context, id DatabaseAccountId, input DatabaseAccountRegenerateKeyParameters) error

DatabaseAccountsRegenerateKeyThenPoll performs DatabaseAccountsRegenerateKey then polls until it's completed

func (CosmosDBClient) DatabaseAccountsUpdate ¶ 

func (c CosmosDBClient) DatabaseAccountsUpdate(ctx context.Context, id DatabaseAccountId, input DatabaseAccountUpdateParameters) (result DatabaseAccountsUpdateOperationResponse, err error)

DatabaseAccountsUpdate ...

func (CosmosDBClient) DatabaseAccountsUpdateThenPoll ¶ 

func (c CosmosDBClient) DatabaseAccountsUpdateThenPoll(ctx context.Context, id DatabaseAccountId, input DatabaseAccountUpdateParameters) error

DatabaseAccountsUpdateThenPoll performs DatabaseAccountsUpdate then polls until it's completed

func (CosmosDBClient) DatabaseListMetricDefinitions ¶ 

func (c CosmosDBClient) DatabaseListMetricDefinitions(ctx context.Context, id DatabaseId) (result DatabaseListMetricDefinitionsOperationResponse, err error)

DatabaseListMetricDefinitions ...

func (CosmosDBClient) DatabaseListMetrics ¶ 

func (c CosmosDBClient) DatabaseListMetrics(ctx context.Context, id DatabaseId, options DatabaseListMetricsOperationOptions) (result DatabaseListMetricsOperationResponse, err error)

DatabaseListMetrics ...

func (CosmosDBClient) DatabaseListUsages ¶ 

func (c CosmosDBClient) DatabaseListUsages(ctx context.Context, id DatabaseId, options DatabaseListUsagesOperationOptions) (result DatabaseListUsagesOperationResponse, err error)

DatabaseListUsages ...

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabase ¶ 

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabase(ctx context.Context, id GremlinDatabaseId, input GremlinDatabaseCreateUpdateParameters) (result GremlinResourcesCreateUpdateGremlinDatabaseOperationResponse, err error)

GremlinResourcesCreateUpdateGremlinDatabase ...

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabaseThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinDatabaseThenPoll(ctx context.Context, id GremlinDatabaseId, input GremlinDatabaseCreateUpdateParameters) error

GremlinResourcesCreateUpdateGremlinDatabaseThenPoll performs GremlinResourcesCreateUpdateGremlinDatabase then polls until it's completed

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraph ¶ 

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraph(ctx context.Context, id GraphId, input GremlinGraphCreateUpdateParameters) (result GremlinResourcesCreateUpdateGremlinGraphOperationResponse, err error)

GremlinResourcesCreateUpdateGremlinGraph ...

func (CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraphThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesCreateUpdateGremlinGraphThenPoll(ctx context.Context, id GraphId, input GremlinGraphCreateUpdateParameters) error

GremlinResourcesCreateUpdateGremlinGraphThenPoll performs GremlinResourcesCreateUpdateGremlinGraph then polls until it's completed

func (CosmosDBClient) GremlinResourcesDeleteGremlinDatabase ¶ 

func (c CosmosDBClient) GremlinResourcesDeleteGremlinDatabase(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesDeleteGremlinDatabaseOperationResponse, err error)

GremlinResourcesDeleteGremlinDatabase ...

func (CosmosDBClient) GremlinResourcesDeleteGremlinDatabaseThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesDeleteGremlinDatabaseThenPoll(ctx context.Context, id GremlinDatabaseId) error

GremlinResourcesDeleteGremlinDatabaseThenPoll performs GremlinResourcesDeleteGremlinDatabase then polls until it's completed

func (CosmosDBClient) GremlinResourcesDeleteGremlinGraph ¶ 

func (c CosmosDBClient) GremlinResourcesDeleteGremlinGraph(ctx context.Context, id GraphId) (result GremlinResourcesDeleteGremlinGraphOperationResponse, err error)

GremlinResourcesDeleteGremlinGraph ...

func (CosmosDBClient) GremlinResourcesDeleteGremlinGraphThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesDeleteGremlinGraphThenPoll(ctx context.Context, id GraphId) error

GremlinResourcesDeleteGremlinGraphThenPoll performs GremlinResourcesDeleteGremlinGraph then polls until it's completed

func (CosmosDBClient) GremlinResourcesGetGremlinDatabase ¶ 

func (c CosmosDBClient) GremlinResourcesGetGremlinDatabase(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesGetGremlinDatabaseOperationResponse, err error)

GremlinResourcesGetGremlinDatabase ...

func (CosmosDBClient) GremlinResourcesGetGremlinDatabaseThroughput ¶ 

func (c CosmosDBClient) GremlinResourcesGetGremlinDatabaseThroughput(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesGetGremlinDatabaseThroughputOperationResponse, err error)

GremlinResourcesGetGremlinDatabaseThroughput ...

func (CosmosDBClient) GremlinResourcesGetGremlinGraph ¶ 

func (c CosmosDBClient) GremlinResourcesGetGremlinGraph(ctx context.Context, id GraphId) (result GremlinResourcesGetGremlinGraphOperationResponse, err error)

GremlinResourcesGetGremlinGraph ...

func (CosmosDBClient) GremlinResourcesGetGremlinGraphThroughput ¶ 

func (c CosmosDBClient) GremlinResourcesGetGremlinGraphThroughput(ctx context.Context, id GraphId) (result GremlinResourcesGetGremlinGraphThroughputOperationResponse, err error)

GremlinResourcesGetGremlinGraphThroughput ...

func (CosmosDBClient) GremlinResourcesListGremlinDatabases ¶ 

func (c CosmosDBClient) GremlinResourcesListGremlinDatabases(ctx context.Context, id DatabaseAccountId) (result GremlinResourcesListGremlinDatabasesOperationResponse, err error)

GremlinResourcesListGremlinDatabases ...

func (CosmosDBClient) GremlinResourcesListGremlinGraphs ¶ 

func (c CosmosDBClient) GremlinResourcesListGremlinGraphs(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesListGremlinGraphsOperationResponse, err error)

GremlinResourcesListGremlinGraphs ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscale ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscale(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesMigrateGremlinDatabaseToAutoscaleOperationResponse, err error)

GremlinResourcesMigrateGremlinDatabaseToAutoscale ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll(ctx context.Context, id GremlinDatabaseId) error

GremlinResourcesMigrateGremlinDatabaseToAutoscaleThenPoll performs GremlinResourcesMigrateGremlinDatabaseToAutoscale then polls until it's completed

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughput ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughput(ctx context.Context, id GremlinDatabaseId) (result GremlinResourcesMigrateGremlinDatabaseToManualThroughputOperationResponse, err error)

GremlinResourcesMigrateGremlinDatabaseToManualThroughput ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll(ctx context.Context, id GremlinDatabaseId) error

GremlinResourcesMigrateGremlinDatabaseToManualThroughputThenPoll performs GremlinResourcesMigrateGremlinDatabaseToManualThroughput then polls until it's completed

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscale ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscale(ctx context.Context, id GraphId) (result GremlinResourcesMigrateGremlinGraphToAutoscaleOperationResponse, err error)

GremlinResourcesMigrateGremlinGraphToAutoscale ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll(ctx context.Context, id GraphId) error

GremlinResourcesMigrateGremlinGraphToAutoscaleThenPoll performs GremlinResourcesMigrateGremlinGraphToAutoscale then polls until it's completed

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughput ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughput(ctx context.Context, id GraphId) (result GremlinResourcesMigrateGremlinGraphToManualThroughputOperationResponse, err error)

GremlinResourcesMigrateGremlinGraphToManualThroughput ...

func (CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll(ctx context.Context, id GraphId) error

GremlinResourcesMigrateGremlinGraphToManualThroughputThenPoll performs GremlinResourcesMigrateGremlinGraphToManualThroughput then polls until it's completed

func (CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughput ¶ 

func (c CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughput(ctx context.Context, id GremlinDatabaseId, input ThroughputSettingsUpdateParameters) (result GremlinResourcesUpdateGremlinDatabaseThroughputOperationResponse, err error)

GremlinResourcesUpdateGremlinDatabaseThroughput ...

func (CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll(ctx context.Context, id GremlinDatabaseId, input ThroughputSettingsUpdateParameters) error

GremlinResourcesUpdateGremlinDatabaseThroughputThenPoll performs GremlinResourcesUpdateGremlinDatabaseThroughput then polls until it's completed

func (CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughput ¶ 

func (c CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughput(ctx context.Context, id GraphId, input ThroughputSettingsUpdateParameters) (result GremlinResourcesUpdateGremlinGraphThroughputOperationResponse, err error)

GremlinResourcesUpdateGremlinGraphThroughput ...

func (CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughputThenPoll ¶ 

func (c CosmosDBClient) GremlinResourcesUpdateGremlinGraphThroughputThenPoll(ctx context.Context, id GraphId, input ThroughputSettingsUpdateParameters) error

GremlinResourcesUpdateGremlinGraphThroughputThenPoll performs GremlinResourcesUpdateGremlinGraphThroughput then polls until it's completed

func (CosmosDBClient) LocationsGet ¶ 

func (c CosmosDBClient) LocationsGet(ctx context.Context, id LocationId) (result LocationsGetOperationResponse, err error)

LocationsGet ...

func (CosmosDBClient) LocationsList ¶ 

func (c CosmosDBClient) LocationsList(ctx context.Context, id commonids.SubscriptionId) (result LocationsListOperationResponse, err error)

LocationsList ...

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollection ¶ 

func (c CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollection(ctx context.Context, id MongodbDatabaseCollectionId, input MongoDBCollectionCreateUpdateParameters) (result MongoDBResourcesCreateUpdateMongoDBCollectionOperationResponse, err error)

MongoDBResourcesCreateUpdateMongoDBCollection ...

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll(ctx context.Context, id MongodbDatabaseCollectionId, input MongoDBCollectionCreateUpdateParameters) error

MongoDBResourcesCreateUpdateMongoDBCollectionThenPoll performs MongoDBResourcesCreateUpdateMongoDBCollection then polls until it's completed

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabase ¶ 

func (c CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabase(ctx context.Context, id MongodbDatabaseId, input MongoDBDatabaseCreateUpdateParameters) (result MongoDBResourcesCreateUpdateMongoDBDatabaseOperationResponse, err error)

MongoDBResourcesCreateUpdateMongoDBDatabase ...

func (CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll(ctx context.Context, id MongodbDatabaseId, input MongoDBDatabaseCreateUpdateParameters) error

MongoDBResourcesCreateUpdateMongoDBDatabaseThenPoll performs MongoDBResourcesCreateUpdateMongoDBDatabase then polls until it's completed

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBCollection ¶ 

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBCollection(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesDeleteMongoDBCollectionOperationResponse, err error)

MongoDBResourcesDeleteMongoDBCollection ...

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBCollectionThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBCollectionThenPoll(ctx context.Context, id MongodbDatabaseCollectionId) error

MongoDBResourcesDeleteMongoDBCollectionThenPoll performs MongoDBResourcesDeleteMongoDBCollection then polls until it's completed

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabase ¶ 

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabase(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesDeleteMongoDBDatabaseOperationResponse, err error)

MongoDBResourcesDeleteMongoDBDatabase ...

func (CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabaseThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesDeleteMongoDBDatabaseThenPoll(ctx context.Context, id MongodbDatabaseId) error

MongoDBResourcesDeleteMongoDBDatabaseThenPoll performs MongoDBResourcesDeleteMongoDBDatabase then polls until it's completed

func (CosmosDBClient) MongoDBResourcesGetMongoDBCollection ¶ 

func (c CosmosDBClient) MongoDBResourcesGetMongoDBCollection(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesGetMongoDBCollectionOperationResponse, err error)

MongoDBResourcesGetMongoDBCollection ...

func (CosmosDBClient) MongoDBResourcesGetMongoDBCollectionThroughput ¶ 

func (c CosmosDBClient) MongoDBResourcesGetMongoDBCollectionThroughput(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesGetMongoDBCollectionThroughputOperationResponse, err error)

MongoDBResourcesGetMongoDBCollectionThroughput ...

func (CosmosDBClient) MongoDBResourcesGetMongoDBDatabase ¶ 

func (c CosmosDBClient) MongoDBResourcesGetMongoDBDatabase(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesGetMongoDBDatabaseOperationResponse, err error)

MongoDBResourcesGetMongoDBDatabase ...

func (CosmosDBClient) MongoDBResourcesGetMongoDBDatabaseThroughput ¶ 

func (c CosmosDBClient) MongoDBResourcesGetMongoDBDatabaseThroughput(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesGetMongoDBDatabaseThroughputOperationResponse, err error)

MongoDBResourcesGetMongoDBDatabaseThroughput ...

func (CosmosDBClient) MongoDBResourcesListMongoDBCollections ¶ 

func (c CosmosDBClient) MongoDBResourcesListMongoDBCollections(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesListMongoDBCollectionsOperationResponse, err error)

MongoDBResourcesListMongoDBCollections ...

func (CosmosDBClient) MongoDBResourcesListMongoDBDatabases ¶ 

func (c CosmosDBClient) MongoDBResourcesListMongoDBDatabases(ctx context.Context, id DatabaseAccountId) (result MongoDBResourcesListMongoDBDatabasesOperationResponse, err error)

MongoDBResourcesListMongoDBDatabases ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscale ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscale(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesMigrateMongoDBCollectionToAutoscaleOperationResponse, err error)

MongoDBResourcesMigrateMongoDBCollectionToAutoscale ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll(ctx context.Context, id MongodbDatabaseCollectionId) error

MongoDBResourcesMigrateMongoDBCollectionToAutoscaleThenPoll performs MongoDBResourcesMigrateMongoDBCollectionToAutoscale then polls until it's completed

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughput ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughput(ctx context.Context, id MongodbDatabaseCollectionId) (result MongoDBResourcesMigrateMongoDBCollectionToManualThroughputOperationResponse, err error)

MongoDBResourcesMigrateMongoDBCollectionToManualThroughput ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll(ctx context.Context, id MongodbDatabaseCollectionId) error

MongoDBResourcesMigrateMongoDBCollectionToManualThroughputThenPoll performs MongoDBResourcesMigrateMongoDBCollectionToManualThroughput then polls until it's completed

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscale ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscale(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleOperationResponse, err error)

MongoDBResourcesMigrateMongoDBDatabaseToAutoscale ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll(ctx context.Context, id MongodbDatabaseId) error

MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleThenPoll performs MongoDBResourcesMigrateMongoDBDatabaseToAutoscale then polls until it's completed

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput(ctx context.Context, id MongodbDatabaseId) (result MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputOperationResponse, err error)

MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput ...

func (CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll(ctx context.Context, id MongodbDatabaseId) error

MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputThenPoll performs MongoDBResourcesMigrateMongoDBDatabaseToManualThroughput then polls until it's completed

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughput ¶ 

func (c CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughput(ctx context.Context, id MongodbDatabaseCollectionId, input ThroughputSettingsUpdateParameters) (result MongoDBResourcesUpdateMongoDBCollectionThroughputOperationResponse, err error)

MongoDBResourcesUpdateMongoDBCollectionThroughput ...

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll(ctx context.Context, id MongodbDatabaseCollectionId, input ThroughputSettingsUpdateParameters) error

MongoDBResourcesUpdateMongoDBCollectionThroughputThenPoll performs MongoDBResourcesUpdateMongoDBCollectionThroughput then polls until it's completed

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughput ¶ 

func (c CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughput(ctx context.Context, id MongodbDatabaseId, input ThroughputSettingsUpdateParameters) (result MongoDBResourcesUpdateMongoDBDatabaseThroughputOperationResponse, err error)

MongoDBResourcesUpdateMongoDBDatabaseThroughput ...

func (CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll ¶ 

func (c CosmosDBClient) MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll(ctx context.Context, id MongodbDatabaseId, input ThroughputSettingsUpdateParameters) error

MongoDBResourcesUpdateMongoDBDatabaseThroughputThenPoll performs MongoDBResourcesUpdateMongoDBDatabaseThroughput then polls until it's completed

func (CosmosDBClient) PartitionKeyRangeIdListMetrics ¶ 

func (c CosmosDBClient) PartitionKeyRangeIdListMetrics(ctx context.Context, id PartitionKeyRangeIdId, options PartitionKeyRangeIdListMetricsOperationOptions) (result PartitionKeyRangeIdListMetricsOperationResponse, err error)

PartitionKeyRangeIdListMetrics ...

func (CosmosDBClient) PartitionKeyRangeIdRegionListMetrics ¶ 

func (c CosmosDBClient) PartitionKeyRangeIdRegionListMetrics(ctx context.Context, id CollectionPartitionKeyRangeIdId, options PartitionKeyRangeIdRegionListMetricsOperationOptions) (result PartitionKeyRangeIdRegionListMetricsOperationResponse, err error)

PartitionKeyRangeIdRegionListMetrics ...

func (CosmosDBClient) PercentileListMetrics ¶ 

func (c CosmosDBClient) PercentileListMetrics(ctx context.Context, id DatabaseAccountId, options PercentileListMetricsOperationOptions) (result PercentileListMetricsOperationResponse, err error)

PercentileListMetrics ...

func (CosmosDBClient) PercentileSourceTargetListMetrics ¶ 

func (c CosmosDBClient) PercentileSourceTargetListMetrics(ctx context.Context, id SourceRegionTargetRegionId, options PercentileSourceTargetListMetricsOperationOptions) (result PercentileSourceTargetListMetricsOperationResponse, err error)

PercentileSourceTargetListMetrics ...

func (CosmosDBClient) PercentileTargetListMetrics ¶ 

func (c CosmosDBClient) PercentileTargetListMetrics(ctx context.Context, id TargetRegionId, options PercentileTargetListMetricsOperationOptions) (result PercentileTargetListMetricsOperationResponse, err error)

PercentileTargetListMetrics ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlContainer ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlContainer(ctx context.Context, id ContainerId, input SqlContainerCreateUpdateParameters) (result SqlResourcesCreateUpdateSqlContainerOperationResponse, err error)

SqlResourcesCreateUpdateSqlContainer ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlContainerThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlContainerThenPoll(ctx context.Context, id ContainerId, input SqlContainerCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlContainerThenPoll performs SqlResourcesCreateUpdateSqlContainer then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlDatabase ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlDatabase(ctx context.Context, id SqlDatabaseId, input SqlDatabaseCreateUpdateParameters) (result SqlResourcesCreateUpdateSqlDatabaseOperationResponse, err error)

SqlResourcesCreateUpdateSqlDatabase ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlDatabaseThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlDatabaseThenPoll(ctx context.Context, id SqlDatabaseId, input SqlDatabaseCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlDatabaseThenPoll performs SqlResourcesCreateUpdateSqlDatabase then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedure ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedure(ctx context.Context, id StoredProcedureId, input SqlStoredProcedureCreateUpdateParameters) (result SqlResourcesCreateUpdateSqlStoredProcedureOperationResponse, err error)

SqlResourcesCreateUpdateSqlStoredProcedure ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedureThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlStoredProcedureThenPoll(ctx context.Context, id StoredProcedureId, input SqlStoredProcedureCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlStoredProcedureThenPoll performs SqlResourcesCreateUpdateSqlStoredProcedure then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlTrigger ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlTrigger(ctx context.Context, id TriggerId, input SqlTriggerCreateUpdateParameters) (result SqlResourcesCreateUpdateSqlTriggerOperationResponse, err error)

SqlResourcesCreateUpdateSqlTrigger ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlTriggerThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlTriggerThenPoll(ctx context.Context, id TriggerId, input SqlTriggerCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlTriggerThenPoll performs SqlResourcesCreateUpdateSqlTrigger then polls until it's completed

func (CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunction ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunction(ctx context.Context, id UserDefinedFunctionId, input SqlUserDefinedFunctionCreateUpdateParameters) (result SqlResourcesCreateUpdateSqlUserDefinedFunctionOperationResponse, err error)

SqlResourcesCreateUpdateSqlUserDefinedFunction ...

func (CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll(ctx context.Context, id UserDefinedFunctionId, input SqlUserDefinedFunctionCreateUpdateParameters) error

SqlResourcesCreateUpdateSqlUserDefinedFunctionThenPoll performs SqlResourcesCreateUpdateSqlUserDefinedFunction then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlContainer ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlContainer(ctx context.Context, id ContainerId) (result SqlResourcesDeleteSqlContainerOperationResponse, err error)

SqlResourcesDeleteSqlContainer ...

func (CosmosDBClient) SqlResourcesDeleteSqlContainerThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlContainerThenPoll(ctx context.Context, id ContainerId) error

SqlResourcesDeleteSqlContainerThenPoll performs SqlResourcesDeleteSqlContainer then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlDatabase ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlDatabase(ctx context.Context, id SqlDatabaseId) (result SqlResourcesDeleteSqlDatabaseOperationResponse, err error)

SqlResourcesDeleteSqlDatabase ...

func (CosmosDBClient) SqlResourcesDeleteSqlDatabaseThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlDatabaseThenPoll(ctx context.Context, id SqlDatabaseId) error

SqlResourcesDeleteSqlDatabaseThenPoll performs SqlResourcesDeleteSqlDatabase then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlStoredProcedure ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlStoredProcedure(ctx context.Context, id StoredProcedureId) (result SqlResourcesDeleteSqlStoredProcedureOperationResponse, err error)

SqlResourcesDeleteSqlStoredProcedure ...

func (CosmosDBClient) SqlResourcesDeleteSqlStoredProcedureThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlStoredProcedureThenPoll(ctx context.Context, id StoredProcedureId) error

SqlResourcesDeleteSqlStoredProcedureThenPoll performs SqlResourcesDeleteSqlStoredProcedure then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlTrigger ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlTrigger(ctx context.Context, id TriggerId) (result SqlResourcesDeleteSqlTriggerOperationResponse, err error)

SqlResourcesDeleteSqlTrigger ...

func (CosmosDBClient) SqlResourcesDeleteSqlTriggerThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlTriggerThenPoll(ctx context.Context, id TriggerId) error

SqlResourcesDeleteSqlTriggerThenPoll performs SqlResourcesDeleteSqlTrigger then polls until it's completed

func (CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunction ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunction(ctx context.Context, id UserDefinedFunctionId) (result SqlResourcesDeleteSqlUserDefinedFunctionOperationResponse, err error)

SqlResourcesDeleteSqlUserDefinedFunction ...

func (CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunctionThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesDeleteSqlUserDefinedFunctionThenPoll(ctx context.Context, id UserDefinedFunctionId) error

SqlResourcesDeleteSqlUserDefinedFunctionThenPoll performs SqlResourcesDeleteSqlUserDefinedFunction then polls until it's completed

func (CosmosDBClient) SqlResourcesGetSqlContainer ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlContainer(ctx context.Context, id ContainerId) (result SqlResourcesGetSqlContainerOperationResponse, err error)

SqlResourcesGetSqlContainer ...

func (CosmosDBClient) SqlResourcesGetSqlContainerThroughput ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlContainerThroughput(ctx context.Context, id ContainerId) (result SqlResourcesGetSqlContainerThroughputOperationResponse, err error)

SqlResourcesGetSqlContainerThroughput ...

func (CosmosDBClient) SqlResourcesGetSqlDatabase ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlDatabase(ctx context.Context, id SqlDatabaseId) (result SqlResourcesGetSqlDatabaseOperationResponse, err error)

SqlResourcesGetSqlDatabase ...

func (CosmosDBClient) SqlResourcesGetSqlDatabaseThroughput ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlDatabaseThroughput(ctx context.Context, id SqlDatabaseId) (result SqlResourcesGetSqlDatabaseThroughputOperationResponse, err error)

SqlResourcesGetSqlDatabaseThroughput ...

func (CosmosDBClient) SqlResourcesGetSqlStoredProcedure ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlStoredProcedure(ctx context.Context, id StoredProcedureId) (result SqlResourcesGetSqlStoredProcedureOperationResponse, err error)

SqlResourcesGetSqlStoredProcedure ...

func (CosmosDBClient) SqlResourcesGetSqlTrigger ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlTrigger(ctx context.Context, id TriggerId) (result SqlResourcesGetSqlTriggerOperationResponse, err error)

SqlResourcesGetSqlTrigger ...

func (CosmosDBClient) SqlResourcesGetSqlUserDefinedFunction ¶ 

func (c CosmosDBClient) SqlResourcesGetSqlUserDefinedFunction(ctx context.Context, id UserDefinedFunctionId) (result SqlResourcesGetSqlUserDefinedFunctionOperationResponse, err error)

SqlResourcesGetSqlUserDefinedFunction ...

func (CosmosDBClient) SqlResourcesListSqlContainers ¶ 

func (c CosmosDBClient) SqlResourcesListSqlContainers(ctx context.Context, id SqlDatabaseId) (result SqlResourcesListSqlContainersOperationResponse, err error)

SqlResourcesListSqlContainers ...

func (CosmosDBClient) SqlResourcesListSqlDatabases ¶ 

func (c CosmosDBClient) SqlResourcesListSqlDatabases(ctx context.Context, id DatabaseAccountId) (result SqlResourcesListSqlDatabasesOperationResponse, err error)

SqlResourcesListSqlDatabases ...

func (CosmosDBClient) SqlResourcesListSqlStoredProcedures ¶ 

func (c CosmosDBClient) SqlResourcesListSqlStoredProcedures(ctx context.Context, id ContainerId) (result SqlResourcesListSqlStoredProceduresOperationResponse, err error)

SqlResourcesListSqlStoredProcedures ...

func (CosmosDBClient) SqlResourcesListSqlTriggers ¶ 

func (c CosmosDBClient) SqlResourcesListSqlTriggers(ctx context.Context, id ContainerId) (result SqlResourcesListSqlTriggersOperationResponse, err error)

SqlResourcesListSqlTriggers ...

func (CosmosDBClient) SqlResourcesListSqlUserDefinedFunctions ¶ 

func (c CosmosDBClient) SqlResourcesListSqlUserDefinedFunctions(ctx context.Context, id ContainerId) (result SqlResourcesListSqlUserDefinedFunctionsOperationResponse, err error)

SqlResourcesListSqlUserDefinedFunctions ...

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscale ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscale(ctx context.Context, id ContainerId) (result SqlResourcesMigrateSqlContainerToAutoscaleOperationResponse, err error)

SqlResourcesMigrateSqlContainerToAutoscale ...

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToAutoscaleThenPoll(ctx context.Context, id ContainerId) error

SqlResourcesMigrateSqlContainerToAutoscaleThenPoll performs SqlResourcesMigrateSqlContainerToAutoscale then polls until it's completed

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughput ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughput(ctx context.Context, id ContainerId) (result SqlResourcesMigrateSqlContainerToManualThroughputOperationResponse, err error)

SqlResourcesMigrateSqlContainerToManualThroughput ...

func (CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlContainerToManualThroughputThenPoll(ctx context.Context, id ContainerId) error

SqlResourcesMigrateSqlContainerToManualThroughputThenPoll performs SqlResourcesMigrateSqlContainerToManualThroughput then polls until it's completed

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscale ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscale(ctx context.Context, id SqlDatabaseId) (result SqlResourcesMigrateSqlDatabaseToAutoscaleOperationResponse, err error)

SqlResourcesMigrateSqlDatabaseToAutoscale ...

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll(ctx context.Context, id SqlDatabaseId) error

SqlResourcesMigrateSqlDatabaseToAutoscaleThenPoll performs SqlResourcesMigrateSqlDatabaseToAutoscale then polls until it's completed

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughput ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughput(ctx context.Context, id SqlDatabaseId) (result SqlResourcesMigrateSqlDatabaseToManualThroughputOperationResponse, err error)

SqlResourcesMigrateSqlDatabaseToManualThroughput ...

func (CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll(ctx context.Context, id SqlDatabaseId) error

SqlResourcesMigrateSqlDatabaseToManualThroughputThenPoll performs SqlResourcesMigrateSqlDatabaseToManualThroughput then polls until it's completed

func (CosmosDBClient) SqlResourcesUpdateSqlContainerThroughput ¶ 

func (c CosmosDBClient) SqlResourcesUpdateSqlContainerThroughput(ctx context.Context, id ContainerId, input ThroughputSettingsUpdateParameters) (result SqlResourcesUpdateSqlContainerThroughputOperationResponse, err error)

SqlResourcesUpdateSqlContainerThroughput ...

func (CosmosDBClient) SqlResourcesUpdateSqlContainerThroughputThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesUpdateSqlContainerThroughputThenPoll(ctx context.Context, id ContainerId, input ThroughputSettingsUpdateParameters) error

SqlResourcesUpdateSqlContainerThroughputThenPoll performs SqlResourcesUpdateSqlContainerThroughput then polls until it's completed

func (CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughput ¶ 

func (c CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughput(ctx context.Context, id SqlDatabaseId, input ThroughputSettingsUpdateParameters) (result SqlResourcesUpdateSqlDatabaseThroughputOperationResponse, err error)

SqlResourcesUpdateSqlDatabaseThroughput ...

func (CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughputThenPoll ¶ 

func (c CosmosDBClient) SqlResourcesUpdateSqlDatabaseThroughputThenPoll(ctx context.Context, id SqlDatabaseId, input ThroughputSettingsUpdateParameters) error

SqlResourcesUpdateSqlDatabaseThroughputThenPoll performs SqlResourcesUpdateSqlDatabaseThroughput then polls until it's completed

func (CosmosDBClient) TableResourcesCreateUpdateTable ¶ 

func (c CosmosDBClient) TableResourcesCreateUpdateTable(ctx context.Context, id TableId, input TableCreateUpdateParameters) (result TableResourcesCreateUpdateTableOperationResponse, err error)

TableResourcesCreateUpdateTable ...

func (CosmosDBClient) TableResourcesCreateUpdateTableThenPoll ¶ 

func (c CosmosDBClient) TableResourcesCreateUpdateTableThenPoll(ctx context.Context, id TableId, input TableCreateUpdateParameters) error

TableResourcesCreateUpdateTableThenPoll performs TableResourcesCreateUpdateTable then polls until it's completed

func (CosmosDBClient) TableResourcesDeleteTable ¶ 

func (c CosmosDBClient) TableResourcesDeleteTable(ctx context.Context, id TableId) (result TableResourcesDeleteTableOperationResponse, err error)

TableResourcesDeleteTable ...

func (CosmosDBClient) TableResourcesDeleteTableThenPoll ¶ 

func (c CosmosDBClient) TableResourcesDeleteTableThenPoll(ctx context.Context, id TableId) error

TableResourcesDeleteTableThenPoll performs TableResourcesDeleteTable then polls until it's completed

func (CosmosDBClient) TableResourcesGetTable ¶ 

func (c CosmosDBClient) TableResourcesGetTable(ctx context.Context, id TableId) (result TableResourcesGetTableOperationResponse, err error)

TableResourcesGetTable ...

func (CosmosDBClient) TableResourcesGetTableThroughput ¶ 

func (c CosmosDBClient) TableResourcesGetTableThroughput(ctx context.Context, id TableId) (result TableResourcesGetTableThroughputOperationResponse, err error)

TableResourcesGetTableThroughput ...

func (CosmosDBClient) TableResourcesListTables ¶ 

func (c CosmosDBClient) TableResourcesListTables(ctx context.Context, id DatabaseAccountId) (result TableResourcesListTablesOperationResponse, err error)

TableResourcesListTables ...

func (CosmosDBClient) TableResourcesMigrateTableToAutoscale ¶ 

func (c CosmosDBClient) TableResourcesMigrateTableToAutoscale(ctx context.Context, id TableId) (result TableResourcesMigrateTableToAutoscaleOperationResponse, err error)

TableResourcesMigrateTableToAutoscale ...

func (CosmosDBClient) TableResourcesMigrateTableToAutoscaleThenPoll ¶ 

func (c CosmosDBClient) TableResourcesMigrateTableToAutoscaleThenPoll(ctx context.Context, id TableId) error

TableResourcesMigrateTableToAutoscaleThenPoll performs TableResourcesMigrateTableToAutoscale then polls until it's completed

func (CosmosDBClient) TableResourcesMigrateTableToManualThroughput ¶ 

func (c CosmosDBClient) TableResourcesMigrateTableToManualThroughput(ctx context.Context, id TableId) (result TableResourcesMigrateTableToManualThroughputOperationResponse, err error)

TableResourcesMigrateTableToManualThroughput ...

func (CosmosDBClient) TableResourcesMigrateTableToManualThroughputThenPoll ¶ 

func (c CosmosDBClient) TableResourcesMigrateTableToManualThroughputThenPoll(ctx context.Context, id TableId) error

TableResourcesMigrateTableToManualThroughputThenPoll performs TableResourcesMigrateTableToManualThroughput then polls until it's completed

func (CosmosDBClient) TableResourcesUpdateTableThroughput ¶ 

func (c CosmosDBClient) TableResourcesUpdateTableThroughput(ctx context.Context, id TableId, input ThroughputSettingsUpdateParameters) (result TableResourcesUpdateTableThroughputOperationResponse, err error)

TableResourcesUpdateTableThroughput ...

func (CosmosDBClient) TableResourcesUpdateTableThroughputThenPoll ¶ 

func (c CosmosDBClient) TableResourcesUpdateTableThroughputThenPoll(ctx context.Context, id TableId, input ThroughputSettingsUpdateParameters) error

TableResourcesUpdateTableThroughputThenPoll performs TableResourcesUpdateTableThroughput then polls until it's completed

type CreateMode ¶ 

type CreateMode string
const (
	CreateModeDefault CreateMode = "Default"
	CreateModeRestore CreateMode = "Restore"
)

type CreateUpdateOptions ¶ 

type CreateUpdateOptions struct {
	AutoScaleSettings *AutoScaleSettings `json:"autoscaleSettings,omitempty"`
	Throughput        *int64             `json:"throughput,omitempty"`
}

type DataType ¶ 

type DataType string
const (
	DataTypeLineString   DataType = "LineString"
	DataTypeMultiPolygon DataType = "MultiPolygon"
	DataTypeNumber       DataType = "Number"
	DataTypePoint        DataType = "Point"
	DataTypePolygon      DataType = "Polygon"
	DataTypeString       DataType = "String"
)

type DatabaseAccountConnectionString ¶ 

type DatabaseAccountConnectionString struct {
	ConnectionString *string `json:"connectionString,omitempty"`
	Description      *string `json:"description,omitempty"`
}

type DatabaseAccountCreateUpdateParameters ¶ 

type DatabaseAccountCreateUpdateParameters struct {
	Id         *string                                  `json:"id,omitempty"`
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Kind       *DatabaseAccountKind                     `json:"kind,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties DatabaseAccountCreateUpdateProperties    `json:"properties"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type DatabaseAccountCreateUpdateProperties ¶ 

type DatabaseAccountCreateUpdateProperties struct {
	AnalyticalStorageConfiguration     *AnalyticalStorageConfiguration `json:"analyticalStorageConfiguration,omitempty"`
	ApiProperties                      *ApiProperties                  `json:"apiProperties,omitempty"`
	BackupPolicy                       BackupPolicy                    `json:"backupPolicy"`
	Capabilities                       *[]Capability                   `json:"capabilities,omitempty"`
	Capacity                           *Capacity                       `json:"capacity,omitempty"`
	ConnectorOffer                     *ConnectorOffer                 `json:"connectorOffer,omitempty"`
	ConsistencyPolicy                  *ConsistencyPolicy              `json:"consistencyPolicy,omitempty"`
	Cors                               *[]CorsPolicy                   `json:"cors,omitempty"`
	CreateMode                         *CreateMode                     `json:"createMode,omitempty"`
	DatabaseAccountOfferType           DatabaseAccountOfferType        `json:"databaseAccountOfferType"`
	DefaultIdentity                    *string                         `json:"defaultIdentity,omitempty"`
	DisableKeyBasedMetadataWriteAccess *bool                           `json:"disableKeyBasedMetadataWriteAccess,omitempty"`
	DisableLocalAuth                   *bool                           `json:"disableLocalAuth,omitempty"`
	EnableAnalyticalStorage            *bool                           `json:"enableAnalyticalStorage,omitempty"`
	EnableAutomaticFailover            *bool                           `json:"enableAutomaticFailover,omitempty"`
	EnableCassandraConnector           *bool                           `json:"enableCassandraConnector,omitempty"`
	EnableFreeTier                     *bool                           `json:"enableFreeTier,omitempty"`
	EnableMultipleWriteLocations       *bool                           `json:"enableMultipleWriteLocations,omitempty"`
	EnablePartitionMerge               *bool                           `json:"enablePartitionMerge,omitempty"`
	IPRules                            *[]IPAddressOrRange             `json:"ipRules,omitempty"`
	IsVirtualNetworkFilterEnabled      *bool                           `json:"isVirtualNetworkFilterEnabled,omitempty"`
	KeyVaultKeyUri                     *string                         `json:"keyVaultKeyUri,omitempty"`
	KeysMetadata                       *DatabaseAccountKeysMetadata    `json:"keysMetadata,omitempty"`
	Locations                          []Location                      `json:"locations"`
	NetworkAclBypass                   *NetworkAclBypass               `json:"networkAclBypass,omitempty"`
	NetworkAclBypassResourceIds        *[]string                       `json:"networkAclBypassResourceIds,omitempty"`
	PublicNetworkAccess                *PublicNetworkAccess            `json:"publicNetworkAccess,omitempty"`
	RestoreParameters                  *RestoreParameters              `json:"restoreParameters,omitempty"`
	VirtualNetworkRules                *[]VirtualNetworkRule           `json:"virtualNetworkRules,omitempty"`
}

func (*DatabaseAccountCreateUpdateProperties) UnmarshalJSON ¶ 

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

type DatabaseAccountGetProperties ¶ 

type DatabaseAccountGetProperties struct {
	AnalyticalStorageConfiguration     *AnalyticalStorageConfiguration `json:"analyticalStorageConfiguration,omitempty"`
	ApiProperties                      *ApiProperties                  `json:"apiProperties,omitempty"`
	BackupPolicy                       BackupPolicy                    `json:"backupPolicy"`
	Capabilities                       *[]Capability                   `json:"capabilities,omitempty"`
	Capacity                           *Capacity                       `json:"capacity,omitempty"`
	ConnectorOffer                     *ConnectorOffer                 `json:"connectorOffer,omitempty"`
	ConsistencyPolicy                  *ConsistencyPolicy              `json:"consistencyPolicy,omitempty"`
	Cors                               *[]CorsPolicy                   `json:"cors,omitempty"`
	CreateMode                         *CreateMode                     `json:"createMode,omitempty"`
	DatabaseAccountOfferType           *DatabaseAccountOfferType       `json:"databaseAccountOfferType,omitempty"`
	DefaultIdentity                    *string                         `json:"defaultIdentity,omitempty"`
	DisableKeyBasedMetadataWriteAccess *bool                           `json:"disableKeyBasedMetadataWriteAccess,omitempty"`
	DisableLocalAuth                   *bool                           `json:"disableLocalAuth,omitempty"`
	DocumentEndpoint                   *string                         `json:"documentEndpoint,omitempty"`
	EnableAnalyticalStorage            *bool                           `json:"enableAnalyticalStorage,omitempty"`
	EnableAutomaticFailover            *bool                           `json:"enableAutomaticFailover,omitempty"`
	EnableCassandraConnector           *bool                           `json:"enableCassandraConnector,omitempty"`
	EnableFreeTier                     *bool                           `json:"enableFreeTier,omitempty"`
	EnableMultipleWriteLocations       *bool                           `json:"enableMultipleWriteLocations,omitempty"`
	EnablePartitionMerge               *bool                           `json:"enablePartitionMerge,omitempty"`
	FailoverPolicies                   *[]FailoverPolicy               `json:"failoverPolicies,omitempty"`
	IPRules                            *[]IPAddressOrRange             `json:"ipRules,omitempty"`
	InstanceId                         *string                         `json:"instanceId,omitempty"`
	IsVirtualNetworkFilterEnabled      *bool                           `json:"isVirtualNetworkFilterEnabled,omitempty"`
	KeyVaultKeyUri                     *string                         `json:"keyVaultKeyUri,omitempty"`
	KeysMetadata                       *DatabaseAccountKeysMetadata    `json:"keysMetadata,omitempty"`
	Locations                          *[]Location                     `json:"locations,omitempty"`
	NetworkAclBypass                   *NetworkAclBypass               `json:"networkAclBypass,omitempty"`
	NetworkAclBypassResourceIds        *[]string                       `json:"networkAclBypassResourceIds,omitempty"`
	PrivateEndpointConnections         *[]PrivateEndpointConnection    `json:"privateEndpointConnections,omitempty"`
	ProvisioningState                  *string                         `json:"provisioningState,omitempty"`
	PublicNetworkAccess                *PublicNetworkAccess            `json:"publicNetworkAccess,omitempty"`
	ReadLocations                      *[]Location                     `json:"readLocations,omitempty"`
	RestoreParameters                  *RestoreParameters              `json:"restoreParameters,omitempty"`
	VirtualNetworkRules                *[]VirtualNetworkRule           `json:"virtualNetworkRules,omitempty"`
	WriteLocations                     *[]Location                     `json:"writeLocations,omitempty"`
}

func (*DatabaseAccountGetProperties) UnmarshalJSON ¶ 

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

type DatabaseAccountGetResults ¶ 

type DatabaseAccountGetResults struct {
	Id         *string                                  `json:"id,omitempty"`
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Kind       *DatabaseAccountKind                     `json:"kind,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties *DatabaseAccountGetProperties            `json:"properties,omitempty"`
	SystemData *systemdata.SystemData                   `json:"systemData,omitempty"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type DatabaseAccountId ¶ 

type DatabaseAccountId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
}

DatabaseAccountId is a struct representing the Resource ID for a Database Account

func NewDatabaseAccountID ¶ 

func NewDatabaseAccountID(subscriptionId string, resourceGroupName string, accountName string) DatabaseAccountId

NewDatabaseAccountID returns a new DatabaseAccountId struct

func ParseDatabaseAccountID ¶ 

func ParseDatabaseAccountID(input string) (*DatabaseAccountId, error)

ParseDatabaseAccountID parses 'input' into a DatabaseAccountId

func ParseDatabaseAccountIDInsensitively ¶ 

func ParseDatabaseAccountIDInsensitively(input string) (*DatabaseAccountId, error)

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

func (DatabaseAccountId) ID ¶ 

func (id DatabaseAccountId) ID() string

ID returns the formatted Database Account ID

func (DatabaseAccountId) Segments ¶ 

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

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

func (DatabaseAccountId) String ¶ 

func (id DatabaseAccountId) String() string

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

type DatabaseAccountKeysMetadata ¶ 

type DatabaseAccountKeysMetadata struct {
	PrimaryMasterKey           *AccountKeyMetadata `json:"primaryMasterKey,omitempty"`
	PrimaryReadonlyMasterKey   *AccountKeyMetadata `json:"primaryReadonlyMasterKey,omitempty"`
	SecondaryMasterKey         *AccountKeyMetadata `json:"secondaryMasterKey,omitempty"`
	SecondaryReadonlyMasterKey *AccountKeyMetadata `json:"secondaryReadonlyMasterKey,omitempty"`
}

type DatabaseAccountKind ¶ 

type DatabaseAccountKind string
const (
	DatabaseAccountKindGlobalDocumentDB DatabaseAccountKind = "GlobalDocumentDB"
	DatabaseAccountKindMongoDB          DatabaseAccountKind = "MongoDB"
	DatabaseAccountKindParse            DatabaseAccountKind = "Parse"
)

type DatabaseAccountListConnectionStringsResult ¶ 

type DatabaseAccountListConnectionStringsResult struct {
	ConnectionStrings *[]DatabaseAccountConnectionString `json:"connectionStrings,omitempty"`
}

type DatabaseAccountListKeysResult ¶ 

type DatabaseAccountListKeysResult struct {
	PrimaryMasterKey           *string `json:"primaryMasterKey,omitempty"`
	PrimaryReadonlyMasterKey   *string `json:"primaryReadonlyMasterKey,omitempty"`
	SecondaryMasterKey         *string `json:"secondaryMasterKey,omitempty"`
	SecondaryReadonlyMasterKey *string `json:"secondaryReadonlyMasterKey,omitempty"`
}

type DatabaseAccountListReadOnlyKeysResult ¶ 

type DatabaseAccountListReadOnlyKeysResult struct {
	PrimaryReadonlyMasterKey   *string `json:"primaryReadonlyMasterKey,omitempty"`
	SecondaryReadonlyMasterKey *string `json:"secondaryReadonlyMasterKey,omitempty"`
}

type DatabaseAccountNameId ¶ 

type DatabaseAccountNameId struct {
	AccountName string
}

DatabaseAccountNameId is a struct representing the Resource ID for a Database Account Name

func NewDatabaseAccountNameID ¶ 

func NewDatabaseAccountNameID(accountName string) DatabaseAccountNameId

NewDatabaseAccountNameID returns a new DatabaseAccountNameId struct

func ParseDatabaseAccountNameID ¶ 

func ParseDatabaseAccountNameID(input string) (*DatabaseAccountNameId, error)

ParseDatabaseAccountNameID parses 'input' into a DatabaseAccountNameId

func ParseDatabaseAccountNameIDInsensitively ¶ 

func ParseDatabaseAccountNameIDInsensitively(input string) (*DatabaseAccountNameId, error)

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

func (DatabaseAccountNameId) ID ¶ 

func (id DatabaseAccountNameId) ID() string

ID returns the formatted Database Account Name ID

func (DatabaseAccountNameId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Database Account Name ID

func (DatabaseAccountNameId) String ¶ 

func (id DatabaseAccountNameId) String() string

String returns a human-readable description of this Database Account Name ID

type DatabaseAccountOfferType ¶ 

type DatabaseAccountOfferType string
const (
	DatabaseAccountOfferTypeStandard DatabaseAccountOfferType = "Standard"
)

type DatabaseAccountRegenerateKeyParameters ¶ 

type DatabaseAccountRegenerateKeyParameters struct {
	KeyKind KeyKind `json:"keyKind"`
}

type DatabaseAccountRegionListMetricsOperationOptions ¶ 

type DatabaseAccountRegionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultDatabaseAccountRegionListMetricsOperationOptions ¶ 

func DefaultDatabaseAccountRegionListMetricsOperationOptions() DatabaseAccountRegionListMetricsOperationOptions

type DatabaseAccountRegionListMetricsOperationResponse ¶ 

type DatabaseAccountRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type DatabaseAccountUpdateParameters ¶ 

type DatabaseAccountUpdateParameters struct {
	Identity   *identity.LegacySystemAndUserAssignedMap `json:"identity,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Properties *DatabaseAccountUpdateProperties         `json:"properties,omitempty"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
}

type DatabaseAccountUpdateProperties ¶ 

type DatabaseAccountUpdateProperties struct {
	AnalyticalStorageConfiguration     *AnalyticalStorageConfiguration `json:"analyticalStorageConfiguration,omitempty"`
	ApiProperties                      *ApiProperties                  `json:"apiProperties,omitempty"`
	BackupPolicy                       BackupPolicy                    `json:"backupPolicy"`
	Capabilities                       *[]Capability                   `json:"capabilities,omitempty"`
	Capacity                           *Capacity                       `json:"capacity,omitempty"`
	ConnectorOffer                     *ConnectorOffer                 `json:"connectorOffer,omitempty"`
	ConsistencyPolicy                  *ConsistencyPolicy              `json:"consistencyPolicy,omitempty"`
	Cors                               *[]CorsPolicy                   `json:"cors,omitempty"`
	DefaultIdentity                    *string                         `json:"defaultIdentity,omitempty"`
	DisableKeyBasedMetadataWriteAccess *bool                           `json:"disableKeyBasedMetadataWriteAccess,omitempty"`
	DisableLocalAuth                   *bool                           `json:"disableLocalAuth,omitempty"`
	EnableAnalyticalStorage            *bool                           `json:"enableAnalyticalStorage,omitempty"`
	EnableAutomaticFailover            *bool                           `json:"enableAutomaticFailover,omitempty"`
	EnableCassandraConnector           *bool                           `json:"enableCassandraConnector,omitempty"`
	EnableFreeTier                     *bool                           `json:"enableFreeTier,omitempty"`
	EnableMultipleWriteLocations       *bool                           `json:"enableMultipleWriteLocations,omitempty"`
	EnablePartitionMerge               *bool                           `json:"enablePartitionMerge,omitempty"`
	IPRules                            *[]IPAddressOrRange             `json:"ipRules,omitempty"`
	IsVirtualNetworkFilterEnabled      *bool                           `json:"isVirtualNetworkFilterEnabled,omitempty"`
	KeyVaultKeyUri                     *string                         `json:"keyVaultKeyUri,omitempty"`
	KeysMetadata                       *DatabaseAccountKeysMetadata    `json:"keysMetadata,omitempty"`
	Locations                          *[]Location                     `json:"locations,omitempty"`
	NetworkAclBypass                   *NetworkAclBypass               `json:"networkAclBypass,omitempty"`
	NetworkAclBypassResourceIds        *[]string                       `json:"networkAclBypassResourceIds,omitempty"`
	PublicNetworkAccess                *PublicNetworkAccess            `json:"publicNetworkAccess,omitempty"`
	VirtualNetworkRules                *[]VirtualNetworkRule           `json:"virtualNetworkRules,omitempty"`
}

func (*DatabaseAccountUpdateProperties) UnmarshalJSON ¶ 

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

type DatabaseAccountsCheckNameExistsOperationResponse ¶ 

type DatabaseAccountsCheckNameExistsOperationResponse struct {
	HttpResponse *http.Response
}

type DatabaseAccountsCreateOrUpdateOperationResponse ¶ 

type DatabaseAccountsCreateOrUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsDeleteOperationResponse ¶ 

type DatabaseAccountsDeleteOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsFailoverPriorityChangeOperationResponse ¶ 

type DatabaseAccountsFailoverPriorityChangeOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsGetOperationResponse ¶ 

type DatabaseAccountsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountGetResults
}

type DatabaseAccountsGetReadOnlyKeysOperationResponse ¶ 

type DatabaseAccountsGetReadOnlyKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListReadOnlyKeysResult
}

type DatabaseAccountsListByResourceGroupOperationResponse ¶ 

type DatabaseAccountsListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountsListResult
}

type DatabaseAccountsListConnectionStringsOperationResponse ¶ 

type DatabaseAccountsListConnectionStringsOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListConnectionStringsResult
}

type DatabaseAccountsListKeysOperationResponse ¶ 

type DatabaseAccountsListKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListKeysResult
}

type DatabaseAccountsListMetricDefinitionsOperationResponse ¶ 

type DatabaseAccountsListMetricDefinitionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricDefinitionsListResult
}

type DatabaseAccountsListMetricsOperationOptions ¶ 

type DatabaseAccountsListMetricsOperationOptions struct {
	Filter *string
}

func DefaultDatabaseAccountsListMetricsOperationOptions ¶ 

func DefaultDatabaseAccountsListMetricsOperationOptions() DatabaseAccountsListMetricsOperationOptions

type DatabaseAccountsListMetricsOperationResponse ¶ 

type DatabaseAccountsListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type DatabaseAccountsListOperationResponse ¶ 

type DatabaseAccountsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountsListResult
}

type DatabaseAccountsListReadOnlyKeysOperationResponse ¶ 

type DatabaseAccountsListReadOnlyKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *DatabaseAccountListReadOnlyKeysResult
}

type DatabaseAccountsListResult ¶ 

type DatabaseAccountsListResult struct {
	Value *[]DatabaseAccountGetResults `json:"value,omitempty"`
}

type DatabaseAccountsListUsagesOperationOptions ¶ 

type DatabaseAccountsListUsagesOperationOptions struct {
	Filter *string
}

func DefaultDatabaseAccountsListUsagesOperationOptions ¶ 

func DefaultDatabaseAccountsListUsagesOperationOptions() DatabaseAccountsListUsagesOperationOptions

type DatabaseAccountsListUsagesOperationResponse ¶ 

type DatabaseAccountsListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *UsagesResult
}

type DatabaseAccountsOfflineRegionOperationResponse ¶ 

type DatabaseAccountsOfflineRegionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsOnlineRegionOperationResponse ¶ 

type DatabaseAccountsOnlineRegionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsRegenerateKeyOperationResponse ¶ 

type DatabaseAccountsRegenerateKeyOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseAccountsUpdateOperationResponse ¶ 

type DatabaseAccountsUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type DatabaseCollectionId ¶ 

type DatabaseCollectionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	Region            string
	DatabaseRid       string
	CollectionRid     string
}

DatabaseCollectionId is a struct representing the Resource ID for a Database Collection

func NewDatabaseCollectionID ¶ 

func NewDatabaseCollectionID(subscriptionId string, resourceGroupName string, accountName string, region string, databaseRid string, collectionRid string) DatabaseCollectionId

NewDatabaseCollectionID returns a new DatabaseCollectionId struct

func ParseDatabaseCollectionID ¶ 

func ParseDatabaseCollectionID(input string) (*DatabaseCollectionId, error)

ParseDatabaseCollectionID parses 'input' into a DatabaseCollectionId

func ParseDatabaseCollectionIDInsensitively ¶ 

func ParseDatabaseCollectionIDInsensitively(input string) (*DatabaseCollectionId, error)

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

func (DatabaseCollectionId) ID ¶ 

func (id DatabaseCollectionId) ID() string

ID returns the formatted Database Collection ID

func (DatabaseCollectionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Database Collection ID

func (DatabaseCollectionId) String ¶ 

func (id DatabaseCollectionId) String() string

String returns a human-readable description of this Database Collection ID

type DatabaseId ¶ 

type DatabaseId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseRid       string
}

DatabaseId is a struct representing the Resource ID for a Database

func NewDatabaseID ¶ 

func NewDatabaseID(subscriptionId string, resourceGroupName string, accountName string, databaseRid string) DatabaseId

NewDatabaseID returns a new DatabaseId struct

func ParseDatabaseID ¶ 

func ParseDatabaseID(input string) (*DatabaseId, error)

ParseDatabaseID parses 'input' into a DatabaseId

func ParseDatabaseIDInsensitively ¶ 

func ParseDatabaseIDInsensitively(input string) (*DatabaseId, error)

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

func (DatabaseId) ID ¶ 

func (id DatabaseId) ID() string

ID returns the formatted Database ID

func (DatabaseId) Segments ¶ 

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

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

func (DatabaseId) String ¶ 

func (id DatabaseId) String() string

String returns a human-readable description of this Database ID

type DatabaseListMetricDefinitionsOperationResponse ¶ 

type DatabaseListMetricDefinitionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricDefinitionsListResult
}

type DatabaseListMetricsOperationOptions ¶ 

type DatabaseListMetricsOperationOptions struct {
	Filter *string
}

func DefaultDatabaseListMetricsOperationOptions ¶ 

func DefaultDatabaseListMetricsOperationOptions() DatabaseListMetricsOperationOptions

type DatabaseListMetricsOperationResponse ¶ 

type DatabaseListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MetricListResult
}

type DatabaseListUsagesOperationOptions ¶ 

type DatabaseListUsagesOperationOptions struct {
	Filter *string
}

func DefaultDatabaseListUsagesOperationOptions ¶ 

func DefaultDatabaseListUsagesOperationOptions() DatabaseListUsagesOperationOptions

type DatabaseListUsagesOperationResponse ¶ 

type DatabaseListUsagesOperationResponse struct {
	HttpResponse *http.Response
	Model        *UsagesResult
}

type DatabaseRestoreResource ¶ 

type DatabaseRestoreResource struct {
	CollectionNames *[]string `json:"collectionNames,omitempty"`
	DatabaseName    *string   `json:"databaseName,omitempty"`
}

type DefaultConsistencyLevel ¶ 

type DefaultConsistencyLevel string
const (
	DefaultConsistencyLevelBoundedStaleness DefaultConsistencyLevel = "BoundedStaleness"
	DefaultConsistencyLevelConsistentPrefix DefaultConsistencyLevel = "ConsistentPrefix"
	DefaultConsistencyLevelEventual         DefaultConsistencyLevel = "Eventual"
	DefaultConsistencyLevelSession          DefaultConsistencyLevel = "Session"
	DefaultConsistencyLevelStrong           DefaultConsistencyLevel = "Strong"
)

type ExcludedPath ¶ 

type ExcludedPath struct {
	Path *string `json:"path,omitempty"`
}

type FailoverPolicies ¶ 

type FailoverPolicies struct {
	FailoverPolicies []FailoverPolicy `json:"failoverPolicies"`
}

type FailoverPolicy ¶ 

type FailoverPolicy struct {
	FailoverPriority *int64  `json:"failoverPriority,omitempty"`
	Id               *string `json:"id,omitempty"`
	LocationName     *string `json:"locationName,omitempty"`
}

type GraphId ¶ 

type GraphId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
	GraphName         string
}

GraphId is a struct representing the Resource ID for a Graph

func NewGraphID ¶ 

func NewGraphID(subscriptionId string, resourceGroupName string, accountName string, databaseName string, graphName string) GraphId

NewGraphID returns a new GraphId struct

func ParseGraphID ¶ 

func ParseGraphID(input string) (*GraphId, error)

ParseGraphID parses 'input' into a GraphId

func ParseGraphIDInsensitively ¶ 

func ParseGraphIDInsensitively(input string) (*GraphId, error)

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

func (GraphId) ID ¶ 

func (id GraphId) ID() string

ID returns the formatted Graph ID

func (GraphId) Segments ¶ 

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

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

func (GraphId) String ¶ 

func (id GraphId) String() string

String returns a human-readable description of this Graph ID

type GremlinDatabaseCreateUpdateParameters ¶ 

type GremlinDatabaseCreateUpdateParameters struct {
	Id         *string                               `json:"id,omitempty"`
	Location   *string                               `json:"location,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties GremlinDatabaseCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                    `json:"tags,omitempty"`
	Type       *string                               `json:"type,omitempty"`
}

type GremlinDatabaseCreateUpdateProperties ¶ 

type GremlinDatabaseCreateUpdateProperties struct {
	Options  *CreateUpdateOptions    `json:"options,omitempty"`
	Resource GremlinDatabaseResource `json:"resource"`
}

type GremlinDatabaseGetProperties ¶ 

type GremlinDatabaseGetProperties struct {
	Options  *OptionsResource              `json:"options,omitempty"`
	Resource *GremlinDatabaseGetProperties `json:"resource,omitempty"`
}

type GremlinDatabaseGetResults ¶ 

type GremlinDatabaseGetResults struct {
	Id         *string                       `json:"id,omitempty"`
	Location   *string                       `json:"location,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *GremlinDatabaseGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string            `json:"tags,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type GremlinDatabaseId ¶ 

type GremlinDatabaseId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
}

GremlinDatabaseId is a struct representing the Resource ID for a Gremlin Database

func NewGremlinDatabaseID ¶ 

func NewGremlinDatabaseID(subscriptionId string, resourceGroupName string, accountName string, databaseName string) GremlinDatabaseId

NewGremlinDatabaseID returns a new GremlinDatabaseId struct

func ParseGremlinDatabaseID ¶ 

func ParseGremlinDatabaseID(input string) (*GremlinDatabaseId, error)

ParseGremlinDatabaseID parses 'input' into a GremlinDatabaseId

func ParseGremlinDatabaseIDInsensitively ¶ 

func ParseGremlinDatabaseIDInsensitively(input string) (*GremlinDatabaseId, error)

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

func (GremlinDatabaseId) ID ¶ 

func (id GremlinDatabaseId) ID() string

ID returns the formatted Gremlin Database ID

func (GremlinDatabaseId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Gremlin Database ID

func (GremlinDatabaseId) String ¶ 

func (id GremlinDatabaseId) String() string

String returns a human-readable description of this Gremlin Database ID

type GremlinDatabaseListResult ¶ 

type GremlinDatabaseListResult struct {
	Value *[]GremlinDatabaseGetResults `json:"value,omitempty"`
}

type GremlinDatabaseResource ¶ 

type GremlinDatabaseResource struct {
	Id string `json:"id"`
}

type GremlinGraphCreateUpdateParameters ¶ 

type GremlinGraphCreateUpdateParameters struct {
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties GremlinGraphCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type GremlinGraphCreateUpdateProperties ¶ 

type GremlinGraphCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource GremlinGraphResource `json:"resource"`
}

type GremlinGraphGetProperties ¶ 

type GremlinGraphGetProperties struct {
	Options  *OptionsResource           `json:"options,omitempty"`
	Resource *GremlinGraphGetProperties `json:"resource,omitempty"`
}

type GremlinGraphGetResults ¶ 

type GremlinGraphGetResults struct {
	Id         *string                    `json:"id,omitempty"`
	Location   *string                    `json:"location,omitempty"`
	Name       *string                    `json:"name,omitempty"`
	Properties *GremlinGraphGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string         `json:"tags,omitempty"`
	Type       *string                    `json:"type,omitempty"`
}

type GremlinGraphListResult ¶ 

type GremlinGraphListResult struct {
	Value *[]GremlinGraphGetResults `json:"value,omitempty"`
}

type GremlinGraphResource ¶ 

type GremlinGraphResource struct {
	AnalyticalStorageTtl     *int64                    `json:"analyticalStorageTtl,omitempty"`
	ConflictResolutionPolicy *ConflictResolutionPolicy `json:"conflictResolutionPolicy,omitempty"`
	DefaultTtl               *int64                    `json:"defaultTtl,omitempty"`
	Id                       string                    `json:"id"`
	IndexingPolicy           *IndexingPolicy           `json:"indexingPolicy,omitempty"`
	PartitionKey             *ContainerPartitionKey    `json:"partitionKey,omitempty"`
	UniqueKeyPolicy          *UniqueKeyPolicy          `json:"uniqueKeyPolicy,omitempty"`
}

type GremlinResourcesCreateUpdateGremlinDatabaseOperationResponse ¶ 

type GremlinResourcesCreateUpdateGremlinDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesCreateUpdateGremlinGraphOperationResponse ¶ 

type GremlinResourcesCreateUpdateGremlinGraphOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesDeleteGremlinDatabaseOperationResponse ¶ 

type GremlinResourcesDeleteGremlinDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesDeleteGremlinGraphOperationResponse ¶ 

type GremlinResourcesDeleteGremlinGraphOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesGetGremlinDatabaseOperationResponse ¶ 

type GremlinResourcesGetGremlinDatabaseOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinDatabaseGetResults
}

type GremlinResourcesGetGremlinDatabaseThroughputOperationResponse ¶ 

type GremlinResourcesGetGremlinDatabaseThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type GremlinResourcesGetGremlinGraphOperationResponse ¶ 

type GremlinResourcesGetGremlinGraphOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinGraphGetResults
}

type GremlinResourcesGetGremlinGraphThroughputOperationResponse ¶ 

type GremlinResourcesGetGremlinGraphThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type GremlinResourcesListGremlinDatabasesOperationResponse ¶ 

type GremlinResourcesListGremlinDatabasesOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinDatabaseListResult
}

type GremlinResourcesListGremlinGraphsOperationResponse ¶ 

type GremlinResourcesListGremlinGraphsOperationResponse struct {
	HttpResponse *http.Response
	Model        *GremlinGraphListResult
}

type GremlinResourcesMigrateGremlinDatabaseToAutoscaleOperationResponse ¶ 

type GremlinResourcesMigrateGremlinDatabaseToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesMigrateGremlinDatabaseToManualThroughputOperationResponse ¶ 

type GremlinResourcesMigrateGremlinDatabaseToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesMigrateGremlinGraphToAutoscaleOperationResponse ¶ 

type GremlinResourcesMigrateGremlinGraphToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesMigrateGremlinGraphToManualThroughputOperationResponse ¶ 

type GremlinResourcesMigrateGremlinGraphToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesUpdateGremlinDatabaseThroughputOperationResponse ¶ 

type GremlinResourcesUpdateGremlinDatabaseThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type GremlinResourcesUpdateGremlinGraphThroughputOperationResponse ¶ 

type GremlinResourcesUpdateGremlinGraphThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type IPAddressOrRange ¶ 

type IPAddressOrRange struct {
	IPAddressOrRange *string `json:"ipAddressOrRange,omitempty"`
}

type IncludedPath ¶ 

type IncludedPath struct {
	Indexes *[]Indexes `json:"indexes,omitempty"`
	Path    *string    `json:"path,omitempty"`
}

type IndexKind ¶ 

type IndexKind string
const (
	IndexKindHash    IndexKind = "Hash"
	IndexKindRange   IndexKind = "Range"
	IndexKindSpatial IndexKind = "Spatial"
)

type Indexes ¶ 

type Indexes struct {
	DataType  *DataType  `json:"dataType,omitempty"`
	Kind      *IndexKind `json:"kind,omitempty"`
	Precision *int64     `json:"precision,omitempty"`
}

type IndexingMode ¶ 

type IndexingMode string
const (
	IndexingModeConsistent IndexingMode = "consistent"
	IndexingModeLazy       IndexingMode = "lazy"
	IndexingModeNone       IndexingMode = "none"
)

type IndexingPolicy ¶ 

type IndexingPolicy struct {
	Automatic        *bool              `json:"automatic,omitempty"`
	CompositeIndexes *[][]CompositePath `json:"compositeIndexes,omitempty"`
	ExcludedPaths    *[]ExcludedPath    `json:"excludedPaths,omitempty"`
	IncludedPaths    *[]IncludedPath    `json:"includedPaths,omitempty"`
	IndexingMode     *IndexingMode      `json:"indexingMode,omitempty"`
	SpatialIndexes   *[]SpatialSpec     `json:"spatialIndexes,omitempty"`
}

type KeyKind ¶ 

type KeyKind string
const (
	KeyKindPrimary           KeyKind = "primary"
	KeyKindPrimaryReadonly   KeyKind = "primaryReadonly"
	KeyKindSecondary         KeyKind = "secondary"
	KeyKindSecondaryReadonly KeyKind = "secondaryReadonly"
)

type Location ¶ 

type Location struct {
	DocumentEndpoint  *string `json:"documentEndpoint,omitempty"`
	FailoverPriority  *int64  `json:"failoverPriority,omitempty"`
	Id                *string `json:"id,omitempty"`
	IsZoneRedundant   *bool   `json:"isZoneRedundant,omitempty"`
	LocationName      *string `json:"locationName,omitempty"`
	ProvisioningState *string `json:"provisioningState,omitempty"`
}

type LocationGetResult ¶ 

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

type LocationId ¶ 

type LocationId struct {
	SubscriptionId string
	Location       string
}

LocationId is a struct representing the Resource ID for a Location

func NewLocationID ¶ 

func NewLocationID(subscriptionId string, location 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 LocationListResult ¶ 

type LocationListResult struct {
	Value *[]LocationGetResult `json:"value,omitempty"`
}

type LocationProperties ¶ 

type LocationProperties struct {
	BackupStorageRedundancies *[]BackupStorageRedundancy `json:"backupStorageRedundancies,omitempty"`
	IsResidencyRestricted     *bool                      `json:"isResidencyRestricted,omitempty"`
	SupportsAvailabilityZone  *bool                      `json:"supportsAvailabilityZone,omitempty"`
}

type LocationsGetOperationResponse ¶ 

type LocationsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *LocationGetResult
}

type LocationsListOperationResponse ¶ 

type LocationsListOperationResponse struct {
	HttpResponse *http.Response
	Model        *LocationListResult
}

type Metric ¶ 

type Metric struct {
	EndTime      *string        `json:"endTime,omitempty"`
	MetricValues *[]MetricValue `json:"metricValues,omitempty"`
	Name         *MetricName    `json:"name,omitempty"`
	StartTime    *string        `json:"startTime,omitempty"`
	TimeGrain    *string        `json:"timeGrain,omitempty"`
	Unit         *UnitType      `json:"unit,omitempty"`
}

func (*Metric) GetEndTimeAsTime ¶ 

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

func (*Metric) GetStartTimeAsTime ¶ 

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

func (*Metric) SetEndTimeAsTime ¶ 

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

func (*Metric) SetStartTimeAsTime ¶ 

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

type MetricAvailability ¶ 

type MetricAvailability struct {
	Retention *string `json:"retention,omitempty"`
	TimeGrain *string `json:"timeGrain,omitempty"`
}

type MetricDefinition ¶ 

type MetricDefinition struct {
	MetricAvailabilities   *[]MetricAvailability   `json:"metricAvailabilities,omitempty"`
	Name                   *MetricName             `json:"name,omitempty"`
	PrimaryAggregationType *PrimaryAggregationType `json:"primaryAggregationType,omitempty"`
	ResourceUri            *string                 `json:"resourceUri,omitempty"`
	Unit                   *UnitType               `json:"unit,omitempty"`
}

type MetricDefinitionsListResult ¶ 

type MetricDefinitionsListResult struct {
	Value *[]MetricDefinition `json:"value,omitempty"`
}

type MetricListResult ¶ 

type MetricListResult struct {
	Value *[]Metric `json:"value,omitempty"`
}

type MetricName ¶ 

type MetricName struct {
	LocalizedValue *string `json:"localizedValue,omitempty"`
	Value          *string `json:"value,omitempty"`
}

type MetricValue ¶ 

type MetricValue struct {
	Average   *float64 `json:"average,omitempty"`
	Count     *float64 `json:"_count,omitempty"`
	Maximum   *float64 `json:"maximum,omitempty"`
	Minimum   *float64 `json:"minimum,omitempty"`
	Timestamp *string  `json:"timestamp,omitempty"`
	Total     *float64 `json:"total,omitempty"`
}

func (*MetricValue) GetTimestampAsTime ¶ 

func (o *MetricValue) GetTimestampAsTime() (*time.Time, error)

func (*MetricValue) SetTimestampAsTime ¶ 

func (o *MetricValue) SetTimestampAsTime(input time.Time)

type MongoDBCollectionCreateUpdateParameters ¶ 

type MongoDBCollectionCreateUpdateParameters struct {
	Id         *string                                 `json:"id,omitempty"`
	Location   *string                                 `json:"location,omitempty"`
	Name       *string                                 `json:"name,omitempty"`
	Properties MongoDBCollectionCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                      `json:"tags,omitempty"`
	Type       *string                                 `json:"type,omitempty"`
}

type MongoDBCollectionCreateUpdateProperties ¶ 

type MongoDBCollectionCreateUpdateProperties struct {
	Options  *CreateUpdateOptions      `json:"options,omitempty"`
	Resource MongoDBCollectionResource `json:"resource"`
}

type MongoDBCollectionGetProperties ¶ 

type MongoDBCollectionGetProperties struct {
	Options  *OptionsResource                `json:"options,omitempty"`
	Resource *MongoDBCollectionGetProperties `json:"resource,omitempty"`
}

type MongoDBCollectionGetResults ¶ 

type MongoDBCollectionGetResults struct {
	Id         *string                         `json:"id,omitempty"`
	Location   *string                         `json:"location,omitempty"`
	Name       *string                         `json:"name,omitempty"`
	Properties *MongoDBCollectionGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string              `json:"tags,omitempty"`
	Type       *string                         `json:"type,omitempty"`
}

type MongoDBCollectionListResult ¶ 

type MongoDBCollectionListResult struct {
	Value *[]MongoDBCollectionGetResults `json:"value,omitempty"`
}

type MongoDBCollectionResource ¶ 

type MongoDBCollectionResource struct {
	AnalyticalStorageTtl *int64             `json:"analyticalStorageTtl,omitempty"`
	Id                   string             `json:"id"`
	Indexes              *[]MongoIndex      `json:"indexes,omitempty"`
	ShardKey             *map[string]string `json:"shardKey,omitempty"`
}

type MongoDBDatabaseCreateUpdateParameters ¶ 

type MongoDBDatabaseCreateUpdateParameters struct {
	Id         *string                               `json:"id,omitempty"`
	Location   *string                               `json:"location,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties MongoDBDatabaseCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                    `json:"tags,omitempty"`
	Type       *string                               `json:"type,omitempty"`
}

type MongoDBDatabaseCreateUpdateProperties ¶ 

type MongoDBDatabaseCreateUpdateProperties struct {
	Options  *CreateUpdateOptions    `json:"options,omitempty"`
	Resource MongoDBDatabaseResource `json:"resource"`
}

type MongoDBDatabaseGetProperties ¶ 

type MongoDBDatabaseGetProperties struct {
	Options  *OptionsResource              `json:"options,omitempty"`
	Resource *MongoDBDatabaseGetProperties `json:"resource,omitempty"`
}

type MongoDBDatabaseGetResults ¶ 

type MongoDBDatabaseGetResults struct {
	Id         *string                       `json:"id,omitempty"`
	Location   *string                       `json:"location,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *MongoDBDatabaseGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string            `json:"tags,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type MongoDBDatabaseListResult ¶ 

type MongoDBDatabaseListResult struct {
	Value *[]MongoDBDatabaseGetResults `json:"value,omitempty"`
}

type MongoDBDatabaseResource ¶ 

type MongoDBDatabaseResource struct {
	Id string `json:"id"`
}

type MongoDBResourcesCreateUpdateMongoDBCollectionOperationResponse ¶ 

type MongoDBResourcesCreateUpdateMongoDBCollectionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesCreateUpdateMongoDBDatabaseOperationResponse ¶ 

type MongoDBResourcesCreateUpdateMongoDBDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesDeleteMongoDBCollectionOperationResponse ¶ 

type MongoDBResourcesDeleteMongoDBCollectionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesDeleteMongoDBDatabaseOperationResponse ¶ 

type MongoDBResourcesDeleteMongoDBDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesGetMongoDBCollectionOperationResponse ¶ 

type MongoDBResourcesGetMongoDBCollectionOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBCollectionGetResults
}

type MongoDBResourcesGetMongoDBCollectionThroughputOperationResponse ¶ 

type MongoDBResourcesGetMongoDBCollectionThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type MongoDBResourcesGetMongoDBDatabaseOperationResponse ¶ 

type MongoDBResourcesGetMongoDBDatabaseOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBDatabaseGetResults
}

type MongoDBResourcesGetMongoDBDatabaseThroughputOperationResponse ¶ 

type MongoDBResourcesGetMongoDBDatabaseThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type MongoDBResourcesListMongoDBCollectionsOperationResponse ¶ 

type MongoDBResourcesListMongoDBCollectionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBCollectionListResult
}

type MongoDBResourcesListMongoDBDatabasesOperationResponse ¶ 

type MongoDBResourcesListMongoDBDatabasesOperationResponse struct {
	HttpResponse *http.Response
	Model        *MongoDBDatabaseListResult
}

type MongoDBResourcesMigrateMongoDBCollectionToAutoscaleOperationResponse ¶ 

type MongoDBResourcesMigrateMongoDBCollectionToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesMigrateMongoDBCollectionToManualThroughputOperationResponse ¶ 

type MongoDBResourcesMigrateMongoDBCollectionToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleOperationResponse ¶ 

type MongoDBResourcesMigrateMongoDBDatabaseToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputOperationResponse ¶ 

type MongoDBResourcesMigrateMongoDBDatabaseToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesUpdateMongoDBCollectionThroughputOperationResponse ¶ 

type MongoDBResourcesUpdateMongoDBCollectionThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoDBResourcesUpdateMongoDBDatabaseThroughputOperationResponse ¶ 

type MongoDBResourcesUpdateMongoDBDatabaseThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type MongoIndex ¶ 

type MongoIndex struct {
	Key     *MongoIndexKeys    `json:"key,omitempty"`
	Options *MongoIndexOptions `json:"options,omitempty"`
}

type MongoIndexKeys ¶ 

type MongoIndexKeys struct {
	Keys *[]string `json:"keys,omitempty"`
}

type MongoIndexOptions ¶ 

type MongoIndexOptions struct {
	ExpireAfterSeconds *int64 `json:"expireAfterSeconds,omitempty"`
	Unique             *bool  `json:"unique,omitempty"`
}

type MongodbDatabaseCollectionId ¶ 

type MongodbDatabaseCollectionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
	CollectionName    string
}

MongodbDatabaseCollectionId is a struct representing the Resource ID for a Mongodb Database Collection

func NewMongodbDatabaseCollectionID ¶ 

func NewMongodbDatabaseCollectionID(subscriptionId string, resourceGroupName string, accountName string, databaseName string, collectionName string) MongodbDatabaseCollectionId

NewMongodbDatabaseCollectionID returns a new MongodbDatabaseCollectionId struct

func ParseMongodbDatabaseCollectionID ¶ 

func ParseMongodbDatabaseCollectionID(input string) (*MongodbDatabaseCollectionId, error)

ParseMongodbDatabaseCollectionID parses 'input' into a MongodbDatabaseCollectionId

func ParseMongodbDatabaseCollectionIDInsensitively ¶ 

func ParseMongodbDatabaseCollectionIDInsensitively(input string) (*MongodbDatabaseCollectionId, error)

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

func (MongodbDatabaseCollectionId) ID ¶ 

func (id MongodbDatabaseCollectionId) ID() string

ID returns the formatted Mongodb Database Collection ID

func (MongodbDatabaseCollectionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Mongodb Database Collection ID

func (MongodbDatabaseCollectionId) String ¶ 

func (id MongodbDatabaseCollectionId) String() string

String returns a human-readable description of this Mongodb Database Collection ID

type MongodbDatabaseId ¶ 

type MongodbDatabaseId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
}

MongodbDatabaseId is a struct representing the Resource ID for a Mongodb Database

func NewMongodbDatabaseID ¶ 

func NewMongodbDatabaseID(subscriptionId string, resourceGroupName string, accountName string, databaseName string) MongodbDatabaseId

NewMongodbDatabaseID returns a new MongodbDatabaseId struct

func ParseMongodbDatabaseID ¶ 

func ParseMongodbDatabaseID(input string) (*MongodbDatabaseId, error)

ParseMongodbDatabaseID parses 'input' into a MongodbDatabaseId

func ParseMongodbDatabaseIDInsensitively ¶ 

func ParseMongodbDatabaseIDInsensitively(input string) (*MongodbDatabaseId, error)

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

func (MongodbDatabaseId) ID ¶ 

func (id MongodbDatabaseId) ID() string

ID returns the formatted Mongodb Database ID

func (MongodbDatabaseId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Mongodb Database ID

func (MongodbDatabaseId) String ¶ 

func (id MongodbDatabaseId) String() string

String returns a human-readable description of this Mongodb Database ID

type NetworkAclBypass ¶ 

type NetworkAclBypass string
const (
	NetworkAclBypassAzureServices NetworkAclBypass = "AzureServices"
	NetworkAclBypassNone          NetworkAclBypass = "None"
)

type OptionsResource ¶ 

type OptionsResource struct {
	AutoScaleSettings *AutoScaleSettings `json:"autoscaleSettings,omitempty"`
	Throughput        *int64             `json:"throughput,omitempty"`
}

type PartitionKeyRangeIdId ¶ 

type PartitionKeyRangeIdId struct {
	SubscriptionId      string
	ResourceGroupName   string
	AccountName         string
	DatabaseRid         string
	CollectionRid       string
	PartitionKeyRangeId string
}

PartitionKeyRangeIdId is a struct representing the Resource ID for a Partition Key Range Id

func NewPartitionKeyRangeIdID ¶ 

func NewPartitionKeyRangeIdID(subscriptionId string, resourceGroupName string, accountName string, databaseRid string, collectionRid string, partitionKeyRangeId string) PartitionKeyRangeIdId

NewPartitionKeyRangeIdID returns a new PartitionKeyRangeIdId struct

func ParsePartitionKeyRangeIdID ¶ 

func ParsePartitionKeyRangeIdID(input string) (*PartitionKeyRangeIdId, error)

ParsePartitionKeyRangeIdID parses 'input' into a PartitionKeyRangeIdId

func ParsePartitionKeyRangeIdIDInsensitively ¶ 

func ParsePartitionKeyRangeIdIDInsensitively(input string) (*PartitionKeyRangeIdId, error)

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

func (PartitionKeyRangeIdId) ID ¶ 

func (id PartitionKeyRangeIdId) ID() string

ID returns the formatted Partition Key Range Id ID

func (PartitionKeyRangeIdId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Partition Key Range Id ID

func (PartitionKeyRangeIdId) String ¶ 

func (id PartitionKeyRangeIdId) String() string

String returns a human-readable description of this Partition Key Range Id ID

type PartitionKeyRangeIdListMetricsOperationOptions ¶ 

type PartitionKeyRangeIdListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPartitionKeyRangeIdListMetricsOperationOptions ¶ 

func DefaultPartitionKeyRangeIdListMetricsOperationOptions() PartitionKeyRangeIdListMetricsOperationOptions

type PartitionKeyRangeIdListMetricsOperationResponse ¶ 

type PartitionKeyRangeIdListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type PartitionKeyRangeIdRegionListMetricsOperationOptions ¶ 

type PartitionKeyRangeIdRegionListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPartitionKeyRangeIdRegionListMetricsOperationOptions ¶ 

func DefaultPartitionKeyRangeIdRegionListMetricsOperationOptions() PartitionKeyRangeIdRegionListMetricsOperationOptions

type PartitionKeyRangeIdRegionListMetricsOperationResponse ¶ 

type PartitionKeyRangeIdRegionListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PartitionMetricListResult
}

type PartitionKind ¶ 

type PartitionKind string
const (
	PartitionKindHash      PartitionKind = "Hash"
	PartitionKindMultiHash PartitionKind = "MultiHash"
	PartitionKindRange     PartitionKind = "Range"
)

type PartitionMetric ¶ 

type PartitionMetric struct {
	EndTime             *string        `json:"endTime,omitempty"`
	MetricValues        *[]MetricValue `json:"metricValues,omitempty"`
	Name                *MetricName    `json:"name,omitempty"`
	PartitionId         *string        `json:"partitionId,omitempty"`
	PartitionKeyRangeId *string        `json:"partitionKeyRangeId,omitempty"`
	StartTime           *string        `json:"startTime,omitempty"`
	TimeGrain           *string        `json:"timeGrain,omitempty"`
	Unit                *UnitType      `json:"unit,omitempty"`
}

func (*PartitionMetric) GetEndTimeAsTime ¶ 

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

func (*PartitionMetric) GetStartTimeAsTime ¶ 

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

func (*PartitionMetric) SetEndTimeAsTime ¶ 

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

func (*PartitionMetric) SetStartTimeAsTime ¶ 

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

type PartitionMetricListResult ¶ 

type PartitionMetricListResult struct {
	Value *[]PartitionMetric `json:"value,omitempty"`
}

type PartitionUsage ¶ 

type PartitionUsage struct {
	CurrentValue        *int64      `json:"currentValue,omitempty"`
	Limit               *int64      `json:"limit,omitempty"`
	Name                *MetricName `json:"name,omitempty"`
	PartitionId         *string     `json:"partitionId,omitempty"`
	PartitionKeyRangeId *string     `json:"partitionKeyRangeId,omitempty"`
	QuotaPeriod         *string     `json:"quotaPeriod,omitempty"`
	Unit                *UnitType   `json:"unit,omitempty"`
}

type PartitionUsagesResult ¶ 

type PartitionUsagesResult struct {
	Value *[]PartitionUsage `json:"value,omitempty"`
}

type PercentileListMetricsOperationOptions ¶ 

type PercentileListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPercentileListMetricsOperationOptions ¶ 

func DefaultPercentileListMetricsOperationOptions() PercentileListMetricsOperationOptions

type PercentileListMetricsOperationResponse ¶ 

type PercentileListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PercentileMetricListResult
}

type PercentileMetric ¶ 

type PercentileMetric struct {
	EndTime      *string                  `json:"endTime,omitempty"`
	MetricValues *[]PercentileMetricValue `json:"metricValues,omitempty"`
	Name         *MetricName              `json:"name,omitempty"`
	StartTime    *string                  `json:"startTime,omitempty"`
	TimeGrain    *string                  `json:"timeGrain,omitempty"`
	Unit         *UnitType                `json:"unit,omitempty"`
}

func (*PercentileMetric) GetEndTimeAsTime ¶ 

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

func (*PercentileMetric) GetStartTimeAsTime ¶ 

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

func (*PercentileMetric) SetEndTimeAsTime ¶ 

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

func (*PercentileMetric) SetStartTimeAsTime ¶ 

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

type PercentileMetricListResult ¶ 

type PercentileMetricListResult struct {
	Value *[]PercentileMetric `json:"value,omitempty"`
}

type PercentileMetricValue ¶ 

type PercentileMetricValue struct {
	Average   *float64 `json:"average,omitempty"`
	Count     *float64 `json:"_count,omitempty"`
	Maximum   *float64 `json:"maximum,omitempty"`
	Minimum   *float64 `json:"minimum,omitempty"`
	P10       *float64 `json:"P10,omitempty"`
	P25       *float64 `json:"P25,omitempty"`
	P50       *float64 `json:"P50,omitempty"`
	P75       *float64 `json:"P75,omitempty"`
	P90       *float64 `json:"P90,omitempty"`
	P95       *float64 `json:"P95,omitempty"`
	P99       *float64 `json:"P99,omitempty"`
	Timestamp *string  `json:"timestamp,omitempty"`
	Total     *float64 `json:"total,omitempty"`
}

func (*PercentileMetricValue) GetTimestampAsTime ¶ 

func (o *PercentileMetricValue) GetTimestampAsTime() (*time.Time, error)

func (*PercentileMetricValue) SetTimestampAsTime ¶ 

func (o *PercentileMetricValue) SetTimestampAsTime(input time.Time)

type PercentileSourceTargetListMetricsOperationOptions ¶ 

type PercentileSourceTargetListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPercentileSourceTargetListMetricsOperationOptions ¶ 

func DefaultPercentileSourceTargetListMetricsOperationOptions() PercentileSourceTargetListMetricsOperationOptions

type PercentileSourceTargetListMetricsOperationResponse ¶ 

type PercentileSourceTargetListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PercentileMetricListResult
}

type PercentileTargetListMetricsOperationOptions ¶ 

type PercentileTargetListMetricsOperationOptions struct {
	Filter *string
}

func DefaultPercentileTargetListMetricsOperationOptions ¶ 

func DefaultPercentileTargetListMetricsOperationOptions() PercentileTargetListMetricsOperationOptions

type PercentileTargetListMetricsOperationResponse ¶ 

type PercentileTargetListMetricsOperationResponse struct {
	HttpResponse *http.Response
	Model        *PercentileMetricListResult
}

type PeriodicModeBackupPolicy ¶ 

type PeriodicModeBackupPolicy struct {
	PeriodicModeProperties *PeriodicModeProperties `json:"periodicModeProperties,omitempty"`

	// Fields inherited from BackupPolicy
	MigrationState *BackupPolicyMigrationState `json:"migrationState,omitempty"`
}

func (PeriodicModeBackupPolicy) MarshalJSON ¶ 

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

type PeriodicModeProperties ¶ 

type PeriodicModeProperties struct {
	BackupIntervalInMinutes        *int64                   `json:"backupIntervalInMinutes,omitempty"`
	BackupRetentionIntervalInHours *int64                   `json:"backupRetentionIntervalInHours,omitempty"`
	BackupStorageRedundancy        *BackupStorageRedundancy `json:"backupStorageRedundancy,omitempty"`
}

type PrimaryAggregationType ¶ 

type PrimaryAggregationType string
const (
	PrimaryAggregationTypeAverage PrimaryAggregationType = "Average"
	PrimaryAggregationTypeLast    PrimaryAggregationType = "Last"
	PrimaryAggregationTypeMaximum PrimaryAggregationType = "Maximum"
	PrimaryAggregationTypeMinimum PrimaryAggregationType = "Minimum"
	PrimaryAggregationTypeNone    PrimaryAggregationType = "None"
	PrimaryAggregationTypeTotal   PrimaryAggregationType = "Total"
)

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 PrivateEndpointConnectionProperties ¶ 

type PrivateEndpointConnectionProperties struct {
	GroupId                           *string                                    `json:"groupId,omitempty"`
	PrivateEndpoint                   *PrivateEndpointProperty                   `json:"privateEndpoint,omitempty"`
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionStateProperty `json:"privateLinkServiceConnectionState,omitempty"`
	ProvisioningState                 *string                                    `json:"provisioningState,omitempty"`
}

type PrivateEndpointProperty ¶ 

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

type PrivateLinkServiceConnectionStateProperty ¶ 

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

type PublicNetworkAccess ¶ 

type PublicNetworkAccess string
const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

type RegionForOnlineOffline ¶ 

type RegionForOnlineOffline struct {
	Region string `json:"region"`
}

type RegionId ¶ 

type RegionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	Region            string
}

RegionId is a struct representing the Resource ID for a Region

func NewRegionID ¶ 

func NewRegionID(subscriptionId string, resourceGroupName string, accountName string, region string) RegionId

NewRegionID returns a new RegionId struct

func ParseRegionID ¶ 

func ParseRegionID(input string) (*RegionId, error)

ParseRegionID parses 'input' into a RegionId

func ParseRegionIDInsensitively ¶ 

func ParseRegionIDInsensitively(input string) (*RegionId, error)

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

func (RegionId) ID ¶ 

func (id RegionId) ID() string

ID returns the formatted Region ID

func (RegionId) Segments ¶ 

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

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

func (RegionId) String ¶ 

func (id RegionId) String() string

String returns a human-readable description of this Region ID

type RestoreMode ¶ 

type RestoreMode string
const (
	RestoreModePointInTime RestoreMode = "PointInTime"
)

type RestoreParameters ¶ 

type RestoreParameters struct {
	DatabasesToRestore    *[]DatabaseRestoreResource `json:"databasesToRestore,omitempty"`
	RestoreMode           *RestoreMode               `json:"restoreMode,omitempty"`
	RestoreSource         *string                    `json:"restoreSource,omitempty"`
	RestoreTimestampInUtc *string                    `json:"restoreTimestampInUtc,omitempty"`
}

func (*RestoreParameters) GetRestoreTimestampInUtcAsTime ¶ 

func (o *RestoreParameters) GetRestoreTimestampInUtcAsTime() (*time.Time, error)

func (*RestoreParameters) SetRestoreTimestampInUtcAsTime ¶ 

func (o *RestoreParameters) SetRestoreTimestampInUtcAsTime(input time.Time)

type ServerVersion ¶ 

type ServerVersion string
const (
	ServerVersionFourPointTwo  ServerVersion = "4.2"
	ServerVersionFourPointZero ServerVersion = "4.0"
	ServerVersionThreePointSix ServerVersion = "3.6"
	ServerVersionThreePointTwo ServerVersion = "3.2"
)

type SourceRegionTargetRegionId ¶ 

type SourceRegionTargetRegionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	SourceRegion      string
	TargetRegion      string
}

SourceRegionTargetRegionId is a struct representing the Resource ID for a Source Region Target Region

func NewSourceRegionTargetRegionID ¶ 

func NewSourceRegionTargetRegionID(subscriptionId string, resourceGroupName string, accountName string, sourceRegion string, targetRegion string) SourceRegionTargetRegionId

NewSourceRegionTargetRegionID returns a new SourceRegionTargetRegionId struct

func ParseSourceRegionTargetRegionID ¶ 

func ParseSourceRegionTargetRegionID(input string) (*SourceRegionTargetRegionId, error)

ParseSourceRegionTargetRegionID parses 'input' into a SourceRegionTargetRegionId

func ParseSourceRegionTargetRegionIDInsensitively ¶ 

func ParseSourceRegionTargetRegionIDInsensitively(input string) (*SourceRegionTargetRegionId, error)

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

func (SourceRegionTargetRegionId) ID ¶ 

func (id SourceRegionTargetRegionId) ID() string

ID returns the formatted Source Region Target Region ID

func (SourceRegionTargetRegionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Source Region Target Region ID

func (SourceRegionTargetRegionId) String ¶ 

func (id SourceRegionTargetRegionId) String() string

String returns a human-readable description of this Source Region Target Region ID

type SpatialSpec ¶ 

type SpatialSpec struct {
	Path  *string        `json:"path,omitempty"`
	Types *[]SpatialType `json:"types,omitempty"`
}

type SpatialType ¶ 

type SpatialType string
const (
	SpatialTypeLineString   SpatialType = "LineString"
	SpatialTypeMultiPolygon SpatialType = "MultiPolygon"
	SpatialTypePoint        SpatialType = "Point"
	SpatialTypePolygon      SpatialType = "Polygon"
)

type SqlContainerCreateUpdateParameters ¶ 

type SqlContainerCreateUpdateParameters struct {
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties SqlContainerCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type SqlContainerCreateUpdateProperties ¶ 

type SqlContainerCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource SqlContainerResource `json:"resource"`
}

type SqlContainerGetProperties ¶ 

type SqlContainerGetProperties struct {
	Options  *OptionsResource           `json:"options,omitempty"`
	Resource *SqlContainerGetProperties `json:"resource,omitempty"`
}

type SqlContainerGetResults ¶ 

type SqlContainerGetResults struct {
	Id         *string                    `json:"id,omitempty"`
	Location   *string                    `json:"location,omitempty"`
	Name       *string                    `json:"name,omitempty"`
	Properties *SqlContainerGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string         `json:"tags,omitempty"`
	Type       *string                    `json:"type,omitempty"`
}

type SqlContainerListResult ¶ 

type SqlContainerListResult struct {
	Value *[]SqlContainerGetResults `json:"value,omitempty"`
}

type SqlContainerResource ¶ 

type SqlContainerResource struct {
	AnalyticalStorageTtl     *int64                    `json:"analyticalStorageTtl,omitempty"`
	ConflictResolutionPolicy *ConflictResolutionPolicy `json:"conflictResolutionPolicy,omitempty"`
	DefaultTtl               *int64                    `json:"defaultTtl,omitempty"`
	Id                       string                    `json:"id"`
	IndexingPolicy           *IndexingPolicy           `json:"indexingPolicy,omitempty"`
	PartitionKey             *ContainerPartitionKey    `json:"partitionKey,omitempty"`
	UniqueKeyPolicy          *UniqueKeyPolicy          `json:"uniqueKeyPolicy,omitempty"`
}

type SqlDatabaseCreateUpdateParameters ¶ 

type SqlDatabaseCreateUpdateParameters struct {
	Id         *string                           `json:"id,omitempty"`
	Location   *string                           `json:"location,omitempty"`
	Name       *string                           `json:"name,omitempty"`
	Properties SqlDatabaseCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                `json:"tags,omitempty"`
	Type       *string                           `json:"type,omitempty"`
}

type SqlDatabaseCreateUpdateProperties ¶ 

type SqlDatabaseCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource SqlDatabaseResource  `json:"resource"`
}

type SqlDatabaseGetProperties ¶ 

type SqlDatabaseGetProperties struct {
	Options  *OptionsResource                  `json:"options,omitempty"`
	Resource *SqlDatabaseGetPropertiesResource `json:"resource,omitempty"`
}

type SqlDatabaseGetPropertiesResource ¶ 

type SqlDatabaseGetPropertiesResource struct {
	Colls *string  `json:"_colls,omitempty"`
	Etag  *string  `json:"_etag,omitempty"`
	Id    *string  `json:"id,omitempty"`
	Rid   *string  `json:"_rid,omitempty"`
	Ts    *float64 `json:"_ts,omitempty"`
	Users *string  `json:"_users,omitempty"`
}

type SqlDatabaseGetResults ¶ 

type SqlDatabaseGetResults struct {
	Id         *string                   `json:"id,omitempty"`
	Location   *string                   `json:"location,omitempty"`
	Name       *string                   `json:"name,omitempty"`
	Properties *SqlDatabaseGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string        `json:"tags,omitempty"`
	Type       *string                   `json:"type,omitempty"`
}

type SqlDatabaseId ¶ 

type SqlDatabaseId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
}

SqlDatabaseId is a struct representing the Resource ID for a Sql Database

func NewSqlDatabaseID ¶ 

func NewSqlDatabaseID(subscriptionId string, resourceGroupName string, accountName string, databaseName string) SqlDatabaseId

NewSqlDatabaseID returns a new SqlDatabaseId struct

func ParseSqlDatabaseID ¶ 

func ParseSqlDatabaseID(input string) (*SqlDatabaseId, error)

ParseSqlDatabaseID parses 'input' into a SqlDatabaseId

func ParseSqlDatabaseIDInsensitively ¶ 

func ParseSqlDatabaseIDInsensitively(input string) (*SqlDatabaseId, error)

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

func (SqlDatabaseId) ID ¶ 

func (id SqlDatabaseId) ID() string

ID returns the formatted Sql Database ID

func (SqlDatabaseId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Sql Database ID

func (SqlDatabaseId) String ¶ 

func (id SqlDatabaseId) String() string

String returns a human-readable description of this Sql Database ID

type SqlDatabaseListResult ¶ 

type SqlDatabaseListResult struct {
	Value *[]SqlDatabaseGetResults `json:"value,omitempty"`
}

type SqlDatabaseResource ¶ 

type SqlDatabaseResource struct {
	Id string `json:"id"`
}

type SqlResourcesCreateUpdateSqlContainerOperationResponse ¶ 

type SqlResourcesCreateUpdateSqlContainerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlDatabaseOperationResponse ¶ 

type SqlResourcesCreateUpdateSqlDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlStoredProcedureOperationResponse ¶ 

type SqlResourcesCreateUpdateSqlStoredProcedureOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlTriggerOperationResponse ¶ 

type SqlResourcesCreateUpdateSqlTriggerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesCreateUpdateSqlUserDefinedFunctionOperationResponse ¶ 

type SqlResourcesCreateUpdateSqlUserDefinedFunctionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlContainerOperationResponse ¶ 

type SqlResourcesDeleteSqlContainerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlDatabaseOperationResponse ¶ 

type SqlResourcesDeleteSqlDatabaseOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlStoredProcedureOperationResponse ¶ 

type SqlResourcesDeleteSqlStoredProcedureOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlTriggerOperationResponse ¶ 

type SqlResourcesDeleteSqlTriggerOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesDeleteSqlUserDefinedFunctionOperationResponse ¶ 

type SqlResourcesDeleteSqlUserDefinedFunctionOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesGetSqlContainerOperationResponse ¶ 

type SqlResourcesGetSqlContainerOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlContainerGetResults
}

type SqlResourcesGetSqlContainerThroughputOperationResponse ¶ 

type SqlResourcesGetSqlContainerThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type SqlResourcesGetSqlDatabaseOperationResponse ¶ 

type SqlResourcesGetSqlDatabaseOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlDatabaseGetResults
}

type SqlResourcesGetSqlDatabaseThroughputOperationResponse ¶ 

type SqlResourcesGetSqlDatabaseThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type SqlResourcesGetSqlStoredProcedureOperationResponse ¶ 

type SqlResourcesGetSqlStoredProcedureOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlStoredProcedureGetResults
}

type SqlResourcesGetSqlTriggerOperationResponse ¶ 

type SqlResourcesGetSqlTriggerOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlTriggerGetResults
}

type SqlResourcesGetSqlUserDefinedFunctionOperationResponse ¶ 

type SqlResourcesGetSqlUserDefinedFunctionOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlUserDefinedFunctionGetResults
}

type SqlResourcesListSqlContainersOperationResponse ¶ 

type SqlResourcesListSqlContainersOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlContainerListResult
}

type SqlResourcesListSqlDatabasesOperationResponse ¶ 

type SqlResourcesListSqlDatabasesOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlDatabaseListResult
}

type SqlResourcesListSqlStoredProceduresOperationResponse ¶ 

type SqlResourcesListSqlStoredProceduresOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlStoredProcedureListResult
}

type SqlResourcesListSqlTriggersOperationResponse ¶ 

type SqlResourcesListSqlTriggersOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlTriggerListResult
}

type SqlResourcesListSqlUserDefinedFunctionsOperationResponse ¶ 

type SqlResourcesListSqlUserDefinedFunctionsOperationResponse struct {
	HttpResponse *http.Response
	Model        *SqlUserDefinedFunctionListResult
}

type SqlResourcesMigrateSqlContainerToAutoscaleOperationResponse ¶ 

type SqlResourcesMigrateSqlContainerToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesMigrateSqlContainerToManualThroughputOperationResponse ¶ 

type SqlResourcesMigrateSqlContainerToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesMigrateSqlDatabaseToAutoscaleOperationResponse ¶ 

type SqlResourcesMigrateSqlDatabaseToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesMigrateSqlDatabaseToManualThroughputOperationResponse ¶ 

type SqlResourcesMigrateSqlDatabaseToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesUpdateSqlContainerThroughputOperationResponse ¶ 

type SqlResourcesUpdateSqlContainerThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlResourcesUpdateSqlDatabaseThroughputOperationResponse ¶ 

type SqlResourcesUpdateSqlDatabaseThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type SqlStoredProcedureCreateUpdateParameters ¶ 

type SqlStoredProcedureCreateUpdateParameters struct {
	Id         *string                                  `json:"id,omitempty"`
	Location   *string                                  `json:"location,omitempty"`
	Name       *string                                  `json:"name,omitempty"`
	Properties SqlStoredProcedureCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                       `json:"tags,omitempty"`
	Type       *string                                  `json:"type,omitempty"`
}

type SqlStoredProcedureCreateUpdateProperties ¶ 

type SqlStoredProcedureCreateUpdateProperties struct {
	Options  *CreateUpdateOptions       `json:"options,omitempty"`
	Resource SqlStoredProcedureResource `json:"resource"`
}

type SqlStoredProcedureGetProperties ¶ 

type SqlStoredProcedureGetProperties struct {
	Resource *SqlStoredProcedureGetProperties `json:"resource,omitempty"`
}

type SqlStoredProcedureGetResults ¶ 

type SqlStoredProcedureGetResults struct {
	Id         *string                          `json:"id,omitempty"`
	Location   *string                          `json:"location,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties *SqlStoredProcedureGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string               `json:"tags,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type SqlStoredProcedureListResult ¶ 

type SqlStoredProcedureListResult struct {
	Value *[]SqlStoredProcedureGetResults `json:"value,omitempty"`
}

type SqlStoredProcedureResource ¶ 

type SqlStoredProcedureResource struct {
	Body *string `json:"body,omitempty"`
	Id   string  `json:"id"`
}

type SqlTriggerCreateUpdateParameters ¶ 

type SqlTriggerCreateUpdateParameters struct {
	Id         *string                          `json:"id,omitempty"`
	Location   *string                          `json:"location,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties SqlTriggerCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string               `json:"tags,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type SqlTriggerCreateUpdateProperties ¶ 

type SqlTriggerCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource SqlTriggerResource   `json:"resource"`
}

type SqlTriggerGetProperties ¶ 

type SqlTriggerGetProperties struct {
	Resource *SqlTriggerGetProperties `json:"resource,omitempty"`
}

type SqlTriggerGetResults ¶ 

type SqlTriggerGetResults struct {
	Id         *string                  `json:"id,omitempty"`
	Location   *string                  `json:"location,omitempty"`
	Name       *string                  `json:"name,omitempty"`
	Properties *SqlTriggerGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string       `json:"tags,omitempty"`
	Type       *string                  `json:"type,omitempty"`
}

type SqlTriggerListResult ¶ 

type SqlTriggerListResult struct {
	Value *[]SqlTriggerGetResults `json:"value,omitempty"`
}

type SqlTriggerResource ¶ 

type SqlTriggerResource struct {
	Body             *string           `json:"body,omitempty"`
	Id               string            `json:"id"`
	TriggerOperation *TriggerOperation `json:"triggerOperation,omitempty"`
	TriggerType      *TriggerType      `json:"triggerType,omitempty"`
}

type SqlUserDefinedFunctionCreateUpdateParameters ¶ 

type SqlUserDefinedFunctionCreateUpdateParameters struct {
	Id         *string                                      `json:"id,omitempty"`
	Location   *string                                      `json:"location,omitempty"`
	Name       *string                                      `json:"name,omitempty"`
	Properties SqlUserDefinedFunctionCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string                           `json:"tags,omitempty"`
	Type       *string                                      `json:"type,omitempty"`
}

type SqlUserDefinedFunctionCreateUpdateProperties ¶ 

type SqlUserDefinedFunctionCreateUpdateProperties struct {
	Options  *CreateUpdateOptions           `json:"options,omitempty"`
	Resource SqlUserDefinedFunctionResource `json:"resource"`
}

type SqlUserDefinedFunctionGetProperties ¶ 

type SqlUserDefinedFunctionGetProperties struct {
	Resource *SqlUserDefinedFunctionGetProperties `json:"resource,omitempty"`
}

type SqlUserDefinedFunctionGetResults ¶ 

type SqlUserDefinedFunctionGetResults struct {
	Id         *string                              `json:"id,omitempty"`
	Location   *string                              `json:"location,omitempty"`
	Name       *string                              `json:"name,omitempty"`
	Properties *SqlUserDefinedFunctionGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string                   `json:"tags,omitempty"`
	Type       *string                              `json:"type,omitempty"`
}

type SqlUserDefinedFunctionListResult ¶ 

type SqlUserDefinedFunctionListResult struct {
	Value *[]SqlUserDefinedFunctionGetResults `json:"value,omitempty"`
}

type SqlUserDefinedFunctionResource ¶ 

type SqlUserDefinedFunctionResource struct {
	Body *string `json:"body,omitempty"`
	Id   string  `json:"id"`
}

type StoredProcedureId ¶ 

type StoredProcedureId struct {
	SubscriptionId      string
	ResourceGroupName   string
	AccountName         string
	DatabaseName        string
	ContainerName       string
	StoredProcedureName string
}

StoredProcedureId is a struct representing the Resource ID for a Stored Procedure

func NewStoredProcedureID ¶ 

func NewStoredProcedureID(subscriptionId string, resourceGroupName string, accountName string, databaseName string, containerName string, storedProcedureName string) StoredProcedureId

NewStoredProcedureID returns a new StoredProcedureId struct

func ParseStoredProcedureID ¶ 

func ParseStoredProcedureID(input string) (*StoredProcedureId, error)

ParseStoredProcedureID parses 'input' into a StoredProcedureId

func ParseStoredProcedureIDInsensitively ¶ 

func ParseStoredProcedureIDInsensitively(input string) (*StoredProcedureId, error)

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

func (StoredProcedureId) ID ¶ 

func (id StoredProcedureId) ID() string

ID returns the formatted Stored Procedure ID

func (StoredProcedureId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Stored Procedure ID

func (StoredProcedureId) String ¶ 

func (id StoredProcedureId) String() string

String returns a human-readable description of this Stored Procedure ID

type TableCreateUpdateParameters ¶ 

type TableCreateUpdateParameters struct {
	Id         *string                     `json:"id,omitempty"`
	Location   *string                     `json:"location,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties TableCreateUpdateProperties `json:"properties"`
	Tags       *map[string]string          `json:"tags,omitempty"`
	Type       *string                     `json:"type,omitempty"`
}

type TableCreateUpdateProperties ¶ 

type TableCreateUpdateProperties struct {
	Options  *CreateUpdateOptions `json:"options,omitempty"`
	Resource TableResource        `json:"resource"`
}

type TableGetProperties ¶ 

type TableGetProperties struct {
	Options  *OptionsResource    `json:"options,omitempty"`
	Resource *TableGetProperties `json:"resource,omitempty"`
}

type TableGetResults ¶ 

type TableGetResults struct {
	Id         *string             `json:"id,omitempty"`
	Location   *string             `json:"location,omitempty"`
	Name       *string             `json:"name,omitempty"`
	Properties *TableGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string  `json:"tags,omitempty"`
	Type       *string             `json:"type,omitempty"`
}

type TableId ¶ 

type TableId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	TableName         string
}

TableId is a struct representing the Resource ID for a Table

func NewTableID ¶ 

func NewTableID(subscriptionId string, resourceGroupName string, accountName string, tableName string) TableId

NewTableID returns a new TableId struct

func ParseTableID ¶ 

func ParseTableID(input string) (*TableId, error)

ParseTableID parses 'input' into a TableId

func ParseTableIDInsensitively ¶ 

func ParseTableIDInsensitively(input string) (*TableId, error)

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

func (TableId) ID ¶ 

func (id TableId) ID() string

ID returns the formatted Table ID

func (TableId) Segments ¶ 

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

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

func (TableId) String ¶ 

func (id TableId) String() string

String returns a human-readable description of this Table ID

type TableListResult ¶ 

type TableListResult struct {
	Value *[]TableGetResults `json:"value,omitempty"`
}

type TableResource ¶ 

type TableResource struct {
	Id string `json:"id"`
}

type TableResourcesCreateUpdateTableOperationResponse ¶ 

type TableResourcesCreateUpdateTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesDeleteTableOperationResponse ¶ 

type TableResourcesDeleteTableOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesGetTableOperationResponse ¶ 

type TableResourcesGetTableOperationResponse struct {
	HttpResponse *http.Response
	Model        *TableGetResults
}

type TableResourcesGetTableThroughputOperationResponse ¶ 

type TableResourcesGetTableThroughputOperationResponse struct {
	HttpResponse *http.Response
	Model        *ThroughputSettingsGetResults
}

type TableResourcesListTablesOperationResponse ¶ 

type TableResourcesListTablesOperationResponse struct {
	HttpResponse *http.Response
	Model        *TableListResult
}

type TableResourcesMigrateTableToAutoscaleOperationResponse ¶ 

type TableResourcesMigrateTableToAutoscaleOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesMigrateTableToManualThroughputOperationResponse ¶ 

type TableResourcesMigrateTableToManualThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TableResourcesUpdateTableThroughputOperationResponse ¶ 

type TableResourcesUpdateTableThroughputOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
}

type TargetRegionId ¶ 

type TargetRegionId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	TargetRegion      string
}

TargetRegionId is a struct representing the Resource ID for a Target Region

func NewTargetRegionID ¶ 

func NewTargetRegionID(subscriptionId string, resourceGroupName string, accountName string, targetRegion string) TargetRegionId

NewTargetRegionID returns a new TargetRegionId struct

func ParseTargetRegionID ¶ 

func ParseTargetRegionID(input string) (*TargetRegionId, error)

ParseTargetRegionID parses 'input' into a TargetRegionId

func ParseTargetRegionIDInsensitively ¶ 

func ParseTargetRegionIDInsensitively(input string) (*TargetRegionId, error)

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

func (TargetRegionId) ID ¶ 

func (id TargetRegionId) ID() string

ID returns the formatted Target Region ID

func (TargetRegionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this Target Region ID

func (TargetRegionId) String ¶ 

func (id TargetRegionId) String() string

String returns a human-readable description of this Target Region ID

type ThroughputPolicyResource ¶ 

type ThroughputPolicyResource struct {
	IncrementPercent *int64 `json:"incrementPercent,omitempty"`
	IsEnabled        *bool  `json:"isEnabled,omitempty"`
}

type ThroughputSettingsGetProperties ¶ 

type ThroughputSettingsGetProperties struct {
	Resource *ThroughputSettingsGetProperties `json:"resource,omitempty"`
}

type ThroughputSettingsGetResults ¶ 

type ThroughputSettingsGetResults struct {
	Id         *string                          `json:"id,omitempty"`
	Location   *string                          `json:"location,omitempty"`
	Name       *string                          `json:"name,omitempty"`
	Properties *ThroughputSettingsGetProperties `json:"properties,omitempty"`
	Tags       *map[string]string               `json:"tags,omitempty"`
	Type       *string                          `json:"type,omitempty"`
}

type ThroughputSettingsResource ¶ 

type ThroughputSettingsResource struct {
	AutoScaleSettings   *AutoscaleSettingsResource `json:"autoscaleSettings,omitempty"`
	MinimumThroughput   *string                    `json:"minimumThroughput,omitempty"`
	OfferReplacePending *string                    `json:"offerReplacePending,omitempty"`
	Throughput          *int64                     `json:"throughput,omitempty"`
}

type ThroughputSettingsUpdateParameters ¶ 

type ThroughputSettingsUpdateParameters struct {
	Id         *string                            `json:"id,omitempty"`
	Location   *string                            `json:"location,omitempty"`
	Name       *string                            `json:"name,omitempty"`
	Properties ThroughputSettingsUpdateProperties `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
}

type ThroughputSettingsUpdateProperties ¶ 

type ThroughputSettingsUpdateProperties struct {
	Resource ThroughputSettingsResource `json:"resource"`
}

type TriggerId ¶ 

type TriggerId struct {
	SubscriptionId    string
	ResourceGroupName string
	AccountName       string
	DatabaseName      string
	ContainerName     string
	TriggerName       string
}

TriggerId is a struct representing the Resource ID for a Trigger

func NewTriggerID ¶ 

func NewTriggerID(subscriptionId string, resourceGroupName string, accountName string, databaseName string, containerName string, triggerName string) TriggerId

NewTriggerID returns a new TriggerId struct

func ParseTriggerID ¶ 

func ParseTriggerID(input string) (*TriggerId, error)

ParseTriggerID parses 'input' into a TriggerId

func ParseTriggerIDInsensitively ¶ 

func ParseTriggerIDInsensitively(input string) (*TriggerId, error)

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

func (TriggerId) ID ¶ 

func (id TriggerId) ID() string

ID returns the formatted Trigger ID

func (TriggerId) Segments ¶ 

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

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

func (TriggerId) String ¶ 

func (id TriggerId) String() string

String returns a human-readable description of this Trigger ID

type TriggerOperation ¶ 

type TriggerOperation string
const (
	TriggerOperationAll     TriggerOperation = "All"
	TriggerOperationCreate  TriggerOperation = "Create"
	TriggerOperationDelete  TriggerOperation = "Delete"
	TriggerOperationReplace TriggerOperation = "Replace"
	TriggerOperationUpdate  TriggerOperation = "Update"
)

type TriggerType ¶ 

type TriggerType string
const (
	TriggerTypePost TriggerType = "Post"
	TriggerTypePre  TriggerType = "Pre"
)

type UniqueKey ¶ 

type UniqueKey struct {
	Paths *[]string `json:"paths,omitempty"`
}

type UniqueKeyPolicy ¶ 

type UniqueKeyPolicy struct {
	UniqueKeys *[]UniqueKey `json:"uniqueKeys,omitempty"`
}

type UnitType ¶ 

type UnitType string
const (
	UnitTypeBytes          UnitType = "Bytes"
	UnitTypeBytesPerSecond UnitType = "BytesPerSecond"
	UnitTypeCount          UnitType = "Count"
	UnitTypeCountPerSecond UnitType = "CountPerSecond"
	UnitTypeMilliseconds   UnitType = "Milliseconds"
	UnitTypePercent        UnitType = "Percent"
	UnitTypeSeconds        UnitType = "Seconds"
)

type Usage ¶ 

type Usage struct {
	CurrentValue *int64      `json:"currentValue,omitempty"`
	Limit        *int64      `json:"limit,omitempty"`
	Name         *MetricName `json:"name,omitempty"`
	QuotaPeriod  *string     `json:"quotaPeriod,omitempty"`
	Unit         *UnitType   `json:"unit,omitempty"`
}

type UsagesResult ¶ 

type UsagesResult struct {
	Value *[]Usage `json:"value,omitempty"`
}

type UserDefinedFunctionId ¶ 

type UserDefinedFunctionId struct {
	SubscriptionId          string
	ResourceGroupName       string
	AccountName             string
	DatabaseName            string
	ContainerName           string
	UserDefinedFunctionName string
}

UserDefinedFunctionId is a struct representing the Resource ID for a User Defined Function

func NewUserDefinedFunctionID ¶ 

func NewUserDefinedFunctionID(subscriptionId string, resourceGroupName string, accountName string, databaseName string, containerName string, userDefinedFunctionName string) UserDefinedFunctionId

NewUserDefinedFunctionID returns a new UserDefinedFunctionId struct

func ParseUserDefinedFunctionID ¶ 

func ParseUserDefinedFunctionID(input string) (*UserDefinedFunctionId, error)

ParseUserDefinedFunctionID parses 'input' into a UserDefinedFunctionId

func ParseUserDefinedFunctionIDInsensitively ¶ 

func ParseUserDefinedFunctionIDInsensitively(input string) (*UserDefinedFunctionId, error)

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

func (UserDefinedFunctionId) ID ¶ 

func (id UserDefinedFunctionId) ID() string

ID returns the formatted User Defined Function ID

func (UserDefinedFunctionId) Segments ¶ 

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

Segments returns a slice of Resource ID Segments which comprise this User Defined Function ID

func (UserDefinedFunctionId) String ¶ 

func (id UserDefinedFunctionId) String() string

String returns a human-readable description of this User Defined Function ID

type VirtualNetworkRule ¶ 

type VirtualNetworkRule struct {
	Id                               *string `json:"id,omitempty"`
	IgnoreMissingVNetServiceEndpoint *bool   `json:"ignoreMissingVNetServiceEndpoint,omitempty"`
}

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.