redis

package
v0.20230418.1121253 Latest Latest
Warning

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

 Go to latest Published: Apr 18, 2023 License: MPL-2.0 Imports: 14 Imported by: 0

README

github.com/hashicorp/go-azure-sdk/resource-manager/redis/2022-06-01/redis Documentation

The redis SDK allows for interaction with the Azure Resource Manager Service redis (API Version 2022-06-01).

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

Import Path

import "github.com/hashicorp/go-azure-sdk/resource-manager/redis/2022-06-01/redis"

Client Initialization

client := redis.NewRedisClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: RedisClient.CheckNameAvailability

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

payload := redis.CheckNameAvailabilityParameters{
	// ...
}


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

Example Usage: RedisClient.Create

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

payload := redis.RedisCreateParameters{
	// ...
}


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

Example Usage: RedisClient.Delete

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

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

Example Usage: RedisClient.ExportData

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

payload := redis.ExportRDBParameters{
	// ...
}


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

Example Usage: RedisClient.FirewallRulesCreateOrUpdate

ctx := context.TODO()
id := redis.NewFirewallRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "redisValue", "firewallRuleValue")

payload := redis.RedisFirewallRule{
	// ...
}


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

Example Usage: RedisClient.FirewallRulesDelete

ctx := context.TODO()
id := redis.NewFirewallRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "redisValue", "firewallRuleValue")

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

Example Usage: RedisClient.FirewallRulesGet

ctx := context.TODO()
id := redis.NewFirewallRuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "redisValue", "firewallRuleValue")

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

Example Usage: RedisClient.FirewallRulesList

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

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

Example Usage: RedisClient.ForceReboot

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

payload := redis.RedisRebootParameters{
	// ...
}


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

Example Usage: RedisClient.Get

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

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

Example Usage: RedisClient.ImportData

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

payload := redis.ImportRDBParameters{
	// ...
}


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

Example Usage: RedisClient.LinkedServerCreate

ctx := context.TODO()
id := redis.NewLinkedServerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "redisValue", "linkedServerValue")

payload := redis.RedisLinkedServerCreateParameters{
	// ...
}


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

Example Usage: RedisClient.LinkedServerDelete

ctx := context.TODO()
id := redis.NewLinkedServerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "redisValue", "linkedServerValue")

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

Example Usage: RedisClient.LinkedServerGet

ctx := context.TODO()
id := redis.NewLinkedServerID("12345678-1234-9876-4563-123456789012", "example-resource-group", "redisValue", "linkedServerValue")

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

Example Usage: RedisClient.LinkedServerList

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

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

Example Usage: RedisClient.ListByResourceGroup

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

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

Example Usage: RedisClient.ListBySubscription

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

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

Example Usage: RedisClient.ListKeys

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

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

Example Usage: RedisClient.ListUpgradeNotifications

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

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

Example Usage: RedisClient.PatchSchedulesCreateOrUpdate

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

payload := redis.RedisPatchSchedule{
	// ...
}


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

Example Usage: RedisClient.PatchSchedulesDelete

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

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

Example Usage: RedisClient.PatchSchedulesGet

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

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

Example Usage: RedisClient.PatchSchedulesListByRedisResource

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

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

Example Usage: RedisClient.RegenerateKey

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

payload := redis.RedisRegenerateKeyParameters{
	// ...
}


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

Example Usage: RedisClient.Update

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

payload := redis.RedisUpdateParameters{
	// ...
}


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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForDayOfWeek 

func PossibleValuesForDayOfWeek() []string

func PossibleValuesForPrivateEndpointConnectionProvisioningState 

func PossibleValuesForPrivateEndpointConnectionProvisioningState() []string

func PossibleValuesForPrivateEndpointServiceConnectionStatus 

func PossibleValuesForPrivateEndpointServiceConnectionStatus() []string

func PossibleValuesForProvisioningState 

func PossibleValuesForProvisioningState() []string

func PossibleValuesForPublicNetworkAccess 

func PossibleValuesForPublicNetworkAccess() []string

func PossibleValuesForRebootType 

func PossibleValuesForRebootType() []string

func PossibleValuesForRedisKeyType 

func PossibleValuesForRedisKeyType() []string

func PossibleValuesForReplicationRole 

func PossibleValuesForReplicationRole() []string

func PossibleValuesForSkuFamily 

func PossibleValuesForSkuFamily() []string

func PossibleValuesForSkuName 

func PossibleValuesForSkuName() []string

func PossibleValuesForTlsVersion 

func PossibleValuesForTlsVersion() []string

func ValidateFirewallRuleID 

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

ValidateFirewallRuleID checks that 'input' can be parsed as a Firewall Rule ID

func ValidateLinkedServerID 

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

ValidateLinkedServerID checks that 'input' can be parsed as a Linked Server ID

func ValidateRediID 

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

ValidateRediID checks that 'input' can be parsed as a Redi ID

Types

type CheckNameAvailabilityOperationResponse 

type CheckNameAvailabilityOperationResponse struct {
	HttpResponse *http.Response
}

type CheckNameAvailabilityParameters 

type CheckNameAvailabilityParameters struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type CreateOperationResponse 

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

type DayOfWeek 

type DayOfWeek string
const (
	DayOfWeekEveryday  DayOfWeek = "Everyday"
	DayOfWeekFriday    DayOfWeek = "Friday"
	DayOfWeekMonday    DayOfWeek = "Monday"
	DayOfWeekSaturday  DayOfWeek = "Saturday"
	DayOfWeekSunday    DayOfWeek = "Sunday"
	DayOfWeekThursday  DayOfWeek = "Thursday"
	DayOfWeekTuesday   DayOfWeek = "Tuesday"
	DayOfWeekWednesday DayOfWeek = "Wednesday"
	DayOfWeekWeekend   DayOfWeek = "Weekend"
)

type DeleteOperationResponse 

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

type ExportDataOperationResponse 

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

type ExportRDBParameters 

type ExportRDBParameters struct {
	Container                      string  `json:"container"`
	Format                         *string `json:"format,omitempty"`
	PreferredDataArchiveAuthMethod *string `json:"preferred-data-archive-auth-method,omitempty"`
	Prefix                         string  `json:"prefix"`
}

type FirewallRuleId 

type FirewallRuleId struct {
	SubscriptionId    string
	ResourceGroupName string
	RedisName         string
	FirewallRuleName  string
}

FirewallRuleId is a struct representing the Resource ID for a Firewall Rule

func NewFirewallRuleID 

func NewFirewallRuleID(subscriptionId string, resourceGroupName string, redisName string, firewallRuleName string) FirewallRuleId

NewFirewallRuleID returns a new FirewallRuleId struct

func ParseFirewallRuleID 

func ParseFirewallRuleID(input string) (*FirewallRuleId, error)

ParseFirewallRuleID parses 'input' into a FirewallRuleId

func ParseFirewallRuleIDInsensitively 

func ParseFirewallRuleIDInsensitively(input string) (*FirewallRuleId, error)

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

func (FirewallRuleId) ID 

func (id FirewallRuleId) ID() string

ID returns the formatted Firewall Rule ID

func (FirewallRuleId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Firewall Rule ID

func (FirewallRuleId) String 

func (id FirewallRuleId) String() string

String returns a human-readable description of this Firewall Rule ID

type FirewallRulesCreateOrUpdateOperationResponse 

type FirewallRulesCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisFirewallRule
}

type FirewallRulesDeleteOperationResponse 

type FirewallRulesDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type FirewallRulesGetOperationResponse 

type FirewallRulesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisFirewallRule
}

type FirewallRulesListCompleteResult 

type FirewallRulesListCompleteResult struct {
	Items []RedisFirewallRule
}

type FirewallRulesListOperationResponse 

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

func (FirewallRulesListOperationResponse) HasMore 

func (r FirewallRulesListOperationResponse) HasMore() bool

func (FirewallRulesListOperationResponse) LoadMore 

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

type ForceRebootOperationResponse 

type ForceRebootOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisForceRebootResponse
}

type GetOperationResponse 

type GetOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisResource
}

type ImportDataOperationResponse 

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

type ImportRDBParameters 

type ImportRDBParameters struct {
	Files                          []string `json:"files"`
	Format                         *string  `json:"format,omitempty"`
	PreferredDataArchiveAuthMethod *string  `json:"preferred-data-archive-auth-method,omitempty"`
}

type LinkedServerCreateOperationResponse 

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

type LinkedServerDeleteOperationResponse 

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

type LinkedServerGetOperationResponse 

type LinkedServerGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisLinkedServerWithProperties
}

type LinkedServerId 

type LinkedServerId struct {
	SubscriptionId    string
	ResourceGroupName string
	RedisName         string
	LinkedServerName  string
}

LinkedServerId is a struct representing the Resource ID for a Linked Server

func NewLinkedServerID 

func NewLinkedServerID(subscriptionId string, resourceGroupName string, redisName string, linkedServerName string) LinkedServerId

NewLinkedServerID returns a new LinkedServerId struct

func ParseLinkedServerID 

func ParseLinkedServerID(input string) (*LinkedServerId, error)

ParseLinkedServerID parses 'input' into a LinkedServerId

func ParseLinkedServerIDInsensitively 

func ParseLinkedServerIDInsensitively(input string) (*LinkedServerId, error)

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

func (LinkedServerId) ID 

func (id LinkedServerId) ID() string

ID returns the formatted Linked Server ID

func (LinkedServerId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Linked Server ID

func (LinkedServerId) String 

func (id LinkedServerId) String() string

String returns a human-readable description of this Linked Server ID

type LinkedServerListCompleteResult 

type LinkedServerListCompleteResult struct {
	Items []RedisLinkedServerWithProperties
}

type LinkedServerListOperationResponse 

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

func (LinkedServerListOperationResponse) HasMore 

func (r LinkedServerListOperationResponse) HasMore() bool

func (LinkedServerListOperationResponse) LoadMore 

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

type ListByResourceGroupCompleteResult 

type ListByResourceGroupCompleteResult struct {
	Items []RedisResource
}

type ListByResourceGroupOperationResponse 

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

func (ListByResourceGroupOperationResponse) HasMore 

func (r ListByResourceGroupOperationResponse) HasMore() bool

func (ListByResourceGroupOperationResponse) LoadMore 

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

type ListBySubscriptionCompleteResult 

type ListBySubscriptionCompleteResult struct {
	Items []RedisResource
}

type ListBySubscriptionOperationResponse 

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

func (ListBySubscriptionOperationResponse) HasMore 

func (r ListBySubscriptionOperationResponse) HasMore() bool

func (ListBySubscriptionOperationResponse) LoadMore 

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

type ListKeysOperationResponse 

type ListKeysOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisAccessKeys
}

type ListUpgradeNotificationsCompleteResult 

type ListUpgradeNotificationsCompleteResult struct {
	Items []UpgradeNotification
}

type ListUpgradeNotificationsOperationOptions 

type ListUpgradeNotificationsOperationOptions struct {
	History *float64
}

func DefaultListUpgradeNotificationsOperationOptions 

func DefaultListUpgradeNotificationsOperationOptions() ListUpgradeNotificationsOperationOptions

type ListUpgradeNotificationsOperationResponse 

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

func (ListUpgradeNotificationsOperationResponse) HasMore 

func (r ListUpgradeNotificationsOperationResponse) HasMore() bool

func (ListUpgradeNotificationsOperationResponse) LoadMore 

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

type PatchSchedulesCreateOrUpdateOperationResponse 

type PatchSchedulesCreateOrUpdateOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisPatchSchedule
}

type PatchSchedulesDeleteOperationResponse 

type PatchSchedulesDeleteOperationResponse struct {
	HttpResponse *http.Response
}

type PatchSchedulesGetOperationResponse 

type PatchSchedulesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisPatchSchedule
}

type PatchSchedulesListByRedisResourceCompleteResult 

type PatchSchedulesListByRedisResourceCompleteResult struct {
	Items []RedisPatchSchedule
}

type PatchSchedulesListByRedisResourceOperationResponse 

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

func (PatchSchedulesListByRedisResourceOperationResponse) HasMore 

func (r PatchSchedulesListByRedisResourceOperationResponse) HasMore() bool

func (PatchSchedulesListByRedisResourceOperationResponse) LoadMore 

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

type PrivateEndpoint 

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

type PrivateEndpointConnection 

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

type PrivateEndpointConnectionProperties 

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

type PrivateEndpointConnectionProvisioningState 

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

type PrivateEndpointServiceConnectionStatus 

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

type PrivateLinkServiceConnectionState 

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

type ProvisioningState 

type ProvisioningState string
const (
	ProvisioningStateCreating               ProvisioningState = "Creating"
	ProvisioningStateDeleting               ProvisioningState = "Deleting"
	ProvisioningStateDisabled               ProvisioningState = "Disabled"
	ProvisioningStateFailed                 ProvisioningState = "Failed"
	ProvisioningStateLinking                ProvisioningState = "Linking"
	ProvisioningStateProvisioning           ProvisioningState = "Provisioning"
	ProvisioningStateRecoveringScaleFailure ProvisioningState = "RecoveringScaleFailure"
	ProvisioningStateScaling                ProvisioningState = "Scaling"
	ProvisioningStateSucceeded              ProvisioningState = "Succeeded"
	ProvisioningStateUnlinking              ProvisioningState = "Unlinking"
	ProvisioningStateUnprovisioning         ProvisioningState = "Unprovisioning"
	ProvisioningStateUpdating               ProvisioningState = "Updating"
)

type PublicNetworkAccess 

type PublicNetworkAccess string
const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

type RebootType 

type RebootType string
const (
	RebootTypeAllNodes      RebootType = "AllNodes"
	RebootTypePrimaryNode   RebootType = "PrimaryNode"
	RebootTypeSecondaryNode RebootType = "SecondaryNode"
)

type RediId 

type RediId struct {
	SubscriptionId    string
	ResourceGroupName string
	RedisName         string
}

RediId is a struct representing the Resource ID for a Redi

func NewRediID 

func NewRediID(subscriptionId string, resourceGroupName string, redisName string) RediId

NewRediID returns a new RediId struct

func ParseRediID 

func ParseRediID(input string) (*RediId, error)

ParseRediID parses 'input' into a RediId

func ParseRediIDInsensitively 

func ParseRediIDInsensitively(input string) (*RediId, error)

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

func (RediId) ID 

func (id RediId) ID() string

ID returns the formatted Redi ID

func (RediId) Segments 

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

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

func (RediId) String 

func (id RediId) String() string

String returns a human-readable description of this Redi ID

type RedisAccessKeys 

type RedisAccessKeys struct {
	PrimaryKey   *string `json:"primaryKey,omitempty"`
	SecondaryKey *string `json:"secondaryKey,omitempty"`
}

type RedisClient 

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

func NewRedisClientWithBaseURI 

func NewRedisClientWithBaseURI(endpoint string) RedisClient

func (RedisClient) CheckNameAvailability 

func (c RedisClient) CheckNameAvailability(ctx context.Context, id commonids.SubscriptionId, input CheckNameAvailabilityParameters) (result CheckNameAvailabilityOperationResponse, err error)

CheckNameAvailability ...

func (RedisClient) Create 

func (c RedisClient) Create(ctx context.Context, id RediId, input RedisCreateParameters) (result CreateOperationResponse, err error)

Create ...

func (RedisClient) CreateThenPoll 

func (c RedisClient) CreateThenPoll(ctx context.Context, id RediId, input RedisCreateParameters) error

CreateThenPoll performs Create then polls until it's completed

func (RedisClient) Delete 

func (c RedisClient) Delete(ctx context.Context, id RediId) (result DeleteOperationResponse, err error)

Delete ...

func (RedisClient) DeleteThenPoll 

func (c RedisClient) DeleteThenPoll(ctx context.Context, id RediId) error

DeleteThenPoll performs Delete then polls until it's completed

func (RedisClient) ExportData 

func (c RedisClient) ExportData(ctx context.Context, id RediId, input ExportRDBParameters) (result ExportDataOperationResponse, err error)

ExportData ...

func (RedisClient) ExportDataThenPoll 

func (c RedisClient) ExportDataThenPoll(ctx context.Context, id RediId, input ExportRDBParameters) error

ExportDataThenPoll performs ExportData then polls until it's completed

func (RedisClient) FirewallRulesCreateOrUpdate 

func (c RedisClient) FirewallRulesCreateOrUpdate(ctx context.Context, id FirewallRuleId, input RedisFirewallRule) (result FirewallRulesCreateOrUpdateOperationResponse, err error)

FirewallRulesCreateOrUpdate ...

func (RedisClient) FirewallRulesDelete 

func (c RedisClient) FirewallRulesDelete(ctx context.Context, id FirewallRuleId) (result FirewallRulesDeleteOperationResponse, err error)

FirewallRulesDelete ...

func (RedisClient) FirewallRulesGet 

func (c RedisClient) FirewallRulesGet(ctx context.Context, id FirewallRuleId) (result FirewallRulesGetOperationResponse, err error)

FirewallRulesGet ...

func (RedisClient) FirewallRulesList 

func (c RedisClient) FirewallRulesList(ctx context.Context, id RediId) (resp FirewallRulesListOperationResponse, err error)

FirewallRulesList ...

func (RedisClient) FirewallRulesListComplete 

func (c RedisClient) FirewallRulesListComplete(ctx context.Context, id RediId) (FirewallRulesListCompleteResult, error)

FirewallRulesListComplete retrieves all of the results into a single object

func (RedisClient) FirewallRulesListCompleteMatchingPredicate 

func (c RedisClient) FirewallRulesListCompleteMatchingPredicate(ctx context.Context, id RediId, predicate RedisFirewallRuleOperationPredicate) (resp FirewallRulesListCompleteResult, err error)

FirewallRulesListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (RedisClient) ForceReboot 

func (c RedisClient) ForceReboot(ctx context.Context, id RediId, input RedisRebootParameters) (result ForceRebootOperationResponse, err error)

ForceReboot ...

func (RedisClient) Get 

func (c RedisClient) Get(ctx context.Context, id RediId) (result GetOperationResponse, err error)

Get ...

func (RedisClient) ImportData 

func (c RedisClient) ImportData(ctx context.Context, id RediId, input ImportRDBParameters) (result ImportDataOperationResponse, err error)

ImportData ...

func (RedisClient) ImportDataThenPoll 

func (c RedisClient) ImportDataThenPoll(ctx context.Context, id RediId, input ImportRDBParameters) error

ImportDataThenPoll performs ImportData then polls until it's completed

func (RedisClient) LinkedServerCreate 

func (c RedisClient) LinkedServerCreate(ctx context.Context, id LinkedServerId, input RedisLinkedServerCreateParameters) (result LinkedServerCreateOperationResponse, err error)

LinkedServerCreate ...

func (RedisClient) LinkedServerCreateThenPoll 

func (c RedisClient) LinkedServerCreateThenPoll(ctx context.Context, id LinkedServerId, input RedisLinkedServerCreateParameters) error

LinkedServerCreateThenPoll performs LinkedServerCreate then polls until it's completed

func (RedisClient) LinkedServerDelete 

func (c RedisClient) LinkedServerDelete(ctx context.Context, id LinkedServerId) (result LinkedServerDeleteOperationResponse, err error)

LinkedServerDelete ...

func (RedisClient) LinkedServerDeleteThenPoll 

func (c RedisClient) LinkedServerDeleteThenPoll(ctx context.Context, id LinkedServerId) error

LinkedServerDeleteThenPoll performs LinkedServerDelete then polls until it's completed

func (RedisClient) LinkedServerGet 

func (c RedisClient) LinkedServerGet(ctx context.Context, id LinkedServerId) (result LinkedServerGetOperationResponse, err error)

LinkedServerGet ...

func (RedisClient) LinkedServerList 

func (c RedisClient) LinkedServerList(ctx context.Context, id RediId) (resp LinkedServerListOperationResponse, err error)

LinkedServerList ...

func (RedisClient) LinkedServerListComplete 

func (c RedisClient) LinkedServerListComplete(ctx context.Context, id RediId) (LinkedServerListCompleteResult, error)

LinkedServerListComplete retrieves all of the results into a single object

func (RedisClient) LinkedServerListCompleteMatchingPredicate 

func (c RedisClient) LinkedServerListCompleteMatchingPredicate(ctx context.Context, id RediId, predicate RedisLinkedServerWithPropertiesOperationPredicate) (resp LinkedServerListCompleteResult, err error)

LinkedServerListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (RedisClient) ListByResourceGroup 

func (c RedisClient) ListByResourceGroup(ctx context.Context, id commonids.ResourceGroupId) (resp ListByResourceGroupOperationResponse, err error)

ListByResourceGroup ...

func (RedisClient) ListByResourceGroupComplete 

func (c RedisClient) ListByResourceGroupComplete(ctx context.Context, id commonids.ResourceGroupId) (ListByResourceGroupCompleteResult, error)

ListByResourceGroupComplete retrieves all of the results into a single object

func (RedisClient) ListByResourceGroupCompleteMatchingPredicate 

func (c RedisClient) ListByResourceGroupCompleteMatchingPredicate(ctx context.Context, id commonids.ResourceGroupId, predicate RedisResourceOperationPredicate) (resp ListByResourceGroupCompleteResult, err error)

ListByResourceGroupCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (RedisClient) ListBySubscription 

func (c RedisClient) ListBySubscription(ctx context.Context, id commonids.SubscriptionId) (resp ListBySubscriptionOperationResponse, err error)

ListBySubscription ...

func (RedisClient) ListBySubscriptionComplete 

func (c RedisClient) ListBySubscriptionComplete(ctx context.Context, id commonids.SubscriptionId) (ListBySubscriptionCompleteResult, error)

ListBySubscriptionComplete retrieves all of the results into a single object

func (RedisClient) ListBySubscriptionCompleteMatchingPredicate 

func (c RedisClient) ListBySubscriptionCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate RedisResourceOperationPredicate) (resp ListBySubscriptionCompleteResult, err error)

ListBySubscriptionCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (RedisClient) ListKeys 

func (c RedisClient) ListKeys(ctx context.Context, id RediId) (result ListKeysOperationResponse, err error)

ListKeys ...

func (RedisClient) ListUpgradeNotifications 

func (c RedisClient) ListUpgradeNotifications(ctx context.Context, id RediId, options ListUpgradeNotificationsOperationOptions) (resp ListUpgradeNotificationsOperationResponse, err error)

ListUpgradeNotifications ...

func (RedisClient) ListUpgradeNotificationsComplete 

func (c RedisClient) ListUpgradeNotificationsComplete(ctx context.Context, id RediId, options ListUpgradeNotificationsOperationOptions) (ListUpgradeNotificationsCompleteResult, error)

ListUpgradeNotificationsComplete retrieves all of the results into a single object

func (RedisClient) ListUpgradeNotificationsCompleteMatchingPredicate 

func (c RedisClient) ListUpgradeNotificationsCompleteMatchingPredicate(ctx context.Context, id RediId, options ListUpgradeNotificationsOperationOptions, predicate UpgradeNotificationOperationPredicate) (resp ListUpgradeNotificationsCompleteResult, err error)

ListUpgradeNotificationsCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (RedisClient) PatchSchedulesCreateOrUpdate 

func (c RedisClient) PatchSchedulesCreateOrUpdate(ctx context.Context, id RediId, input RedisPatchSchedule) (result PatchSchedulesCreateOrUpdateOperationResponse, err error)

PatchSchedulesCreateOrUpdate ...

func (RedisClient) PatchSchedulesDelete 

func (c RedisClient) PatchSchedulesDelete(ctx context.Context, id RediId) (result PatchSchedulesDeleteOperationResponse, err error)

PatchSchedulesDelete ...

func (RedisClient) PatchSchedulesGet 

func (c RedisClient) PatchSchedulesGet(ctx context.Context, id RediId) (result PatchSchedulesGetOperationResponse, err error)

PatchSchedulesGet ...

func (RedisClient) PatchSchedulesListByRedisResource 

func (c RedisClient) PatchSchedulesListByRedisResource(ctx context.Context, id RediId) (resp PatchSchedulesListByRedisResourceOperationResponse, err error)

PatchSchedulesListByRedisResource ...

func (RedisClient) PatchSchedulesListByRedisResourceComplete 

func (c RedisClient) PatchSchedulesListByRedisResourceComplete(ctx context.Context, id RediId) (PatchSchedulesListByRedisResourceCompleteResult, error)

PatchSchedulesListByRedisResourceComplete retrieves all of the results into a single object

func (RedisClient) PatchSchedulesListByRedisResourceCompleteMatchingPredicate 

func (c RedisClient) PatchSchedulesListByRedisResourceCompleteMatchingPredicate(ctx context.Context, id RediId, predicate RedisPatchScheduleOperationPredicate) (resp PatchSchedulesListByRedisResourceCompleteResult, err error)

PatchSchedulesListByRedisResourceCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (RedisClient) RegenerateKey 

func (c RedisClient) RegenerateKey(ctx context.Context, id RediId, input RedisRegenerateKeyParameters) (result RegenerateKeyOperationResponse, err error)

RegenerateKey ...

func (RedisClient) Update 

func (c RedisClient) Update(ctx context.Context, id RediId, input RedisUpdateParameters) (result UpdateOperationResponse, err error)

Update ...

func (RedisClient) UpdateThenPoll 

func (c RedisClient) UpdateThenPoll(ctx context.Context, id RediId, input RedisUpdateParameters) error

UpdateThenPoll performs Update then polls until it's completed

type RedisCommonPropertiesRedisConfiguration 

type RedisCommonPropertiesRedisConfiguration struct {
	AofBackupEnabled                   *string `json:"aof-backup-enabled,omitempty"`
	AofStorageConnectionString0        *string `json:"aof-storage-connection-string-0,omitempty"`
	AofStorageConnectionString1        *string `json:"aof-storage-connection-string-1,omitempty"`
	Authnotrequired                    *string `json:"authnotrequired,omitempty"`
	Maxclients                         *string `json:"maxclients,omitempty"`
	MaxfragmentationmemoryReserved     *string `json:"maxfragmentationmemory-reserved,omitempty"`
	MaxmemoryDelta                     *string `json:"maxmemory-delta,omitempty"`
	MaxmemoryPolicy                    *string `json:"maxmemory-policy,omitempty"`
	MaxmemoryReserved                  *string `json:"maxmemory-reserved,omitempty"`
	NotifyKeyspaceEvents               *string `json:"notify-keyspace-events,omitempty"`
	PreferredDataArchiveAuthMethod     *string `json:"preferred-data-archive-auth-method,omitempty"`
	PreferredDataPersistenceAuthMethod *string `json:"preferred-data-persistence-auth-method,omitempty"`
	RdbBackupEnabled                   *string `json:"rdb-backup-enabled,omitempty"`
	RdbBackupFrequency                 *string `json:"rdb-backup-frequency,omitempty"`
	RdbBackupMaxSnapshotCount          *string `json:"rdb-backup-max-snapshot-count,omitempty"`
	RdbStorageConnectionString         *string `json:"rdb-storage-connection-string,omitempty"`
	ZonalConfiguration                 *string `json:"zonal-configuration,omitempty"`
}

type RedisCreateParameters 

type RedisCreateParameters struct {
	Identity   *identity.SystemAndUserAssignedMap `json:"identity,omitempty"`
	Location   string                             `json:"location"`
	Properties RedisCreateProperties              `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Zones      *zones.Schema                      `json:"zones,omitempty"`
}

type RedisCreateProperties 

type RedisCreateProperties struct {
	EnableNonSslPort    *bool                                    `json:"enableNonSslPort,omitempty"`
	MinimumTlsVersion   *TlsVersion                              `json:"minimumTlsVersion,omitempty"`
	PublicNetworkAccess *PublicNetworkAccess                     `json:"publicNetworkAccess,omitempty"`
	RedisConfiguration  *RedisCommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`
	RedisVersion        *string                                  `json:"redisVersion,omitempty"`
	ReplicasPerMaster   *int64                                   `json:"replicasPerMaster,omitempty"`
	ReplicasPerPrimary  *int64                                   `json:"replicasPerPrimary,omitempty"`
	ShardCount          *int64                                   `json:"shardCount,omitempty"`
	Sku                 Sku                                      `json:"sku"`
	StaticIP            *string                                  `json:"staticIP,omitempty"`
	SubnetId            *string                                  `json:"subnetId,omitempty"`
	TenantSettings      *map[string]string                       `json:"tenantSettings,omitempty"`
}

type RedisFirewallRule 

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

type RedisFirewallRuleOperationPredicate 

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

func (RedisFirewallRuleOperationPredicate) Matches 

func (p RedisFirewallRuleOperationPredicate) Matches(input RedisFirewallRule) bool

type RedisFirewallRuleProperties 

type RedisFirewallRuleProperties struct {
	EndIP   string `json:"endIP"`
	StartIP string `json:"startIP"`
}

type RedisForceRebootResponse 

type RedisForceRebootResponse struct {
	Message *string `json:"message,omitempty"`
}

type RedisInstanceDetails 

type RedisInstanceDetails struct {
	IsMaster   *bool   `json:"isMaster,omitempty"`
	IsPrimary  *bool   `json:"isPrimary,omitempty"`
	NonSslPort *int64  `json:"nonSslPort,omitempty"`
	ShardId    *int64  `json:"shardId,omitempty"`
	SslPort    *int64  `json:"sslPort,omitempty"`
	Zone       *string `json:"zone,omitempty"`
}

type RedisKeyType 

type RedisKeyType string
const (
	RedisKeyTypePrimary   RedisKeyType = "Primary"
	RedisKeyTypeSecondary RedisKeyType = "Secondary"
)

type RedisLinkedServer 

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

type RedisLinkedServerCreateParameters 

type RedisLinkedServerCreateParameters struct {
	Properties RedisLinkedServerCreateProperties `json:"properties"`
}

type RedisLinkedServerCreateProperties 

type RedisLinkedServerCreateProperties struct {
	GeoReplicatedPrimaryHostName *string         `json:"geoReplicatedPrimaryHostName,omitempty"`
	LinkedRedisCacheId           string          `json:"linkedRedisCacheId"`
	LinkedRedisCacheLocation     string          `json:"linkedRedisCacheLocation"`
	PrimaryHostName              *string         `json:"primaryHostName,omitempty"`
	ServerRole                   ReplicationRole `json:"serverRole"`
}

type RedisLinkedServerProperties 

type RedisLinkedServerProperties struct {
	GeoReplicatedPrimaryHostName *string         `json:"geoReplicatedPrimaryHostName,omitempty"`
	LinkedRedisCacheId           string          `json:"linkedRedisCacheId"`
	LinkedRedisCacheLocation     string          `json:"linkedRedisCacheLocation"`
	PrimaryHostName              *string         `json:"primaryHostName,omitempty"`
	ProvisioningState            *string         `json:"provisioningState,omitempty"`
	ServerRole                   ReplicationRole `json:"serverRole"`
}

type RedisLinkedServerWithProperties 

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

type RedisLinkedServerWithPropertiesOperationPredicate 

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

func (RedisLinkedServerWithPropertiesOperationPredicate) Matches 

func (p RedisLinkedServerWithPropertiesOperationPredicate) Matches(input RedisLinkedServerWithProperties) bool

type RedisPatchSchedule 

type RedisPatchSchedule struct {
	Id         *string         `json:"id,omitempty"`
	Location   *string         `json:"location,omitempty"`
	Name       *string         `json:"name,omitempty"`
	Properties ScheduleEntries `json:"properties"`
	Type       *string         `json:"type,omitempty"`
}

type RedisPatchScheduleOperationPredicate 

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

func (RedisPatchScheduleOperationPredicate) Matches 

func (p RedisPatchScheduleOperationPredicate) Matches(input RedisPatchSchedule) bool

type RedisProperties 

type RedisProperties struct {
	AccessKeys                 *RedisAccessKeys                         `json:"accessKeys,omitempty"`
	EnableNonSslPort           *bool                                    `json:"enableNonSslPort,omitempty"`
	HostName                   *string                                  `json:"hostName,omitempty"`
	Instances                  *[]RedisInstanceDetails                  `json:"instances,omitempty"`
	LinkedServers              *[]RedisLinkedServer                     `json:"linkedServers,omitempty"`
	MinimumTlsVersion          *TlsVersion                              `json:"minimumTlsVersion,omitempty"`
	Port                       *int64                                   `json:"port,omitempty"`
	PrivateEndpointConnections *[]PrivateEndpointConnection             `json:"privateEndpointConnections,omitempty"`
	ProvisioningState          *ProvisioningState                       `json:"provisioningState,omitempty"`
	PublicNetworkAccess        *PublicNetworkAccess                     `json:"publicNetworkAccess,omitempty"`
	RedisConfiguration         *RedisCommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`
	RedisVersion               *string                                  `json:"redisVersion,omitempty"`
	ReplicasPerMaster          *int64                                   `json:"replicasPerMaster,omitempty"`
	ReplicasPerPrimary         *int64                                   `json:"replicasPerPrimary,omitempty"`
	ShardCount                 *int64                                   `json:"shardCount,omitempty"`
	Sku                        Sku                                      `json:"sku"`
	SslPort                    *int64                                   `json:"sslPort,omitempty"`
	StaticIP                   *string                                  `json:"staticIP,omitempty"`
	SubnetId                   *string                                  `json:"subnetId,omitempty"`
	TenantSettings             *map[string]string                       `json:"tenantSettings,omitempty"`
}

type RedisRebootParameters 

type RedisRebootParameters struct {
	Ports      *[]int64    `json:"ports,omitempty"`
	RebootType *RebootType `json:"rebootType,omitempty"`
	ShardId    *int64      `json:"shardId,omitempty"`
}

type RedisRegenerateKeyParameters 

type RedisRegenerateKeyParameters struct {
	KeyType RedisKeyType `json:"keyType"`
}

type RedisResource 

type RedisResource struct {
	Id         *string                            `json:"id,omitempty"`
	Identity   *identity.SystemAndUserAssignedMap `json:"identity,omitempty"`
	Location   string                             `json:"location"`
	Name       *string                            `json:"name,omitempty"`
	Properties RedisProperties                    `json:"properties"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
	Type       *string                            `json:"type,omitempty"`
	Zones      *zones.Schema                      `json:"zones,omitempty"`
}

type RedisResourceOperationPredicate 

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

func (RedisResourceOperationPredicate) Matches 

func (p RedisResourceOperationPredicate) Matches(input RedisResource) bool

type RedisUpdateParameters 

type RedisUpdateParameters struct {
	Identity   *identity.SystemAndUserAssignedMap `json:"identity,omitempty"`
	Properties *RedisUpdateProperties             `json:"properties,omitempty"`
	Tags       *map[string]string                 `json:"tags,omitempty"`
}

type RedisUpdateProperties 

type RedisUpdateProperties struct {
	EnableNonSslPort    *bool                                    `json:"enableNonSslPort,omitempty"`
	MinimumTlsVersion   *TlsVersion                              `json:"minimumTlsVersion,omitempty"`
	PublicNetworkAccess *PublicNetworkAccess                     `json:"publicNetworkAccess,omitempty"`
	RedisConfiguration  *RedisCommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`
	RedisVersion        *string                                  `json:"redisVersion,omitempty"`
	ReplicasPerMaster   *int64                                   `json:"replicasPerMaster,omitempty"`
	ReplicasPerPrimary  *int64                                   `json:"replicasPerPrimary,omitempty"`
	ShardCount          *int64                                   `json:"shardCount,omitempty"`
	Sku                 *Sku                                     `json:"sku,omitempty"`
	TenantSettings      *map[string]string                       `json:"tenantSettings,omitempty"`
}

type RegenerateKeyOperationResponse 

type RegenerateKeyOperationResponse struct {
	HttpResponse *http.Response
	Model        *RedisAccessKeys
}

type ReplicationRole 

type ReplicationRole string
const (
	ReplicationRolePrimary   ReplicationRole = "Primary"
	ReplicationRoleSecondary ReplicationRole = "Secondary"
)

type ScheduleEntries 

type ScheduleEntries struct {
	ScheduleEntries []ScheduleEntry `json:"scheduleEntries"`
}

type ScheduleEntry 

type ScheduleEntry struct {
	DayOfWeek         DayOfWeek `json:"dayOfWeek"`
	MaintenanceWindow *string   `json:"maintenanceWindow,omitempty"`
	StartHourUtc      int64     `json:"startHourUtc"`
}

type Sku 

type Sku struct {
	Capacity int64     `json:"capacity"`
	Family   SkuFamily `json:"family"`
	Name     SkuName   `json:"name"`
}

type SkuFamily 

type SkuFamily string
const (
	SkuFamilyC SkuFamily = "C"
	SkuFamilyP SkuFamily = "P"
)

type SkuName 

type SkuName string
const (
	SkuNameBasic    SkuName = "Basic"
	SkuNamePremium  SkuName = "Premium"
	SkuNameStandard SkuName = "Standard"
)

type TlsVersion 

type TlsVersion string
const (
	TlsVersionOnePointOne  TlsVersion = "1.1"
	TlsVersionOnePointTwo  TlsVersion = "1.2"
	TlsVersionOnePointZero TlsVersion = "1.0"
)

type UpdateOperationResponse 

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

type UpgradeNotification 

type UpgradeNotification struct {
	Name               *string            `json:"name,omitempty"`
	Timestamp          *string            `json:"timestamp,omitempty"`
	UpsellNotification *map[string]string `json:"upsellNotification,omitempty"`
}

func (*UpgradeNotification) GetTimestampAsTime 

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

func (*UpgradeNotification) SetTimestampAsTime 

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

type UpgradeNotificationOperationPredicate 

type UpgradeNotificationOperationPredicate struct {
	Name      *string
	Timestamp *string
}

func (UpgradeNotificationOperationPredicate) Matches 

func (p UpgradeNotificationOperationPredicate) Matches(input UpgradeNotification) bool

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.