frontdoors

package
v0.20240527.1094340 Latest Latest
Warning

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

 Go to latest Published: May 27, 2024 License: MPL-2.0 Imports: 12 Imported by: 1

README

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

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

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

Import Path

import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
import "github.com/hashicorp/go-azure-sdk/resource-manager/frontdoor/2020-05-01/frontdoors"

Client Initialization

client := frontdoors.NewFrontDoorsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: FrontDoorsClient.CreateOrUpdate

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

payload := frontdoors.FrontDoor{
	// ...
}


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

Example Usage: FrontDoorsClient.Delete

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

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

Example Usage: FrontDoorsClient.EndpointsPurgeContent

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

payload := frontdoors.PurgeParameters{
	// ...
}


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

Example Usage: FrontDoorsClient.FrontendEndpointsDisableHTTPS

ctx := context.TODO()
id := frontdoors.NewFrontendEndpointID("12345678-1234-9876-4563-123456789012", "example-resource-group", "frontDoorValue", "frontendEndpointValue")

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

Example Usage: FrontDoorsClient.FrontendEndpointsEnableHTTPS

ctx := context.TODO()
id := frontdoors.NewFrontendEndpointID("12345678-1234-9876-4563-123456789012", "example-resource-group", "frontDoorValue", "frontendEndpointValue")

payload := frontdoors.CustomHTTPSConfiguration{
	// ...
}


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

Example Usage: FrontDoorsClient.FrontendEndpointsGet

ctx := context.TODO()
id := frontdoors.NewFrontendEndpointID("12345678-1234-9876-4563-123456789012", "example-resource-group", "frontDoorValue", "frontendEndpointValue")

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

Example Usage: FrontDoorsClient.FrontendEndpointsListByFrontDoor

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

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

Example Usage: FrontDoorsClient.Get

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

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: FrontDoorsClient.List

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

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

Example Usage: FrontDoorsClient.ListByResourceGroup

ctx := context.TODO()
id := commonids.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: FrontDoorsClient.RulesEnginesCreateOrUpdate

ctx := context.TODO()
id := frontdoors.NewRulesEngineID("12345678-1234-9876-4563-123456789012", "example-resource-group", "frontDoorValue", "rulesEngineValue")

payload := frontdoors.RulesEngine{
	// ...
}


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

Example Usage: FrontDoorsClient.RulesEnginesDelete

ctx := context.TODO()
id := frontdoors.NewRulesEngineID("12345678-1234-9876-4563-123456789012", "example-resource-group", "frontDoorValue", "rulesEngineValue")

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

Example Usage: FrontDoorsClient.RulesEnginesGet

ctx := context.TODO()
id := frontdoors.NewRulesEngineID("12345678-1234-9876-4563-123456789012", "example-resource-group", "frontDoorValue", "rulesEngineValue")

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

Example Usage: FrontDoorsClient.RulesEnginesListByFrontDoor

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

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

Example Usage: FrontDoorsClient.ValidateCustomDomain

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

payload := frontdoors.ValidateCustomDomainInput{
	// ...
}


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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForBackendEnabledState 

func PossibleValuesForBackendEnabledState() []string

func PossibleValuesForCustomHTTPSProvisioningState 

func PossibleValuesForCustomHTTPSProvisioningState() []string

func PossibleValuesForCustomHTTPSProvisioningSubstate 

func PossibleValuesForCustomHTTPSProvisioningSubstate() []string

func PossibleValuesForDynamicCompressionEnabled 

func PossibleValuesForDynamicCompressionEnabled() []string

func PossibleValuesForEnforceCertificateNameCheckEnabledState 

func PossibleValuesForEnforceCertificateNameCheckEnabledState() []string

func PossibleValuesForFrontDoorCertificateSource 

func PossibleValuesForFrontDoorCertificateSource() []string

func PossibleValuesForFrontDoorCertificateType 

func PossibleValuesForFrontDoorCertificateType() []string

func PossibleValuesForFrontDoorEnabledState 

func PossibleValuesForFrontDoorEnabledState() []string

func PossibleValuesForFrontDoorForwardingProtocol 

func PossibleValuesForFrontDoorForwardingProtocol() []string

func PossibleValuesForFrontDoorHealthProbeMethod 

func PossibleValuesForFrontDoorHealthProbeMethod() []string

func PossibleValuesForFrontDoorProtocol 

func PossibleValuesForFrontDoorProtocol() []string

func PossibleValuesForFrontDoorQuery 

func PossibleValuesForFrontDoorQuery() []string

func PossibleValuesForFrontDoorRedirectProtocol 

func PossibleValuesForFrontDoorRedirectProtocol() []string

func PossibleValuesForFrontDoorRedirectType 

func PossibleValuesForFrontDoorRedirectType() []string

func PossibleValuesForFrontDoorResourceState 

func PossibleValuesForFrontDoorResourceState() []string

func PossibleValuesForFrontDoorTlsProtocolType 

func PossibleValuesForFrontDoorTlsProtocolType() []string

func PossibleValuesForHeaderActionType 

func PossibleValuesForHeaderActionType() []string

func PossibleValuesForHealthProbeEnabled 

func PossibleValuesForHealthProbeEnabled() []string

func PossibleValuesForMatchProcessingBehavior 

func PossibleValuesForMatchProcessingBehavior() []string

func PossibleValuesForMinimumTLSVersion 

func PossibleValuesForMinimumTLSVersion() []string

func PossibleValuesForPrivateEndpointStatus 

func PossibleValuesForPrivateEndpointStatus() []string

func PossibleValuesForRoutingRuleEnabledState 

func PossibleValuesForRoutingRuleEnabledState() []string

func PossibleValuesForRulesEngineMatchVariable 

func PossibleValuesForRulesEngineMatchVariable() []string

func PossibleValuesForRulesEngineOperator 

func PossibleValuesForRulesEngineOperator() []string

func PossibleValuesForSessionAffinityEnabledState 

func PossibleValuesForSessionAffinityEnabledState() []string

func PossibleValuesForTransform 

func PossibleValuesForTransform() []string

func ValidateFrontDoorID 

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

ValidateFrontDoorID checks that 'input' can be parsed as a Front Door ID

func ValidateFrontendEndpointID 

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

ValidateFrontendEndpointID checks that 'input' can be parsed as a Frontend Endpoint ID

func ValidateRulesEngineID 

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

ValidateRulesEngineID checks that 'input' can be parsed as a Rules Engine ID

Types

type Backend 

type Backend struct {
	Address                    *string                `json:"address,omitempty"`
	BackendHostHeader          *string                `json:"backendHostHeader,omitempty"`
	EnabledState               *BackendEnabledState   `json:"enabledState,omitempty"`
	HTTPPort                   *int64                 `json:"httpPort,omitempty"`
	HTTPSPort                  *int64                 `json:"httpsPort,omitempty"`
	Priority                   *int64                 `json:"priority,omitempty"`
	PrivateEndpointStatus      *PrivateEndpointStatus `json:"privateEndpointStatus,omitempty"`
	PrivateLinkAlias           *string                `json:"privateLinkAlias,omitempty"`
	PrivateLinkApprovalMessage *string                `json:"privateLinkApprovalMessage,omitempty"`
	PrivateLinkLocation        *string                `json:"privateLinkLocation,omitempty"`
	PrivateLinkResourceId      *string                `json:"privateLinkResourceId,omitempty"`
	Weight                     *int64                 `json:"weight,omitempty"`
}

type BackendEnabledState 

type BackendEnabledState string
const (
	BackendEnabledStateDisabled BackendEnabledState = "Disabled"
	BackendEnabledStateEnabled  BackendEnabledState = "Enabled"
)

type BackendPool 

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

type BackendPoolProperties 

type BackendPoolProperties struct {
	Backends              *[]Backend              `json:"backends,omitempty"`
	HealthProbeSettings   *SubResource            `json:"healthProbeSettings,omitempty"`
	LoadBalancingSettings *SubResource            `json:"loadBalancingSettings,omitempty"`
	ResourceState         *FrontDoorResourceState `json:"resourceState,omitempty"`
}

type BackendPoolsSettings 

type BackendPoolsSettings struct {
	EnforceCertificateNameCheck *EnforceCertificateNameCheckEnabledState `json:"enforceCertificateNameCheck,omitempty"`
	SendRecvTimeoutSeconds      *int64                                   `json:"sendRecvTimeoutSeconds,omitempty"`
}

type CacheConfiguration 

type CacheConfiguration struct {
	CacheDuration                *string                    `json:"cacheDuration,omitempty"`
	DynamicCompression           *DynamicCompressionEnabled `json:"dynamicCompression,omitempty"`
	QueryParameterStripDirective *FrontDoorQuery            `json:"queryParameterStripDirective,omitempty"`
	QueryParameters              *string                    `json:"queryParameters,omitempty"`
}

type CreateOrUpdateOperationResponse 

type CreateOrUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
	Model        *FrontDoor
}

type CustomHTTPSConfiguration 

type CustomHTTPSConfiguration struct {
	CertificateSource                    FrontDoorCertificateSource            `json:"certificateSource"`
	FrontDoorCertificateSourceParameters *FrontDoorCertificateSourceParameters `json:"frontDoorCertificateSourceParameters,omitempty"`
	KeyVaultCertificateSourceParameters  *KeyVaultCertificateSourceParameters  `json:"keyVaultCertificateSourceParameters,omitempty"`
	MinimumTlsVersion                    MinimumTLSVersion                     `json:"minimumTlsVersion"`
	ProtocolType                         FrontDoorTlsProtocolType              `json:"protocolType"`
}

type CustomHTTPSProvisioningState 

type CustomHTTPSProvisioningState string
const (
	CustomHTTPSProvisioningStateDisabled  CustomHTTPSProvisioningState = "Disabled"
	CustomHTTPSProvisioningStateDisabling CustomHTTPSProvisioningState = "Disabling"
	CustomHTTPSProvisioningStateEnabled   CustomHTTPSProvisioningState = "Enabled"
	CustomHTTPSProvisioningStateEnabling  CustomHTTPSProvisioningState = "Enabling"
	CustomHTTPSProvisioningStateFailed    CustomHTTPSProvisioningState = "Failed"
)

type CustomHTTPSProvisioningSubstate 

type CustomHTTPSProvisioningSubstate string
const (
	CustomHTTPSProvisioningSubstateCertificateDeleted                            CustomHTTPSProvisioningSubstate = "CertificateDeleted"
	CustomHTTPSProvisioningSubstateCertificateDeployed                           CustomHTTPSProvisioningSubstate = "CertificateDeployed"
	CustomHTTPSProvisioningSubstateDeletingCertificate                           CustomHTTPSProvisioningSubstate = "DeletingCertificate"
	CustomHTTPSProvisioningSubstateDeployingCertificate                          CustomHTTPSProvisioningSubstate = "DeployingCertificate"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestApproved        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestApproved"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestRejected        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestRejected"
	CustomHTTPSProvisioningSubstateDomainControlValidationRequestTimedOut        CustomHTTPSProvisioningSubstate = "DomainControlValidationRequestTimedOut"
	CustomHTTPSProvisioningSubstateIssuingCertificate                            CustomHTTPSProvisioningSubstate = "IssuingCertificate"
	CustomHTTPSProvisioningSubstatePendingDomainControlValidationREquestApproval CustomHTTPSProvisioningSubstate = "PendingDomainControlValidationREquestApproval"
	CustomHTTPSProvisioningSubstateSubmittingDomainControlValidationRequest      CustomHTTPSProvisioningSubstate = "SubmittingDomainControlValidationRequest"
)

type DeleteOperationResponse 

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

type DynamicCompressionEnabled 

type DynamicCompressionEnabled string
const (
	DynamicCompressionEnabledDisabled DynamicCompressionEnabled = "Disabled"
	DynamicCompressionEnabledEnabled  DynamicCompressionEnabled = "Enabled"
)

type EndpointsPurgeContentOperationResponse 

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

type EnforceCertificateNameCheckEnabledState 

type EnforceCertificateNameCheckEnabledState string
const (
	EnforceCertificateNameCheckEnabledStateDisabled EnforceCertificateNameCheckEnabledState = "Disabled"
	EnforceCertificateNameCheckEnabledStateEnabled  EnforceCertificateNameCheckEnabledState = "Enabled"
)

type ForwardingConfiguration 

type ForwardingConfiguration struct {
	BackendPool          *SubResource                 `json:"backendPool,omitempty"`
	CacheConfiguration   *CacheConfiguration          `json:"cacheConfiguration,omitempty"`
	CustomForwardingPath *string                      `json:"customForwardingPath,omitempty"`
	ForwardingProtocol   *FrontDoorForwardingProtocol `json:"forwardingProtocol,omitempty"`
}

func (ForwardingConfiguration) MarshalJSON 

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

type FrontDoor 

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

type FrontDoorCertificateSource 

type FrontDoorCertificateSource string
const (
	FrontDoorCertificateSourceAzureKeyVault FrontDoorCertificateSource = "AzureKeyVault"
	FrontDoorCertificateSourceFrontDoor     FrontDoorCertificateSource = "FrontDoor"
)

type FrontDoorCertificateSourceParameters 

type FrontDoorCertificateSourceParameters struct {
	CertificateType *FrontDoorCertificateType `json:"certificateType,omitempty"`
}

type FrontDoorCertificateType 

type FrontDoorCertificateType string
const (
	FrontDoorCertificateTypeDedicated FrontDoorCertificateType = "Dedicated"
)

type FrontDoorEnabledState 

type FrontDoorEnabledState string
const (
	FrontDoorEnabledStateDisabled FrontDoorEnabledState = "Disabled"
	FrontDoorEnabledStateEnabled  FrontDoorEnabledState = "Enabled"
)

type FrontDoorForwardingProtocol 

type FrontDoorForwardingProtocol string
const (
	FrontDoorForwardingProtocolHTTPOnly     FrontDoorForwardingProtocol = "HttpOnly"
	FrontDoorForwardingProtocolHTTPSOnly    FrontDoorForwardingProtocol = "HttpsOnly"
	FrontDoorForwardingProtocolMatchRequest FrontDoorForwardingProtocol = "MatchRequest"
)

type FrontDoorHealthProbeMethod 

type FrontDoorHealthProbeMethod string
const (
	FrontDoorHealthProbeMethodGET  FrontDoorHealthProbeMethod = "GET"
	FrontDoorHealthProbeMethodHEAD FrontDoorHealthProbeMethod = "HEAD"
)

type FrontDoorId 

type FrontDoorId struct {
	SubscriptionId    string
	ResourceGroupName string
	FrontDoorName     string
}

FrontDoorId is a struct representing the Resource ID for a Front Door

func NewFrontDoorID 

func NewFrontDoorID(subscriptionId string, resourceGroupName string, frontDoorName string) FrontDoorId

NewFrontDoorID returns a new FrontDoorId struct

func ParseFrontDoorID 

func ParseFrontDoorID(input string) (*FrontDoorId, error)

ParseFrontDoorID parses 'input' into a FrontDoorId

func ParseFrontDoorIDInsensitively 

func ParseFrontDoorIDInsensitively(input string) (*FrontDoorId, error)

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

func (*FrontDoorId) FromParseResult 

func (id *FrontDoorId) FromParseResult(input resourceids.ParseResult) error

func (FrontDoorId) ID 

func (id FrontDoorId) ID() string

ID returns the formatted Front Door ID

func (FrontDoorId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Front Door ID

func (FrontDoorId) String 

func (id FrontDoorId) String() string

String returns a human-readable description of this Front Door ID

type FrontDoorOperationPredicate 

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

func (FrontDoorOperationPredicate) Matches 

func (p FrontDoorOperationPredicate) Matches(input FrontDoor) bool

type FrontDoorProperties 

type FrontDoorProperties struct {
	BackendPools          *[]BackendPool                `json:"backendPools,omitempty"`
	BackendPoolsSettings  *BackendPoolsSettings         `json:"backendPoolsSettings,omitempty"`
	Cname                 *string                       `json:"cname,omitempty"`
	EnabledState          *FrontDoorEnabledState        `json:"enabledState,omitempty"`
	FriendlyName          *string                       `json:"friendlyName,omitempty"`
	FrontdoorId           *string                       `json:"frontdoorId,omitempty"`
	FrontendEndpoints     *[]FrontendEndpoint           `json:"frontendEndpoints,omitempty"`
	HealthProbeSettings   *[]HealthProbeSettingsModel   `json:"healthProbeSettings,omitempty"`
	LoadBalancingSettings *[]LoadBalancingSettingsModel `json:"loadBalancingSettings,omitempty"`
	ProvisioningState     *string                       `json:"provisioningState,omitempty"`
	ResourceState         *FrontDoorResourceState       `json:"resourceState,omitempty"`
	RoutingRules          *[]RoutingRule                `json:"routingRules,omitempty"`
	RulesEngines          *[]RulesEngine                `json:"rulesEngines,omitempty"`
}

type FrontDoorProtocol 

type FrontDoorProtocol string
const (
	FrontDoorProtocolHTTP  FrontDoorProtocol = "Http"
	FrontDoorProtocolHTTPS FrontDoorProtocol = "Https"
)

type FrontDoorQuery 

type FrontDoorQuery string
const (
	FrontDoorQueryStripAll       FrontDoorQuery = "StripAll"
	FrontDoorQueryStripAllExcept FrontDoorQuery = "StripAllExcept"
	FrontDoorQueryStripNone      FrontDoorQuery = "StripNone"
	FrontDoorQueryStripOnly      FrontDoorQuery = "StripOnly"
)

type FrontDoorRedirectProtocol 

type FrontDoorRedirectProtocol string
const (
	FrontDoorRedirectProtocolHTTPOnly     FrontDoorRedirectProtocol = "HttpOnly"
	FrontDoorRedirectProtocolHTTPSOnly    FrontDoorRedirectProtocol = "HttpsOnly"
	FrontDoorRedirectProtocolMatchRequest FrontDoorRedirectProtocol = "MatchRequest"
)

type FrontDoorRedirectType 

type FrontDoorRedirectType string
const (
	FrontDoorRedirectTypeFound             FrontDoorRedirectType = "Found"
	FrontDoorRedirectTypeMoved             FrontDoorRedirectType = "Moved"
	FrontDoorRedirectTypePermanentRedirect FrontDoorRedirectType = "PermanentRedirect"
	FrontDoorRedirectTypeTemporaryRedirect FrontDoorRedirectType = "TemporaryRedirect"
)

type FrontDoorResourceState 

type FrontDoorResourceState string
const (
	FrontDoorResourceStateCreating  FrontDoorResourceState = "Creating"
	FrontDoorResourceStateDeleting  FrontDoorResourceState = "Deleting"
	FrontDoorResourceStateDisabled  FrontDoorResourceState = "Disabled"
	FrontDoorResourceStateDisabling FrontDoorResourceState = "Disabling"
	FrontDoorResourceStateEnabled   FrontDoorResourceState = "Enabled"
	FrontDoorResourceStateEnabling  FrontDoorResourceState = "Enabling"
)

type FrontDoorTlsProtocolType 

type FrontDoorTlsProtocolType string
const (
	FrontDoorTlsProtocolTypeServerNameIndication FrontDoorTlsProtocolType = "ServerNameIndication"
)

type FrontDoorsClient 

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

func NewFrontDoorsClientWithBaseURI 

func NewFrontDoorsClientWithBaseURI(endpoint string) FrontDoorsClient

func (FrontDoorsClient) CreateOrUpdate 

func (c FrontDoorsClient) CreateOrUpdate(ctx context.Context, id FrontDoorId, input FrontDoor) (result CreateOrUpdateOperationResponse, err error)

CreateOrUpdate ...

func (FrontDoorsClient) CreateOrUpdateThenPoll 

func (c FrontDoorsClient) CreateOrUpdateThenPoll(ctx context.Context, id FrontDoorId, input FrontDoor) error

CreateOrUpdateThenPoll performs CreateOrUpdate then polls until it's completed

func (FrontDoorsClient) Delete 

func (c FrontDoorsClient) Delete(ctx context.Context, id FrontDoorId) (result DeleteOperationResponse, err error)

Delete ...

func (FrontDoorsClient) DeleteThenPoll 

func (c FrontDoorsClient) DeleteThenPoll(ctx context.Context, id FrontDoorId) error

DeleteThenPoll performs Delete then polls until it's completed

func (FrontDoorsClient) EndpointsPurgeContent 

func (c FrontDoorsClient) EndpointsPurgeContent(ctx context.Context, id FrontDoorId, input PurgeParameters) (result EndpointsPurgeContentOperationResponse, err error)

EndpointsPurgeContent ...

func (FrontDoorsClient) EndpointsPurgeContentThenPoll 

func (c FrontDoorsClient) EndpointsPurgeContentThenPoll(ctx context.Context, id FrontDoorId, input PurgeParameters) error

EndpointsPurgeContentThenPoll performs EndpointsPurgeContent then polls until it's completed

func (FrontDoorsClient) FrontendEndpointsDisableHTTPS 

func (c FrontDoorsClient) FrontendEndpointsDisableHTTPS(ctx context.Context, id FrontendEndpointId) (result FrontendEndpointsDisableHTTPSOperationResponse, err error)

FrontendEndpointsDisableHTTPS ...

func (FrontDoorsClient) FrontendEndpointsDisableHTTPSThenPoll 

func (c FrontDoorsClient) FrontendEndpointsDisableHTTPSThenPoll(ctx context.Context, id FrontendEndpointId) error

FrontendEndpointsDisableHTTPSThenPoll performs FrontendEndpointsDisableHTTPS then polls until it's completed

func (FrontDoorsClient) FrontendEndpointsEnableHTTPS 

func (c FrontDoorsClient) FrontendEndpointsEnableHTTPS(ctx context.Context, id FrontendEndpointId, input CustomHTTPSConfiguration) (result FrontendEndpointsEnableHTTPSOperationResponse, err error)

FrontendEndpointsEnableHTTPS ...

func (FrontDoorsClient) FrontendEndpointsEnableHTTPSThenPoll 

func (c FrontDoorsClient) FrontendEndpointsEnableHTTPSThenPoll(ctx context.Context, id FrontendEndpointId, input CustomHTTPSConfiguration) error

FrontendEndpointsEnableHTTPSThenPoll performs FrontendEndpointsEnableHTTPS then polls until it's completed

func (FrontDoorsClient) FrontendEndpointsGet 

func (c FrontDoorsClient) FrontendEndpointsGet(ctx context.Context, id FrontendEndpointId) (result FrontendEndpointsGetOperationResponse, err error)

FrontendEndpointsGet ...

func (FrontDoorsClient) FrontendEndpointsListByFrontDoor 

func (c FrontDoorsClient) FrontendEndpointsListByFrontDoor(ctx context.Context, id FrontDoorId) (resp FrontendEndpointsListByFrontDoorOperationResponse, err error)

FrontendEndpointsListByFrontDoor ...

func (FrontDoorsClient) FrontendEndpointsListByFrontDoorComplete 

func (c FrontDoorsClient) FrontendEndpointsListByFrontDoorComplete(ctx context.Context, id FrontDoorId) (FrontendEndpointsListByFrontDoorCompleteResult, error)

FrontendEndpointsListByFrontDoorComplete retrieves all of the results into a single object

func (FrontDoorsClient) FrontendEndpointsListByFrontDoorCompleteMatchingPredicate 

func (c FrontDoorsClient) FrontendEndpointsListByFrontDoorCompleteMatchingPredicate(ctx context.Context, id FrontDoorId, predicate FrontendEndpointOperationPredicate) (resp FrontendEndpointsListByFrontDoorCompleteResult, err error)

FrontendEndpointsListByFrontDoorCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (FrontDoorsClient) Get 

func (c FrontDoorsClient) Get(ctx context.Context, id FrontDoorId) (result GetOperationResponse, err error)

Get ...

func (FrontDoorsClient) List 

func (c FrontDoorsClient) List(ctx context.Context, id commonids.SubscriptionId) (resp ListOperationResponse, err error)

List ...

func (FrontDoorsClient) ListByResourceGroup 

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

ListByResourceGroup ...

func (FrontDoorsClient) ListByResourceGroupComplete 

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

ListByResourceGroupComplete retrieves all of the results into a single object

func (FrontDoorsClient) ListByResourceGroupCompleteMatchingPredicate 

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

ListByResourceGroupCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (FrontDoorsClient) ListComplete 

func (c FrontDoorsClient) ListComplete(ctx context.Context, id commonids.SubscriptionId) (ListCompleteResult, error)

ListComplete retrieves all of the results into a single object

func (FrontDoorsClient) ListCompleteMatchingPredicate 

func (c FrontDoorsClient) ListCompleteMatchingPredicate(ctx context.Context, id commonids.SubscriptionId, predicate FrontDoorOperationPredicate) (resp ListCompleteResult, err error)

ListCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (FrontDoorsClient) RulesEnginesCreateOrUpdate 

func (c FrontDoorsClient) RulesEnginesCreateOrUpdate(ctx context.Context, id RulesEngineId, input RulesEngine) (result RulesEnginesCreateOrUpdateOperationResponse, err error)

RulesEnginesCreateOrUpdate ...

func (FrontDoorsClient) RulesEnginesCreateOrUpdateThenPoll 

func (c FrontDoorsClient) RulesEnginesCreateOrUpdateThenPoll(ctx context.Context, id RulesEngineId, input RulesEngine) error

RulesEnginesCreateOrUpdateThenPoll performs RulesEnginesCreateOrUpdate then polls until it's completed

func (FrontDoorsClient) RulesEnginesDelete 

func (c FrontDoorsClient) RulesEnginesDelete(ctx context.Context, id RulesEngineId) (result RulesEnginesDeleteOperationResponse, err error)

RulesEnginesDelete ...

func (FrontDoorsClient) RulesEnginesDeleteThenPoll 

func (c FrontDoorsClient) RulesEnginesDeleteThenPoll(ctx context.Context, id RulesEngineId) error

RulesEnginesDeleteThenPoll performs RulesEnginesDelete then polls until it's completed

func (FrontDoorsClient) RulesEnginesGet 

func (c FrontDoorsClient) RulesEnginesGet(ctx context.Context, id RulesEngineId) (result RulesEnginesGetOperationResponse, err error)

RulesEnginesGet ...

func (FrontDoorsClient) RulesEnginesListByFrontDoor 

func (c FrontDoorsClient) RulesEnginesListByFrontDoor(ctx context.Context, id FrontDoorId) (resp RulesEnginesListByFrontDoorOperationResponse, err error)

RulesEnginesListByFrontDoor ...

func (FrontDoorsClient) RulesEnginesListByFrontDoorComplete 

func (c FrontDoorsClient) RulesEnginesListByFrontDoorComplete(ctx context.Context, id FrontDoorId) (RulesEnginesListByFrontDoorCompleteResult, error)

RulesEnginesListByFrontDoorComplete retrieves all of the results into a single object

func (FrontDoorsClient) RulesEnginesListByFrontDoorCompleteMatchingPredicate 

func (c FrontDoorsClient) RulesEnginesListByFrontDoorCompleteMatchingPredicate(ctx context.Context, id FrontDoorId, predicate RulesEngineOperationPredicate) (resp RulesEnginesListByFrontDoorCompleteResult, err error)

RulesEnginesListByFrontDoorCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (FrontDoorsClient) ValidateCustomDomain 

func (c FrontDoorsClient) ValidateCustomDomain(ctx context.Context, id FrontDoorId, input ValidateCustomDomainInput) (result ValidateCustomDomainOperationResponse, err error)

ValidateCustomDomain ...

type FrontendEndpoint 

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

type FrontendEndpointId 

type FrontendEndpointId struct {
	SubscriptionId       string
	ResourceGroupName    string
	FrontDoorName        string
	FrontendEndpointName string
}

FrontendEndpointId is a struct representing the Resource ID for a Frontend Endpoint

func NewFrontendEndpointID 

func NewFrontendEndpointID(subscriptionId string, resourceGroupName string, frontDoorName string, frontendEndpointName string) FrontendEndpointId

NewFrontendEndpointID returns a new FrontendEndpointId struct

func ParseFrontendEndpointID 

func ParseFrontendEndpointID(input string) (*FrontendEndpointId, error)

ParseFrontendEndpointID parses 'input' into a FrontendEndpointId

func ParseFrontendEndpointIDInsensitively 

func ParseFrontendEndpointIDInsensitively(input string) (*FrontendEndpointId, error)

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

func (*FrontendEndpointId) FromParseResult 

func (id *FrontendEndpointId) FromParseResult(input resourceids.ParseResult) error

func (FrontendEndpointId) ID 

func (id FrontendEndpointId) ID() string

ID returns the formatted Frontend Endpoint ID

func (FrontendEndpointId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Frontend Endpoint ID

func (FrontendEndpointId) String 

func (id FrontendEndpointId) String() string

String returns a human-readable description of this Frontend Endpoint ID

type FrontendEndpointOperationPredicate 

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

func (FrontendEndpointOperationPredicate) Matches 

func (p FrontendEndpointOperationPredicate) Matches(input FrontendEndpoint) bool

type FrontendEndpointProperties 

type FrontendEndpointProperties struct {
	CustomHTTPSConfiguration         *CustomHTTPSConfiguration                                         `json:"customHttpsConfiguration,omitempty"`
	CustomHTTPSProvisioningState     *CustomHTTPSProvisioningState                                     `json:"customHttpsProvisioningState,omitempty"`
	CustomHTTPSProvisioningSubstate  *CustomHTTPSProvisioningSubstate                                  `json:"customHttpsProvisioningSubstate,omitempty"`
	HostName                         *string                                                           `json:"hostName,omitempty"`
	ResourceState                    *FrontDoorResourceState                                           `json:"resourceState,omitempty"`
	SessionAffinityEnabledState      *SessionAffinityEnabledState                                      `json:"sessionAffinityEnabledState,omitempty"`
	SessionAffinityTtlSeconds        *int64                                                            `json:"sessionAffinityTtlSeconds,omitempty"`
	WebApplicationFirewallPolicyLink *FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink `json:"webApplicationFirewallPolicyLink,omitempty"`
}
type FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink struct {
	Id *string `json:"id,omitempty"`
}

type FrontendEndpointsDisableHTTPSOperationResponse 

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

type FrontendEndpointsEnableHTTPSOperationResponse 

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

type FrontendEndpointsGetOperationResponse 

type FrontendEndpointsGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *FrontendEndpoint
}

type FrontendEndpointsListByFrontDoorCompleteResult 

type FrontendEndpointsListByFrontDoorCompleteResult struct {
	Items []FrontendEndpoint
}

type FrontendEndpointsListByFrontDoorOperationResponse 

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

func (FrontendEndpointsListByFrontDoorOperationResponse) HasMore 

func (r FrontendEndpointsListByFrontDoorOperationResponse) HasMore() bool

func (FrontendEndpointsListByFrontDoorOperationResponse) LoadMore 

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

type GetOperationResponse 

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

type HeaderAction 

type HeaderAction struct {
	HeaderActionType HeaderActionType `json:"headerActionType"`
	HeaderName       string           `json:"headerName"`
	Value            *string          `json:"value,omitempty"`
}

type HeaderActionType 

type HeaderActionType string
const (
	HeaderActionTypeAppend    HeaderActionType = "Append"
	HeaderActionTypeDelete    HeaderActionType = "Delete"
	HeaderActionTypeOverwrite HeaderActionType = "Overwrite"
)

type HealthProbeEnabled 

type HealthProbeEnabled string
const (
	HealthProbeEnabledDisabled HealthProbeEnabled = "Disabled"
	HealthProbeEnabledEnabled  HealthProbeEnabled = "Enabled"
)

type HealthProbeSettingsModel 

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

type HealthProbeSettingsProperties 

type HealthProbeSettingsProperties struct {
	EnabledState      *HealthProbeEnabled         `json:"enabledState,omitempty"`
	HealthProbeMethod *FrontDoorHealthProbeMethod `json:"healthProbeMethod,omitempty"`
	IntervalInSeconds *int64                      `json:"intervalInSeconds,omitempty"`
	Path              *string                     `json:"path,omitempty"`
	Protocol          *FrontDoorProtocol          `json:"protocol,omitempty"`
	ResourceState     *FrontDoorResourceState     `json:"resourceState,omitempty"`
}

type KeyVaultCertificateSourceParameters 

type KeyVaultCertificateSourceParameters struct {
	SecretName    *string                                   `json:"secretName,omitempty"`
	SecretVersion *string                                   `json:"secretVersion,omitempty"`
	Vault         *KeyVaultCertificateSourceParametersVault `json:"vault,omitempty"`
}

type KeyVaultCertificateSourceParametersVault 

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

type ListByResourceGroupCompleteResult 

type ListByResourceGroupCompleteResult struct {
	Items []FrontDoor
}

type ListByResourceGroupOperationResponse 

type ListByResourceGroupOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]FrontDoor
	// 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 ListCompleteResult 

type ListCompleteResult struct {
	Items []FrontDoor
}

type ListOperationResponse 

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

func (ListOperationResponse) HasMore 

func (r ListOperationResponse) HasMore() bool

func (ListOperationResponse) LoadMore 

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

type LoadBalancingSettingsModel 

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

type LoadBalancingSettingsProperties 

type LoadBalancingSettingsProperties struct {
	AdditionalLatencyMilliseconds *int64                  `json:"additionalLatencyMilliseconds,omitempty"`
	ResourceState                 *FrontDoorResourceState `json:"resourceState,omitempty"`
	SampleSize                    *int64                  `json:"sampleSize,omitempty"`
	SuccessfulSamplesRequired     *int64                  `json:"successfulSamplesRequired,omitempty"`
}

type MatchProcessingBehavior 

type MatchProcessingBehavior string
const (
	MatchProcessingBehaviorContinue MatchProcessingBehavior = "Continue"
	MatchProcessingBehaviorStop     MatchProcessingBehavior = "Stop"
)

type MinimumTLSVersion 

type MinimumTLSVersion string
const (
	MinimumTLSVersionOnePointTwo  MinimumTLSVersion = "1.2"
	MinimumTLSVersionOnePointZero MinimumTLSVersion = "1.0"
)

type PrivateEndpointStatus 

type PrivateEndpointStatus string
const (
	PrivateEndpointStatusApproved     PrivateEndpointStatus = "Approved"
	PrivateEndpointStatusDisconnected PrivateEndpointStatus = "Disconnected"
	PrivateEndpointStatusPending      PrivateEndpointStatus = "Pending"
	PrivateEndpointStatusRejected     PrivateEndpointStatus = "Rejected"
	PrivateEndpointStatusTimeout      PrivateEndpointStatus = "Timeout"
)

type PurgeParameters 

type PurgeParameters struct {
	ContentPaths []string `json:"contentPaths"`
}

type RawRouteConfigurationImpl 

type RawRouteConfigurationImpl struct {
	Type   string
	Values map[string]interface{}
}

RawRouteConfigurationImpl is returned when the Discriminated Value doesn't match any of the defined types NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround) and is used only for Deserialization (e.g. this cannot be used as a Request Payload).

type RedirectConfiguration 

type RedirectConfiguration struct {
	CustomFragment    *string                    `json:"customFragment,omitempty"`
	CustomHost        *string                    `json:"customHost,omitempty"`
	CustomPath        *string                    `json:"customPath,omitempty"`
	CustomQueryString *string                    `json:"customQueryString,omitempty"`
	RedirectProtocol  *FrontDoorRedirectProtocol `json:"redirectProtocol,omitempty"`
	RedirectType      *FrontDoorRedirectType     `json:"redirectType,omitempty"`
}

func (RedirectConfiguration) MarshalJSON 

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

type RouteConfiguration 

type RouteConfiguration interface {
}

type RoutingRule 

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

type RoutingRuleEnabledState 

type RoutingRuleEnabledState string
const (
	RoutingRuleEnabledStateDisabled RoutingRuleEnabledState = "Disabled"
	RoutingRuleEnabledStateEnabled  RoutingRuleEnabledState = "Enabled"
)

type RoutingRuleProperties 

type RoutingRuleProperties struct {
	AcceptedProtocols                *[]FrontDoorProtocol                                         `json:"acceptedProtocols,omitempty"`
	EnabledState                     *RoutingRuleEnabledState                                     `json:"enabledState,omitempty"`
	FrontendEndpoints                *[]SubResource                                               `json:"frontendEndpoints,omitempty"`
	PatternsToMatch                  *[]string                                                    `json:"patternsToMatch,omitempty"`
	ResourceState                    *FrontDoorResourceState                                      `json:"resourceState,omitempty"`
	RouteConfiguration               RouteConfiguration                                           `json:"routeConfiguration"`
	RulesEngine                      *SubResource                                                 `json:"rulesEngine,omitempty"`
	WebApplicationFirewallPolicyLink *RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink `json:"webApplicationFirewallPolicyLink,omitempty"`
}

func (*RoutingRuleProperties) UnmarshalJSON 

func (s *RoutingRuleProperties) UnmarshalJSON(bytes []byte) error
type RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink struct {
	Id *string `json:"id,omitempty"`
}

type RulesEngine 

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

type RulesEngineAction 

type RulesEngineAction struct {
	RequestHeaderActions       *[]HeaderAction    `json:"requestHeaderActions,omitempty"`
	ResponseHeaderActions      *[]HeaderAction    `json:"responseHeaderActions,omitempty"`
	RouteConfigurationOverride RouteConfiguration `json:"routeConfigurationOverride"`
}

func (*RulesEngineAction) UnmarshalJSON 

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

type RulesEngineId 

type RulesEngineId struct {
	SubscriptionId    string
	ResourceGroupName string
	FrontDoorName     string
	RulesEngineName   string
}

RulesEngineId is a struct representing the Resource ID for a Rules Engine

func NewRulesEngineID 

func NewRulesEngineID(subscriptionId string, resourceGroupName string, frontDoorName string, rulesEngineName string) RulesEngineId

NewRulesEngineID returns a new RulesEngineId struct

func ParseRulesEngineID 

func ParseRulesEngineID(input string) (*RulesEngineId, error)

ParseRulesEngineID parses 'input' into a RulesEngineId

func ParseRulesEngineIDInsensitively 

func ParseRulesEngineIDInsensitively(input string) (*RulesEngineId, error)

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

func (*RulesEngineId) FromParseResult 

func (id *RulesEngineId) FromParseResult(input resourceids.ParseResult) error

func (RulesEngineId) ID 

func (id RulesEngineId) ID() string

ID returns the formatted Rules Engine ID

func (RulesEngineId) Segments 

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

Segments returns a slice of Resource ID Segments which comprise this Rules Engine ID

func (RulesEngineId) String 

func (id RulesEngineId) String() string

String returns a human-readable description of this Rules Engine ID

type RulesEngineMatchCondition 

type RulesEngineMatchCondition struct {
	NegateCondition          *bool                    `json:"negateCondition,omitempty"`
	RulesEngineMatchValue    []string                 `json:"rulesEngineMatchValue"`
	RulesEngineMatchVariable RulesEngineMatchVariable `json:"rulesEngineMatchVariable"`
	RulesEngineOperator      RulesEngineOperator      `json:"rulesEngineOperator"`
	Selector                 *string                  `json:"selector,omitempty"`
	Transforms               *[]Transform             `json:"transforms,omitempty"`
}

type RulesEngineMatchVariable 

type RulesEngineMatchVariable string
const (
	RulesEngineMatchVariableIsMobile                 RulesEngineMatchVariable = "IsMobile"
	RulesEngineMatchVariablePostArgs                 RulesEngineMatchVariable = "PostArgs"
	RulesEngineMatchVariableQueryString              RulesEngineMatchVariable = "QueryString"
	RulesEngineMatchVariableRemoteAddr               RulesEngineMatchVariable = "RemoteAddr"
	RulesEngineMatchVariableRequestBody              RulesEngineMatchVariable = "RequestBody"
	RulesEngineMatchVariableRequestFilename          RulesEngineMatchVariable = "RequestFilename"
	RulesEngineMatchVariableRequestFilenameExtension RulesEngineMatchVariable = "RequestFilenameExtension"
	RulesEngineMatchVariableRequestHeader            RulesEngineMatchVariable = "RequestHeader"
	RulesEngineMatchVariableRequestMethod            RulesEngineMatchVariable = "RequestMethod"
	RulesEngineMatchVariableRequestPath              RulesEngineMatchVariable = "RequestPath"
	RulesEngineMatchVariableRequestScheme            RulesEngineMatchVariable = "RequestScheme"
	RulesEngineMatchVariableRequestUri               RulesEngineMatchVariable = "RequestUri"
)

type RulesEngineOperationPredicate 

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

func (RulesEngineOperationPredicate) Matches 

func (p RulesEngineOperationPredicate) Matches(input RulesEngine) bool

type RulesEngineOperator 

type RulesEngineOperator string
const (
	RulesEngineOperatorAny                RulesEngineOperator = "Any"
	RulesEngineOperatorBeginsWith         RulesEngineOperator = "BeginsWith"
	RulesEngineOperatorContains           RulesEngineOperator = "Contains"
	RulesEngineOperatorEndsWith           RulesEngineOperator = "EndsWith"
	RulesEngineOperatorEqual              RulesEngineOperator = "Equal"
	RulesEngineOperatorGeoMatch           RulesEngineOperator = "GeoMatch"
	RulesEngineOperatorGreaterThan        RulesEngineOperator = "GreaterThan"
	RulesEngineOperatorGreaterThanOrEqual RulesEngineOperator = "GreaterThanOrEqual"
	RulesEngineOperatorIPMatch            RulesEngineOperator = "IPMatch"
	RulesEngineOperatorLessThan           RulesEngineOperator = "LessThan"
	RulesEngineOperatorLessThanOrEqual    RulesEngineOperator = "LessThanOrEqual"
)

type RulesEngineProperties 

type RulesEngineProperties struct {
	ResourceState *FrontDoorResourceState `json:"resourceState,omitempty"`
	Rules         *[]RulesEngineRule      `json:"rules,omitempty"`
}

type RulesEngineRule 

type RulesEngineRule struct {
	Action                  RulesEngineAction            `json:"action"`
	MatchConditions         *[]RulesEngineMatchCondition `json:"matchConditions,omitempty"`
	MatchProcessingBehavior *MatchProcessingBehavior     `json:"matchProcessingBehavior,omitempty"`
	Name                    string                       `json:"name"`
	Priority                int64                        `json:"priority"`
}

type RulesEnginesCreateOrUpdateOperationResponse 

type RulesEnginesCreateOrUpdateOperationResponse struct {
	Poller       polling.LongRunningPoller
	HttpResponse *http.Response
	Model        *RulesEngine
}

type RulesEnginesDeleteOperationResponse 

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

type RulesEnginesGetOperationResponse 

type RulesEnginesGetOperationResponse struct {
	HttpResponse *http.Response
	Model        *RulesEngine
}

type RulesEnginesListByFrontDoorCompleteResult 

type RulesEnginesListByFrontDoorCompleteResult struct {
	Items []RulesEngine
}

type RulesEnginesListByFrontDoorOperationResponse 

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

func (RulesEnginesListByFrontDoorOperationResponse) HasMore 

func (r RulesEnginesListByFrontDoorOperationResponse) HasMore() bool

func (RulesEnginesListByFrontDoorOperationResponse) LoadMore 

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

type SessionAffinityEnabledState 

type SessionAffinityEnabledState string
const (
	SessionAffinityEnabledStateDisabled SessionAffinityEnabledState = "Disabled"
	SessionAffinityEnabledStateEnabled  SessionAffinityEnabledState = "Enabled"
)

type SubResource 

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

type Transform 

type Transform string
const (
	TransformLowercase   Transform = "Lowercase"
	TransformRemoveNulls Transform = "RemoveNulls"
	TransformTrim        Transform = "Trim"
	TransformUppercase   Transform = "Uppercase"
	TransformUrlDecode   Transform = "UrlDecode"
	TransformUrlEncode   Transform = "UrlEncode"
)

type ValidateCustomDomainInput 

type ValidateCustomDomainInput struct {
	HostName string `json:"hostName"`
}

type ValidateCustomDomainOperationResponse 

type ValidateCustomDomainOperationResponse struct {
	HttpResponse *http.Response
	Model        *ValidateCustomDomainOutput
}

type ValidateCustomDomainOutput 

type ValidateCustomDomainOutput struct {
	CustomDomainValidated *bool   `json:"customDomainValidated,omitempty"`
	Message               *string `json:"message,omitempty"`
	Reason                *string `json:"reason,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.