frontdoors

package
v0.20240131.1112007 Latest Latest
Warning

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

Go to latest
Published: Jan 31, 2024 License: MPL-2.0 Imports: 11 Imported by: 1

README

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

The frontdoors SDK allows for interaction with the Azure Resource Manager Service frontdoor (API Version 2020-04-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/frontdoor/2020-04-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 := frontdoors.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 := frontdoors.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"`
	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

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

Get ...

func (FrontDoorsClient) List

List ...

func (FrontDoorsClient) ListByResourceGroup

ListByResourceGroup ...

func (FrontDoorsClient) ListByResourceGroupComplete

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

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

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

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 (FrontendEndpointsListByFrontDoorOperationResponse) LoadMore

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 (ListByResourceGroupOperationResponse) LoadMore

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

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 (RulesEnginesListByFrontDoorOperationResponse) LoadMore

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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL