networkfirewall

package
v0.8.0 Latest Latest
Warning

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

 Go to latest Published: Nov 30, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	FirewallPolicyRuleOrderDefaultActionOrder = FirewallPolicyRuleOrder("DEFAULT_ACTION_ORDER")
	FirewallPolicyRuleOrderStrictOrder        = FirewallPolicyRuleOrder("STRICT_ORDER")
)
View Source 
const (
	LoggingConfigurationLogDestinationConfigLogDestinationTypeS3                  = LoggingConfigurationLogDestinationConfigLogDestinationType("S3")
	LoggingConfigurationLogDestinationConfigLogDestinationTypeCloudWatchLogs      = LoggingConfigurationLogDestinationConfigLogDestinationType("CloudWatchLogs")
	LoggingConfigurationLogDestinationConfigLogDestinationTypeKinesisDataFirehose = LoggingConfigurationLogDestinationConfigLogDestinationType("KinesisDataFirehose")
)
View Source 
const (
	LoggingConfigurationLogDestinationConfigLogTypeAlert = LoggingConfigurationLogDestinationConfigLogType("ALERT")
	LoggingConfigurationLogDestinationConfigLogTypeFlow  = LoggingConfigurationLogDestinationConfigLogType("FLOW")
)
View Source 
const (
	RuleGroupGeneratedRulesTypeAllowlist = RuleGroupGeneratedRulesType("ALLOWLIST")
	RuleGroupGeneratedRulesTypeDenylist  = RuleGroupGeneratedRulesType("DENYLIST")
)
View Source 
const (
	RuleGroupHeaderDirectionForward = RuleGroupHeaderDirection("FORWARD")
	RuleGroupHeaderDirectionAny     = RuleGroupHeaderDirection("ANY")
)
View Source 
const (
	RuleGroupHeaderProtocolIp     = RuleGroupHeaderProtocol("IP")
	RuleGroupHeaderProtocolTcp    = RuleGroupHeaderProtocol("TCP")
	RuleGroupHeaderProtocolUdp    = RuleGroupHeaderProtocol("UDP")
	RuleGroupHeaderProtocolIcmp   = RuleGroupHeaderProtocol("ICMP")
	RuleGroupHeaderProtocolHttp   = RuleGroupHeaderProtocol("HTTP")
	RuleGroupHeaderProtocolFtp    = RuleGroupHeaderProtocol("FTP")
	RuleGroupHeaderProtocolTls    = RuleGroupHeaderProtocol("TLS")
	RuleGroupHeaderProtocolSmb    = RuleGroupHeaderProtocol("SMB")
	RuleGroupHeaderProtocolDns    = RuleGroupHeaderProtocol("DNS")
	RuleGroupHeaderProtocolDcerpc = RuleGroupHeaderProtocol("DCERPC")
	RuleGroupHeaderProtocolSsh    = RuleGroupHeaderProtocol("SSH")
	RuleGroupHeaderProtocolSmtp   = RuleGroupHeaderProtocol("SMTP")
	RuleGroupHeaderProtocolImap   = RuleGroupHeaderProtocol("IMAP")
	RuleGroupHeaderProtocolMsn    = RuleGroupHeaderProtocol("MSN")
	RuleGroupHeaderProtocolKrb5   = RuleGroupHeaderProtocol("KRB5")
	RuleGroupHeaderProtocolIkev2  = RuleGroupHeaderProtocol("IKEV2")
	RuleGroupHeaderProtocolTftp   = RuleGroupHeaderProtocol("TFTP")
	RuleGroupHeaderProtocolNtp    = RuleGroupHeaderProtocol("NTP")
	RuleGroupHeaderProtocolDhcp   = RuleGroupHeaderProtocol("DHCP")
)
View Source 
const (
	RuleGroupRuleOrderDefaultActionOrder = RuleGroupRuleOrder("DEFAULT_ACTION_ORDER")
	RuleGroupRuleOrderStrictOrder        = RuleGroupRuleOrder("STRICT_ORDER")
)
View Source 
const (
	RuleGroupStatefulRuleActionPass  = RuleGroupStatefulRuleAction("PASS")
	RuleGroupStatefulRuleActionDrop  = RuleGroupStatefulRuleAction("DROP")
	RuleGroupStatefulRuleActionAlert = RuleGroupStatefulRuleAction("ALERT")
)
View Source 
const (
	RuleGroupTCPFlagFin = RuleGroupTCPFlag("FIN")
	RuleGroupTCPFlagSyn = RuleGroupTCPFlag("SYN")
	RuleGroupTCPFlagRst = RuleGroupTCPFlag("RST")
	RuleGroupTCPFlagPsh = RuleGroupTCPFlag("PSH")
	RuleGroupTCPFlagAck = RuleGroupTCPFlag("ACK")
	RuleGroupTCPFlagUrg = RuleGroupTCPFlag("URG")
	RuleGroupTCPFlagEce = RuleGroupTCPFlag("ECE")
	RuleGroupTCPFlagCwr = RuleGroupTCPFlag("CWR")
)
View Source 
const (
	RuleGroupTargetTypeTlsSni   = RuleGroupTargetType("TLS_SNI")
	RuleGroupTargetTypeHttpHost = RuleGroupTargetType("HTTP_HOST")
)
View Source 
const (
	RuleGroupTypeEnumStateless = RuleGroupTypeEnum("STATELESS")
	RuleGroupTypeEnumStateful  = RuleGroupTypeEnum("STATEFUL")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Firewall 

type Firewall struct {
	pulumi.CustomResourceState

	DeleteProtection               pulumi.BoolPtrOutput             `pulumi:"deleteProtection"`
	Description                    pulumi.StringPtrOutput           `pulumi:"description"`
	EndpointIds                    pulumi.StringArrayOutput         `pulumi:"endpointIds"`
	FirewallArn                    pulumi.StringOutput              `pulumi:"firewallArn"`
	FirewallId                     pulumi.StringOutput              `pulumi:"firewallId"`
	FirewallName                   pulumi.StringOutput              `pulumi:"firewallName"`
	FirewallPolicyArn              pulumi.StringOutput              `pulumi:"firewallPolicyArn"`
	FirewallPolicyChangeProtection pulumi.BoolPtrOutput             `pulumi:"firewallPolicyChangeProtection"`
	SubnetChangeProtection         pulumi.BoolPtrOutput             `pulumi:"subnetChangeProtection"`
	SubnetMappings                 FirewallSubnetMappingArrayOutput `pulumi:"subnetMappings"`
	Tags                           FirewallTagArrayOutput           `pulumi:"tags"`
	VpcId                          pulumi.StringOutput              `pulumi:"vpcId"`
}

Resource type definition for AWS::NetworkFirewall::Firewall

func GetFirewall 

func GetFirewall(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FirewallState, opts ...pulumi.ResourceOption) (*Firewall, error)

GetFirewall gets an existing Firewall resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFirewall 

func NewFirewall(ctx *pulumi.Context,
	name string, args *FirewallArgs, opts ...pulumi.ResourceOption) (*Firewall, error)

NewFirewall registers a new resource with the given unique name, arguments, and options.

func (*Firewall) ElementType 

func (*Firewall) ElementType() reflect.Type

func (*Firewall) ToFirewallOutput 

func (i *Firewall) ToFirewallOutput() FirewallOutput

func (*Firewall) ToFirewallOutputWithContext 

func (i *Firewall) ToFirewallOutputWithContext(ctx context.Context) FirewallOutput

type FirewallArgs 

type FirewallArgs struct {
	DeleteProtection               pulumi.BoolPtrInput
	Description                    pulumi.StringPtrInput
	FirewallName                   pulumi.StringPtrInput
	FirewallPolicyArn              pulumi.StringInput
	FirewallPolicyChangeProtection pulumi.BoolPtrInput
	SubnetChangeProtection         pulumi.BoolPtrInput
	SubnetMappings                 FirewallSubnetMappingArrayInput
	Tags                           FirewallTagArrayInput
	VpcId                          pulumi.StringInput
}

The set of arguments for constructing a Firewall resource.

func (FirewallArgs) ElementType 

func (FirewallArgs) ElementType() reflect.Type

type FirewallInput 

type FirewallInput interface {
	pulumi.Input

	ToFirewallOutput() FirewallOutput
	ToFirewallOutputWithContext(ctx context.Context) FirewallOutput
}

type FirewallOutput 

type FirewallOutput struct{ *pulumi.OutputState }

func (FirewallOutput) ElementType 

func (FirewallOutput) ElementType() reflect.Type

func (FirewallOutput) ToFirewallOutput 

func (o FirewallOutput) ToFirewallOutput() FirewallOutput

func (FirewallOutput) ToFirewallOutputWithContext 

func (o FirewallOutput) ToFirewallOutputWithContext(ctx context.Context) FirewallOutput

type FirewallPolicy 

type FirewallPolicy struct {
	pulumi.CustomResourceState

	Description        pulumi.StringPtrOutput       `pulumi:"description"`
	FirewallPolicy     FirewallPolicyTypeOutput     `pulumi:"firewallPolicy"`
	FirewallPolicyArn  pulumi.StringOutput          `pulumi:"firewallPolicyArn"`
	FirewallPolicyId   pulumi.StringOutput          `pulumi:"firewallPolicyId"`
	FirewallPolicyName pulumi.StringOutput          `pulumi:"firewallPolicyName"`
	Tags               FirewallPolicyTagArrayOutput `pulumi:"tags"`
}

Resource type definition for AWS::NetworkFirewall::FirewallPolicy

func GetFirewallPolicy 

func GetFirewallPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *FirewallPolicyState, opts ...pulumi.ResourceOption) (*FirewallPolicy, error)

GetFirewallPolicy gets an existing FirewallPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewFirewallPolicy 

func NewFirewallPolicy(ctx *pulumi.Context,
	name string, args *FirewallPolicyArgs, opts ...pulumi.ResourceOption) (*FirewallPolicy, error)

NewFirewallPolicy registers a new resource with the given unique name, arguments, and options.

func (*FirewallPolicy) ElementType 

func (*FirewallPolicy) ElementType() reflect.Type

func (*FirewallPolicy) ToFirewallPolicyOutput 

func (i *FirewallPolicy) ToFirewallPolicyOutput() FirewallPolicyOutput

func (*FirewallPolicy) ToFirewallPolicyOutputWithContext 

func (i *FirewallPolicy) ToFirewallPolicyOutputWithContext(ctx context.Context) FirewallPolicyOutput

type FirewallPolicyActionDefinition 

type FirewallPolicyActionDefinition struct {
	PublishMetricAction *FirewallPolicyPublishMetricAction `pulumi:"publishMetricAction"`
}

type FirewallPolicyActionDefinitionArgs 

type FirewallPolicyActionDefinitionArgs struct {
	PublishMetricAction FirewallPolicyPublishMetricActionPtrInput `pulumi:"publishMetricAction"`
}

func (FirewallPolicyActionDefinitionArgs) ElementType 

func (FirewallPolicyActionDefinitionArgs) ElementType() reflect.Type

func (FirewallPolicyActionDefinitionArgs) ToFirewallPolicyActionDefinitionOutput 

func (i FirewallPolicyActionDefinitionArgs) ToFirewallPolicyActionDefinitionOutput() FirewallPolicyActionDefinitionOutput

func (FirewallPolicyActionDefinitionArgs) ToFirewallPolicyActionDefinitionOutputWithContext 

func (i FirewallPolicyActionDefinitionArgs) ToFirewallPolicyActionDefinitionOutputWithContext(ctx context.Context) FirewallPolicyActionDefinitionOutput

type FirewallPolicyActionDefinitionInput 

type FirewallPolicyActionDefinitionInput interface {
	pulumi.Input

	ToFirewallPolicyActionDefinitionOutput() FirewallPolicyActionDefinitionOutput
	ToFirewallPolicyActionDefinitionOutputWithContext(context.Context) FirewallPolicyActionDefinitionOutput
}

FirewallPolicyActionDefinitionInput is an input type that accepts FirewallPolicyActionDefinitionArgs and FirewallPolicyActionDefinitionOutput values. You can construct a concrete instance of `FirewallPolicyActionDefinitionInput` via: 

FirewallPolicyActionDefinitionArgs{...}

type FirewallPolicyActionDefinitionOutput 

type FirewallPolicyActionDefinitionOutput struct{ *pulumi.OutputState }

func (FirewallPolicyActionDefinitionOutput) ElementType 

func (FirewallPolicyActionDefinitionOutput) ElementType() reflect.Type

func (FirewallPolicyActionDefinitionOutput) PublishMetricAction 

func (o FirewallPolicyActionDefinitionOutput) PublishMetricAction() FirewallPolicyPublishMetricActionPtrOutput

func (FirewallPolicyActionDefinitionOutput) ToFirewallPolicyActionDefinitionOutput 

func (o FirewallPolicyActionDefinitionOutput) ToFirewallPolicyActionDefinitionOutput() FirewallPolicyActionDefinitionOutput

func (FirewallPolicyActionDefinitionOutput) ToFirewallPolicyActionDefinitionOutputWithContext 

func (o FirewallPolicyActionDefinitionOutput) ToFirewallPolicyActionDefinitionOutputWithContext(ctx context.Context) FirewallPolicyActionDefinitionOutput

type FirewallPolicyArgs 

type FirewallPolicyArgs struct {
	Description        pulumi.StringPtrInput
	FirewallPolicy     FirewallPolicyTypeInput
	FirewallPolicyName pulumi.StringPtrInput
	Tags               FirewallPolicyTagArrayInput
}

The set of arguments for constructing a FirewallPolicy resource.

func (FirewallPolicyArgs) ElementType 

func (FirewallPolicyArgs) ElementType() reflect.Type

type FirewallPolicyCustomAction 

type FirewallPolicyCustomAction struct {
	ActionDefinition FirewallPolicyActionDefinition `pulumi:"actionDefinition"`
	ActionName       string                         `pulumi:"actionName"`
}

type FirewallPolicyCustomActionArgs 

type FirewallPolicyCustomActionArgs struct {
	ActionDefinition FirewallPolicyActionDefinitionInput `pulumi:"actionDefinition"`
	ActionName       pulumi.StringInput                  `pulumi:"actionName"`
}

func (FirewallPolicyCustomActionArgs) ElementType 

func (FirewallPolicyCustomActionArgs) ElementType() reflect.Type

func (FirewallPolicyCustomActionArgs) ToFirewallPolicyCustomActionOutput 

func (i FirewallPolicyCustomActionArgs) ToFirewallPolicyCustomActionOutput() FirewallPolicyCustomActionOutput

func (FirewallPolicyCustomActionArgs) ToFirewallPolicyCustomActionOutputWithContext 

func (i FirewallPolicyCustomActionArgs) ToFirewallPolicyCustomActionOutputWithContext(ctx context.Context) FirewallPolicyCustomActionOutput

type FirewallPolicyCustomActionArray 

type FirewallPolicyCustomActionArray []FirewallPolicyCustomActionInput

func (FirewallPolicyCustomActionArray) ElementType 

func (FirewallPolicyCustomActionArray) ElementType() reflect.Type

func (FirewallPolicyCustomActionArray) ToFirewallPolicyCustomActionArrayOutput 

func (i FirewallPolicyCustomActionArray) ToFirewallPolicyCustomActionArrayOutput() FirewallPolicyCustomActionArrayOutput

func (FirewallPolicyCustomActionArray) ToFirewallPolicyCustomActionArrayOutputWithContext 

func (i FirewallPolicyCustomActionArray) ToFirewallPolicyCustomActionArrayOutputWithContext(ctx context.Context) FirewallPolicyCustomActionArrayOutput

type FirewallPolicyCustomActionArrayInput 

type FirewallPolicyCustomActionArrayInput interface {
	pulumi.Input

	ToFirewallPolicyCustomActionArrayOutput() FirewallPolicyCustomActionArrayOutput
	ToFirewallPolicyCustomActionArrayOutputWithContext(context.Context) FirewallPolicyCustomActionArrayOutput
}

FirewallPolicyCustomActionArrayInput is an input type that accepts FirewallPolicyCustomActionArray and FirewallPolicyCustomActionArrayOutput values. You can construct a concrete instance of `FirewallPolicyCustomActionArrayInput` via: 

FirewallPolicyCustomActionArray{ FirewallPolicyCustomActionArgs{...} }

type FirewallPolicyCustomActionArrayOutput 

type FirewallPolicyCustomActionArrayOutput struct{ *pulumi.OutputState }

func (FirewallPolicyCustomActionArrayOutput) ElementType 

func (FirewallPolicyCustomActionArrayOutput) ElementType() reflect.Type

func (FirewallPolicyCustomActionArrayOutput) Index 

func (o FirewallPolicyCustomActionArrayOutput) Index(i pulumi.IntInput) FirewallPolicyCustomActionOutput

func (FirewallPolicyCustomActionArrayOutput) ToFirewallPolicyCustomActionArrayOutput 

func (o FirewallPolicyCustomActionArrayOutput) ToFirewallPolicyCustomActionArrayOutput() FirewallPolicyCustomActionArrayOutput

func (FirewallPolicyCustomActionArrayOutput) ToFirewallPolicyCustomActionArrayOutputWithContext 

func (o FirewallPolicyCustomActionArrayOutput) ToFirewallPolicyCustomActionArrayOutputWithContext(ctx context.Context) FirewallPolicyCustomActionArrayOutput

type FirewallPolicyCustomActionInput 

type FirewallPolicyCustomActionInput interface {
	pulumi.Input

	ToFirewallPolicyCustomActionOutput() FirewallPolicyCustomActionOutput
	ToFirewallPolicyCustomActionOutputWithContext(context.Context) FirewallPolicyCustomActionOutput
}

FirewallPolicyCustomActionInput is an input type that accepts FirewallPolicyCustomActionArgs and FirewallPolicyCustomActionOutput values. You can construct a concrete instance of `FirewallPolicyCustomActionInput` via: 

FirewallPolicyCustomActionArgs{...}

type FirewallPolicyCustomActionOutput 

type FirewallPolicyCustomActionOutput struct{ *pulumi.OutputState }

func (FirewallPolicyCustomActionOutput) ActionDefinition 

func (o FirewallPolicyCustomActionOutput) ActionDefinition() FirewallPolicyActionDefinitionOutput

func (FirewallPolicyCustomActionOutput) ActionName 

func (o FirewallPolicyCustomActionOutput) ActionName() pulumi.StringOutput

func (FirewallPolicyCustomActionOutput) ElementType 

func (FirewallPolicyCustomActionOutput) ElementType() reflect.Type

func (FirewallPolicyCustomActionOutput) ToFirewallPolicyCustomActionOutput 

func (o FirewallPolicyCustomActionOutput) ToFirewallPolicyCustomActionOutput() FirewallPolicyCustomActionOutput

func (FirewallPolicyCustomActionOutput) ToFirewallPolicyCustomActionOutputWithContext 

func (o FirewallPolicyCustomActionOutput) ToFirewallPolicyCustomActionOutputWithContext(ctx context.Context) FirewallPolicyCustomActionOutput

type FirewallPolicyDimension 

type FirewallPolicyDimension struct {
	Value string `pulumi:"value"`
}

type FirewallPolicyDimensionArgs 

type FirewallPolicyDimensionArgs struct {
	Value pulumi.StringInput `pulumi:"value"`
}

func (FirewallPolicyDimensionArgs) ElementType 

func (FirewallPolicyDimensionArgs) ElementType() reflect.Type

func (FirewallPolicyDimensionArgs) ToFirewallPolicyDimensionOutput 

func (i FirewallPolicyDimensionArgs) ToFirewallPolicyDimensionOutput() FirewallPolicyDimensionOutput

func (FirewallPolicyDimensionArgs) ToFirewallPolicyDimensionOutputWithContext 

func (i FirewallPolicyDimensionArgs) ToFirewallPolicyDimensionOutputWithContext(ctx context.Context) FirewallPolicyDimensionOutput

type FirewallPolicyDimensionArray 

type FirewallPolicyDimensionArray []FirewallPolicyDimensionInput

func (FirewallPolicyDimensionArray) ElementType 

func (FirewallPolicyDimensionArray) ElementType() reflect.Type

func (FirewallPolicyDimensionArray) ToFirewallPolicyDimensionArrayOutput 

func (i FirewallPolicyDimensionArray) ToFirewallPolicyDimensionArrayOutput() FirewallPolicyDimensionArrayOutput

func (FirewallPolicyDimensionArray) ToFirewallPolicyDimensionArrayOutputWithContext 

func (i FirewallPolicyDimensionArray) ToFirewallPolicyDimensionArrayOutputWithContext(ctx context.Context) FirewallPolicyDimensionArrayOutput

type FirewallPolicyDimensionArrayInput 

type FirewallPolicyDimensionArrayInput interface {
	pulumi.Input

	ToFirewallPolicyDimensionArrayOutput() FirewallPolicyDimensionArrayOutput
	ToFirewallPolicyDimensionArrayOutputWithContext(context.Context) FirewallPolicyDimensionArrayOutput
}

FirewallPolicyDimensionArrayInput is an input type that accepts FirewallPolicyDimensionArray and FirewallPolicyDimensionArrayOutput values. You can construct a concrete instance of `FirewallPolicyDimensionArrayInput` via: 

FirewallPolicyDimensionArray{ FirewallPolicyDimensionArgs{...} }

type FirewallPolicyDimensionArrayOutput 

type FirewallPolicyDimensionArrayOutput struct{ *pulumi.OutputState }

func (FirewallPolicyDimensionArrayOutput) ElementType 

func (FirewallPolicyDimensionArrayOutput) ElementType() reflect.Type

func (FirewallPolicyDimensionArrayOutput) Index 

func (o FirewallPolicyDimensionArrayOutput) Index(i pulumi.IntInput) FirewallPolicyDimensionOutput

func (FirewallPolicyDimensionArrayOutput) ToFirewallPolicyDimensionArrayOutput 

func (o FirewallPolicyDimensionArrayOutput) ToFirewallPolicyDimensionArrayOutput() FirewallPolicyDimensionArrayOutput

func (FirewallPolicyDimensionArrayOutput) ToFirewallPolicyDimensionArrayOutputWithContext 

func (o FirewallPolicyDimensionArrayOutput) ToFirewallPolicyDimensionArrayOutputWithContext(ctx context.Context) FirewallPolicyDimensionArrayOutput

type FirewallPolicyDimensionInput 

type FirewallPolicyDimensionInput interface {
	pulumi.Input

	ToFirewallPolicyDimensionOutput() FirewallPolicyDimensionOutput
	ToFirewallPolicyDimensionOutputWithContext(context.Context) FirewallPolicyDimensionOutput
}

FirewallPolicyDimensionInput is an input type that accepts FirewallPolicyDimensionArgs and FirewallPolicyDimensionOutput values. You can construct a concrete instance of `FirewallPolicyDimensionInput` via: 

FirewallPolicyDimensionArgs{...}

type FirewallPolicyDimensionOutput 

type FirewallPolicyDimensionOutput struct{ *pulumi.OutputState }

func (FirewallPolicyDimensionOutput) ElementType 

func (FirewallPolicyDimensionOutput) ElementType() reflect.Type

func (FirewallPolicyDimensionOutput) ToFirewallPolicyDimensionOutput 

func (o FirewallPolicyDimensionOutput) ToFirewallPolicyDimensionOutput() FirewallPolicyDimensionOutput

func (FirewallPolicyDimensionOutput) ToFirewallPolicyDimensionOutputWithContext 

func (o FirewallPolicyDimensionOutput) ToFirewallPolicyDimensionOutputWithContext(ctx context.Context) FirewallPolicyDimensionOutput

func (FirewallPolicyDimensionOutput) Value 

func (o FirewallPolicyDimensionOutput) Value() pulumi.StringOutput

type FirewallPolicyInput 

type FirewallPolicyInput interface {
	pulumi.Input

	ToFirewallPolicyOutput() FirewallPolicyOutput
	ToFirewallPolicyOutputWithContext(ctx context.Context) FirewallPolicyOutput
}

type FirewallPolicyOutput 

type FirewallPolicyOutput struct{ *pulumi.OutputState }

func (FirewallPolicyOutput) ElementType 

func (FirewallPolicyOutput) ElementType() reflect.Type

func (FirewallPolicyOutput) ToFirewallPolicyOutput 

func (o FirewallPolicyOutput) ToFirewallPolicyOutput() FirewallPolicyOutput

func (FirewallPolicyOutput) ToFirewallPolicyOutputWithContext 

func (o FirewallPolicyOutput) ToFirewallPolicyOutputWithContext(ctx context.Context) FirewallPolicyOutput

type FirewallPolicyPublishMetricAction 

type FirewallPolicyPublishMetricAction struct {
	Dimensions []FirewallPolicyDimension `pulumi:"dimensions"`
}

type FirewallPolicyPublishMetricActionArgs 

type FirewallPolicyPublishMetricActionArgs struct {
	Dimensions FirewallPolicyDimensionArrayInput `pulumi:"dimensions"`
}

func (FirewallPolicyPublishMetricActionArgs) ElementType 

func (FirewallPolicyPublishMetricActionArgs) ElementType() reflect.Type

func (FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionOutput 

func (i FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionOutput() FirewallPolicyPublishMetricActionOutput

func (FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionOutputWithContext 

func (i FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionOutputWithContext(ctx context.Context) FirewallPolicyPublishMetricActionOutput

func (FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionPtrOutput 

func (i FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionPtrOutput() FirewallPolicyPublishMetricActionPtrOutput

func (FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionPtrOutputWithContext 

func (i FirewallPolicyPublishMetricActionArgs) ToFirewallPolicyPublishMetricActionPtrOutputWithContext(ctx context.Context) FirewallPolicyPublishMetricActionPtrOutput

type FirewallPolicyPublishMetricActionInput 

type FirewallPolicyPublishMetricActionInput interface {
	pulumi.Input

	ToFirewallPolicyPublishMetricActionOutput() FirewallPolicyPublishMetricActionOutput
	ToFirewallPolicyPublishMetricActionOutputWithContext(context.Context) FirewallPolicyPublishMetricActionOutput
}

FirewallPolicyPublishMetricActionInput is an input type that accepts FirewallPolicyPublishMetricActionArgs and FirewallPolicyPublishMetricActionOutput values. You can construct a concrete instance of `FirewallPolicyPublishMetricActionInput` via: 

FirewallPolicyPublishMetricActionArgs{...}

type FirewallPolicyPublishMetricActionOutput 

type FirewallPolicyPublishMetricActionOutput struct{ *pulumi.OutputState }

func (FirewallPolicyPublishMetricActionOutput) Dimensions 

func (o FirewallPolicyPublishMetricActionOutput) Dimensions() FirewallPolicyDimensionArrayOutput

func (FirewallPolicyPublishMetricActionOutput) ElementType 

func (FirewallPolicyPublishMetricActionOutput) ElementType() reflect.Type

func (FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionOutput 

func (o FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionOutput() FirewallPolicyPublishMetricActionOutput

func (FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionOutputWithContext 

func (o FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionOutputWithContext(ctx context.Context) FirewallPolicyPublishMetricActionOutput

func (FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionPtrOutput 

func (o FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionPtrOutput() FirewallPolicyPublishMetricActionPtrOutput

func (FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionPtrOutputWithContext 

func (o FirewallPolicyPublishMetricActionOutput) ToFirewallPolicyPublishMetricActionPtrOutputWithContext(ctx context.Context) FirewallPolicyPublishMetricActionPtrOutput

type FirewallPolicyPublishMetricActionPtrInput 

type FirewallPolicyPublishMetricActionPtrInput interface {
	pulumi.Input

	ToFirewallPolicyPublishMetricActionPtrOutput() FirewallPolicyPublishMetricActionPtrOutput
	ToFirewallPolicyPublishMetricActionPtrOutputWithContext(context.Context) FirewallPolicyPublishMetricActionPtrOutput
}

FirewallPolicyPublishMetricActionPtrInput is an input type that accepts FirewallPolicyPublishMetricActionArgs, FirewallPolicyPublishMetricActionPtr and FirewallPolicyPublishMetricActionPtrOutput values. You can construct a concrete instance of `FirewallPolicyPublishMetricActionPtrInput` via: 

        FirewallPolicyPublishMetricActionArgs{...}

or:

        nil

func FirewallPolicyPublishMetricActionPtr 

func FirewallPolicyPublishMetricActionPtr(v *FirewallPolicyPublishMetricActionArgs) FirewallPolicyPublishMetricActionPtrInput

type FirewallPolicyPublishMetricActionPtrOutput 

type FirewallPolicyPublishMetricActionPtrOutput struct{ *pulumi.OutputState }

func (FirewallPolicyPublishMetricActionPtrOutput) Dimensions 

func (o FirewallPolicyPublishMetricActionPtrOutput) Dimensions() FirewallPolicyDimensionArrayOutput

func (FirewallPolicyPublishMetricActionPtrOutput) Elem 

func (o FirewallPolicyPublishMetricActionPtrOutput) Elem() FirewallPolicyPublishMetricActionOutput

func (FirewallPolicyPublishMetricActionPtrOutput) ElementType 

func (FirewallPolicyPublishMetricActionPtrOutput) ElementType() reflect.Type

func (FirewallPolicyPublishMetricActionPtrOutput) ToFirewallPolicyPublishMetricActionPtrOutput 

func (o FirewallPolicyPublishMetricActionPtrOutput) ToFirewallPolicyPublishMetricActionPtrOutput() FirewallPolicyPublishMetricActionPtrOutput

func (FirewallPolicyPublishMetricActionPtrOutput) ToFirewallPolicyPublishMetricActionPtrOutputWithContext 

func (o FirewallPolicyPublishMetricActionPtrOutput) ToFirewallPolicyPublishMetricActionPtrOutputWithContext(ctx context.Context) FirewallPolicyPublishMetricActionPtrOutput

type FirewallPolicyRuleOrder added in v0.3.0 

type FirewallPolicyRuleOrder string

func (FirewallPolicyRuleOrder) ElementType added in v0.3.0 

func (FirewallPolicyRuleOrder) ElementType() reflect.Type

func (FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderOutput added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderOutput() FirewallPolicyRuleOrderOutput

func (FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderOutputWithContext added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderOutputWithContext(ctx context.Context) FirewallPolicyRuleOrderOutput

func (FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderPtrOutput added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderPtrOutput() FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderPtrOutputWithContext added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToFirewallPolicyRuleOrderPtrOutputWithContext(ctx context.Context) FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyRuleOrder) ToStringOutput added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToStringOutput() pulumi.StringOutput

func (FirewallPolicyRuleOrder) ToStringOutputWithContext added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (FirewallPolicyRuleOrder) ToStringPtrOutput added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToStringPtrOutput() pulumi.StringPtrOutput

func (FirewallPolicyRuleOrder) ToStringPtrOutputWithContext added in v0.3.0 

func (e FirewallPolicyRuleOrder) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type FirewallPolicyRuleOrderInput added in v0.3.0 

type FirewallPolicyRuleOrderInput interface {
	pulumi.Input

	ToFirewallPolicyRuleOrderOutput() FirewallPolicyRuleOrderOutput
	ToFirewallPolicyRuleOrderOutputWithContext(context.Context) FirewallPolicyRuleOrderOutput
}

FirewallPolicyRuleOrderInput is an input type that accepts FirewallPolicyRuleOrderArgs and FirewallPolicyRuleOrderOutput values. You can construct a concrete instance of `FirewallPolicyRuleOrderInput` via: 

FirewallPolicyRuleOrderArgs{...}

type FirewallPolicyRuleOrderOutput added in v0.3.0 

type FirewallPolicyRuleOrderOutput struct{ *pulumi.OutputState }

func (FirewallPolicyRuleOrderOutput) ElementType added in v0.3.0 

func (FirewallPolicyRuleOrderOutput) ElementType() reflect.Type

func (FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderOutput added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderOutput() FirewallPolicyRuleOrderOutput

func (FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderOutputWithContext added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderOutputWithContext(ctx context.Context) FirewallPolicyRuleOrderOutput

func (FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderPtrOutput added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderPtrOutput() FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderPtrOutputWithContext added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToFirewallPolicyRuleOrderPtrOutputWithContext(ctx context.Context) FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyRuleOrderOutput) ToStringOutput added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToStringOutput() pulumi.StringOutput

func (FirewallPolicyRuleOrderOutput) ToStringOutputWithContext added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (FirewallPolicyRuleOrderOutput) ToStringPtrOutput added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (FirewallPolicyRuleOrderOutput) ToStringPtrOutputWithContext added in v0.3.0 

func (o FirewallPolicyRuleOrderOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type FirewallPolicyRuleOrderPtrInput added in v0.3.0 

type FirewallPolicyRuleOrderPtrInput interface {
	pulumi.Input

	ToFirewallPolicyRuleOrderPtrOutput() FirewallPolicyRuleOrderPtrOutput
	ToFirewallPolicyRuleOrderPtrOutputWithContext(context.Context) FirewallPolicyRuleOrderPtrOutput
}

func FirewallPolicyRuleOrderPtr added in v0.3.0 

func FirewallPolicyRuleOrderPtr(v string) FirewallPolicyRuleOrderPtrInput

type FirewallPolicyRuleOrderPtrOutput added in v0.3.0 

type FirewallPolicyRuleOrderPtrOutput struct{ *pulumi.OutputState }

func (FirewallPolicyRuleOrderPtrOutput) Elem added in v0.3.0 

func (o FirewallPolicyRuleOrderPtrOutput) Elem() FirewallPolicyRuleOrderOutput

func (FirewallPolicyRuleOrderPtrOutput) ElementType added in v0.3.0 

func (FirewallPolicyRuleOrderPtrOutput) ElementType() reflect.Type

func (FirewallPolicyRuleOrderPtrOutput) ToFirewallPolicyRuleOrderPtrOutput added in v0.3.0 

func (o FirewallPolicyRuleOrderPtrOutput) ToFirewallPolicyRuleOrderPtrOutput() FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyRuleOrderPtrOutput) ToFirewallPolicyRuleOrderPtrOutputWithContext added in v0.3.0 

func (o FirewallPolicyRuleOrderPtrOutput) ToFirewallPolicyRuleOrderPtrOutputWithContext(ctx context.Context) FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyRuleOrderPtrOutput) ToStringPtrOutput added in v0.3.0 

func (o FirewallPolicyRuleOrderPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (FirewallPolicyRuleOrderPtrOutput) ToStringPtrOutputWithContext added in v0.3.0 

func (o FirewallPolicyRuleOrderPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type FirewallPolicyState 

type FirewallPolicyState struct {
}

func (FirewallPolicyState) ElementType 

func (FirewallPolicyState) ElementType() reflect.Type

type FirewallPolicyStatefulEngineOptions added in v0.3.0 

type FirewallPolicyStatefulEngineOptions struct {
	RuleOrder *FirewallPolicyRuleOrder `pulumi:"ruleOrder"`
}

type FirewallPolicyStatefulEngineOptionsArgs added in v0.3.0 

type FirewallPolicyStatefulEngineOptionsArgs struct {
	RuleOrder FirewallPolicyRuleOrderPtrInput `pulumi:"ruleOrder"`
}

func (FirewallPolicyStatefulEngineOptionsArgs) ElementType added in v0.3.0 

func (FirewallPolicyStatefulEngineOptionsArgs) ElementType() reflect.Type

func (FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsOutput added in v0.3.0 

func (i FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsOutput() FirewallPolicyStatefulEngineOptionsOutput

func (FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsOutputWithContext added in v0.3.0 

func (i FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsOutputWithContext(ctx context.Context) FirewallPolicyStatefulEngineOptionsOutput

func (FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsPtrOutput added in v0.3.0 

func (i FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsPtrOutput() FirewallPolicyStatefulEngineOptionsPtrOutput

func (FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext added in v0.3.0 

func (i FirewallPolicyStatefulEngineOptionsArgs) ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext(ctx context.Context) FirewallPolicyStatefulEngineOptionsPtrOutput

type FirewallPolicyStatefulEngineOptionsInput added in v0.3.0 

type FirewallPolicyStatefulEngineOptionsInput interface {
	pulumi.Input

	ToFirewallPolicyStatefulEngineOptionsOutput() FirewallPolicyStatefulEngineOptionsOutput
	ToFirewallPolicyStatefulEngineOptionsOutputWithContext(context.Context) FirewallPolicyStatefulEngineOptionsOutput
}

FirewallPolicyStatefulEngineOptionsInput is an input type that accepts FirewallPolicyStatefulEngineOptionsArgs and FirewallPolicyStatefulEngineOptionsOutput values. You can construct a concrete instance of `FirewallPolicyStatefulEngineOptionsInput` via: 

FirewallPolicyStatefulEngineOptionsArgs{...}

type FirewallPolicyStatefulEngineOptionsOutput added in v0.3.0 

type FirewallPolicyStatefulEngineOptionsOutput struct{ *pulumi.OutputState }

func (FirewallPolicyStatefulEngineOptionsOutput) ElementType added in v0.3.0 

func (FirewallPolicyStatefulEngineOptionsOutput) ElementType() reflect.Type

func (FirewallPolicyStatefulEngineOptionsOutput) RuleOrder added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsOutput) RuleOrder() FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsOutput added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsOutput() FirewallPolicyStatefulEngineOptionsOutput

func (FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsOutputWithContext added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsOutputWithContext(ctx context.Context) FirewallPolicyStatefulEngineOptionsOutput

func (FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutput added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutput() FirewallPolicyStatefulEngineOptionsPtrOutput

func (FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext(ctx context.Context) FirewallPolicyStatefulEngineOptionsPtrOutput

type FirewallPolicyStatefulEngineOptionsPtrInput added in v0.3.0 

type FirewallPolicyStatefulEngineOptionsPtrInput interface {
	pulumi.Input

	ToFirewallPolicyStatefulEngineOptionsPtrOutput() FirewallPolicyStatefulEngineOptionsPtrOutput
	ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext(context.Context) FirewallPolicyStatefulEngineOptionsPtrOutput
}

FirewallPolicyStatefulEngineOptionsPtrInput is an input type that accepts FirewallPolicyStatefulEngineOptionsArgs, FirewallPolicyStatefulEngineOptionsPtr and FirewallPolicyStatefulEngineOptionsPtrOutput values. You can construct a concrete instance of `FirewallPolicyStatefulEngineOptionsPtrInput` via: 

        FirewallPolicyStatefulEngineOptionsArgs{...}

or:

        nil

func FirewallPolicyStatefulEngineOptionsPtr added in v0.3.0 

func FirewallPolicyStatefulEngineOptionsPtr(v *FirewallPolicyStatefulEngineOptionsArgs) FirewallPolicyStatefulEngineOptionsPtrInput

type FirewallPolicyStatefulEngineOptionsPtrOutput added in v0.3.0 

type FirewallPolicyStatefulEngineOptionsPtrOutput struct{ *pulumi.OutputState }

func (FirewallPolicyStatefulEngineOptionsPtrOutput) Elem added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsPtrOutput) Elem() FirewallPolicyStatefulEngineOptionsOutput

func (FirewallPolicyStatefulEngineOptionsPtrOutput) ElementType added in v0.3.0 

func (FirewallPolicyStatefulEngineOptionsPtrOutput) ElementType() reflect.Type

func (FirewallPolicyStatefulEngineOptionsPtrOutput) RuleOrder added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsPtrOutput) RuleOrder() FirewallPolicyRuleOrderPtrOutput

func (FirewallPolicyStatefulEngineOptionsPtrOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutput added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsPtrOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutput() FirewallPolicyStatefulEngineOptionsPtrOutput

func (FirewallPolicyStatefulEngineOptionsPtrOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext added in v0.3.0 

func (o FirewallPolicyStatefulEngineOptionsPtrOutput) ToFirewallPolicyStatefulEngineOptionsPtrOutputWithContext(ctx context.Context) FirewallPolicyStatefulEngineOptionsPtrOutput

type FirewallPolicyStatefulRuleGroupReference 

type FirewallPolicyStatefulRuleGroupReference struct {
	Priority    *int   `pulumi:"priority"`
	ResourceArn string `pulumi:"resourceArn"`
}

type FirewallPolicyStatefulRuleGroupReferenceArgs 

type FirewallPolicyStatefulRuleGroupReferenceArgs struct {
	Priority    pulumi.IntPtrInput `pulumi:"priority"`
	ResourceArn pulumi.StringInput `pulumi:"resourceArn"`
}

func (FirewallPolicyStatefulRuleGroupReferenceArgs) ElementType 

func (FirewallPolicyStatefulRuleGroupReferenceArgs) ElementType() reflect.Type

func (FirewallPolicyStatefulRuleGroupReferenceArgs) ToFirewallPolicyStatefulRuleGroupReferenceOutput 

func (i FirewallPolicyStatefulRuleGroupReferenceArgs) ToFirewallPolicyStatefulRuleGroupReferenceOutput() FirewallPolicyStatefulRuleGroupReferenceOutput

func (FirewallPolicyStatefulRuleGroupReferenceArgs) ToFirewallPolicyStatefulRuleGroupReferenceOutputWithContext 

func (i FirewallPolicyStatefulRuleGroupReferenceArgs) ToFirewallPolicyStatefulRuleGroupReferenceOutputWithContext(ctx context.Context) FirewallPolicyStatefulRuleGroupReferenceOutput

type FirewallPolicyStatefulRuleGroupReferenceArray 

type FirewallPolicyStatefulRuleGroupReferenceArray []FirewallPolicyStatefulRuleGroupReferenceInput

func (FirewallPolicyStatefulRuleGroupReferenceArray) ElementType 

func (FirewallPolicyStatefulRuleGroupReferenceArray) ElementType() reflect.Type

func (FirewallPolicyStatefulRuleGroupReferenceArray) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutput 

func (i FirewallPolicyStatefulRuleGroupReferenceArray) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutput() FirewallPolicyStatefulRuleGroupReferenceArrayOutput

func (FirewallPolicyStatefulRuleGroupReferenceArray) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutputWithContext 

func (i FirewallPolicyStatefulRuleGroupReferenceArray) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutputWithContext(ctx context.Context) FirewallPolicyStatefulRuleGroupReferenceArrayOutput

type FirewallPolicyStatefulRuleGroupReferenceArrayInput 

type FirewallPolicyStatefulRuleGroupReferenceArrayInput interface {
	pulumi.Input

	ToFirewallPolicyStatefulRuleGroupReferenceArrayOutput() FirewallPolicyStatefulRuleGroupReferenceArrayOutput
	ToFirewallPolicyStatefulRuleGroupReferenceArrayOutputWithContext(context.Context) FirewallPolicyStatefulRuleGroupReferenceArrayOutput
}

FirewallPolicyStatefulRuleGroupReferenceArrayInput is an input type that accepts FirewallPolicyStatefulRuleGroupReferenceArray and FirewallPolicyStatefulRuleGroupReferenceArrayOutput values. You can construct a concrete instance of `FirewallPolicyStatefulRuleGroupReferenceArrayInput` via: 

FirewallPolicyStatefulRuleGroupReferenceArray{ FirewallPolicyStatefulRuleGroupReferenceArgs{...} }

type FirewallPolicyStatefulRuleGroupReferenceArrayOutput 

type FirewallPolicyStatefulRuleGroupReferenceArrayOutput struct{ *pulumi.OutputState }

func (FirewallPolicyStatefulRuleGroupReferenceArrayOutput) ElementType 

func (FirewallPolicyStatefulRuleGroupReferenceArrayOutput) ElementType() reflect.Type

func (FirewallPolicyStatefulRuleGroupReferenceArrayOutput) Index 

func (o FirewallPolicyStatefulRuleGroupReferenceArrayOutput) Index(i pulumi.IntInput) FirewallPolicyStatefulRuleGroupReferenceOutput

func (FirewallPolicyStatefulRuleGroupReferenceArrayOutput) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutput 

func (o FirewallPolicyStatefulRuleGroupReferenceArrayOutput) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutput() FirewallPolicyStatefulRuleGroupReferenceArrayOutput

func (FirewallPolicyStatefulRuleGroupReferenceArrayOutput) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutputWithContext 

func (o FirewallPolicyStatefulRuleGroupReferenceArrayOutput) ToFirewallPolicyStatefulRuleGroupReferenceArrayOutputWithContext(ctx context.Context) FirewallPolicyStatefulRuleGroupReferenceArrayOutput

type FirewallPolicyStatefulRuleGroupReferenceInput 

type FirewallPolicyStatefulRuleGroupReferenceInput interface {
	pulumi.Input

	ToFirewallPolicyStatefulRuleGroupReferenceOutput() FirewallPolicyStatefulRuleGroupReferenceOutput
	ToFirewallPolicyStatefulRuleGroupReferenceOutputWithContext(context.Context) FirewallPolicyStatefulRuleGroupReferenceOutput
}

FirewallPolicyStatefulRuleGroupReferenceInput is an input type that accepts FirewallPolicyStatefulRuleGroupReferenceArgs and FirewallPolicyStatefulRuleGroupReferenceOutput values. You can construct a concrete instance of `FirewallPolicyStatefulRuleGroupReferenceInput` via: 

FirewallPolicyStatefulRuleGroupReferenceArgs{...}

type FirewallPolicyStatefulRuleGroupReferenceOutput 

type FirewallPolicyStatefulRuleGroupReferenceOutput struct{ *pulumi.OutputState }

func (FirewallPolicyStatefulRuleGroupReferenceOutput) ElementType 

func (FirewallPolicyStatefulRuleGroupReferenceOutput) ElementType() reflect.Type

func (FirewallPolicyStatefulRuleGroupReferenceOutput) Priority added in v0.3.0 

func (o FirewallPolicyStatefulRuleGroupReferenceOutput) Priority() pulumi.IntPtrOutput

func (FirewallPolicyStatefulRuleGroupReferenceOutput) ResourceArn 

func (o FirewallPolicyStatefulRuleGroupReferenceOutput) ResourceArn() pulumi.StringOutput

func (FirewallPolicyStatefulRuleGroupReferenceOutput) ToFirewallPolicyStatefulRuleGroupReferenceOutput 

func (o FirewallPolicyStatefulRuleGroupReferenceOutput) ToFirewallPolicyStatefulRuleGroupReferenceOutput() FirewallPolicyStatefulRuleGroupReferenceOutput

func (FirewallPolicyStatefulRuleGroupReferenceOutput) ToFirewallPolicyStatefulRuleGroupReferenceOutputWithContext 

func (o FirewallPolicyStatefulRuleGroupReferenceOutput) ToFirewallPolicyStatefulRuleGroupReferenceOutputWithContext(ctx context.Context) FirewallPolicyStatefulRuleGroupReferenceOutput

type FirewallPolicyStatelessRuleGroupReference 

type FirewallPolicyStatelessRuleGroupReference struct {
	Priority    int    `pulumi:"priority"`
	ResourceArn string `pulumi:"resourceArn"`
}

type FirewallPolicyStatelessRuleGroupReferenceArgs 

type FirewallPolicyStatelessRuleGroupReferenceArgs struct {
	Priority    pulumi.IntInput    `pulumi:"priority"`
	ResourceArn pulumi.StringInput `pulumi:"resourceArn"`
}

func (FirewallPolicyStatelessRuleGroupReferenceArgs) ElementType 

func (FirewallPolicyStatelessRuleGroupReferenceArgs) ElementType() reflect.Type

func (FirewallPolicyStatelessRuleGroupReferenceArgs) ToFirewallPolicyStatelessRuleGroupReferenceOutput 

func (i FirewallPolicyStatelessRuleGroupReferenceArgs) ToFirewallPolicyStatelessRuleGroupReferenceOutput() FirewallPolicyStatelessRuleGroupReferenceOutput

func (FirewallPolicyStatelessRuleGroupReferenceArgs) ToFirewallPolicyStatelessRuleGroupReferenceOutputWithContext 

func (i FirewallPolicyStatelessRuleGroupReferenceArgs) ToFirewallPolicyStatelessRuleGroupReferenceOutputWithContext(ctx context.Context) FirewallPolicyStatelessRuleGroupReferenceOutput

type FirewallPolicyStatelessRuleGroupReferenceArray 

type FirewallPolicyStatelessRuleGroupReferenceArray []FirewallPolicyStatelessRuleGroupReferenceInput

func (FirewallPolicyStatelessRuleGroupReferenceArray) ElementType 

func (FirewallPolicyStatelessRuleGroupReferenceArray) ElementType() reflect.Type

func (FirewallPolicyStatelessRuleGroupReferenceArray) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutput 

func (i FirewallPolicyStatelessRuleGroupReferenceArray) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutput() FirewallPolicyStatelessRuleGroupReferenceArrayOutput

func (FirewallPolicyStatelessRuleGroupReferenceArray) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutputWithContext 

func (i FirewallPolicyStatelessRuleGroupReferenceArray) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutputWithContext(ctx context.Context) FirewallPolicyStatelessRuleGroupReferenceArrayOutput

type FirewallPolicyStatelessRuleGroupReferenceArrayInput 

type FirewallPolicyStatelessRuleGroupReferenceArrayInput interface {
	pulumi.Input

	ToFirewallPolicyStatelessRuleGroupReferenceArrayOutput() FirewallPolicyStatelessRuleGroupReferenceArrayOutput
	ToFirewallPolicyStatelessRuleGroupReferenceArrayOutputWithContext(context.Context) FirewallPolicyStatelessRuleGroupReferenceArrayOutput
}

FirewallPolicyStatelessRuleGroupReferenceArrayInput is an input type that accepts FirewallPolicyStatelessRuleGroupReferenceArray and FirewallPolicyStatelessRuleGroupReferenceArrayOutput values. You can construct a concrete instance of `FirewallPolicyStatelessRuleGroupReferenceArrayInput` via: 

FirewallPolicyStatelessRuleGroupReferenceArray{ FirewallPolicyStatelessRuleGroupReferenceArgs{...} }

type FirewallPolicyStatelessRuleGroupReferenceArrayOutput 

type FirewallPolicyStatelessRuleGroupReferenceArrayOutput struct{ *pulumi.OutputState }

func (FirewallPolicyStatelessRuleGroupReferenceArrayOutput) ElementType 

func (FirewallPolicyStatelessRuleGroupReferenceArrayOutput) ElementType() reflect.Type

func (FirewallPolicyStatelessRuleGroupReferenceArrayOutput) Index 

func (o FirewallPolicyStatelessRuleGroupReferenceArrayOutput) Index(i pulumi.IntInput) FirewallPolicyStatelessRuleGroupReferenceOutput

func (FirewallPolicyStatelessRuleGroupReferenceArrayOutput) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutput 

func (o FirewallPolicyStatelessRuleGroupReferenceArrayOutput) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutput() FirewallPolicyStatelessRuleGroupReferenceArrayOutput

func (FirewallPolicyStatelessRuleGroupReferenceArrayOutput) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutputWithContext 

func (o FirewallPolicyStatelessRuleGroupReferenceArrayOutput) ToFirewallPolicyStatelessRuleGroupReferenceArrayOutputWithContext(ctx context.Context) FirewallPolicyStatelessRuleGroupReferenceArrayOutput

type FirewallPolicyStatelessRuleGroupReferenceInput 

type FirewallPolicyStatelessRuleGroupReferenceInput interface {
	pulumi.Input

	ToFirewallPolicyStatelessRuleGroupReferenceOutput() FirewallPolicyStatelessRuleGroupReferenceOutput
	ToFirewallPolicyStatelessRuleGroupReferenceOutputWithContext(context.Context) FirewallPolicyStatelessRuleGroupReferenceOutput
}

FirewallPolicyStatelessRuleGroupReferenceInput is an input type that accepts FirewallPolicyStatelessRuleGroupReferenceArgs and FirewallPolicyStatelessRuleGroupReferenceOutput values. You can construct a concrete instance of `FirewallPolicyStatelessRuleGroupReferenceInput` via: 

FirewallPolicyStatelessRuleGroupReferenceArgs{...}

type FirewallPolicyStatelessRuleGroupReferenceOutput 

type FirewallPolicyStatelessRuleGroupReferenceOutput struct{ *pulumi.OutputState }

func (FirewallPolicyStatelessRuleGroupReferenceOutput) ElementType 

func (FirewallPolicyStatelessRuleGroupReferenceOutput) ElementType() reflect.Type

func (FirewallPolicyStatelessRuleGroupReferenceOutput) Priority 

func (o FirewallPolicyStatelessRuleGroupReferenceOutput) Priority() pulumi.IntOutput

func (FirewallPolicyStatelessRuleGroupReferenceOutput) ResourceArn 

func (o FirewallPolicyStatelessRuleGroupReferenceOutput) ResourceArn() pulumi.StringOutput

func (FirewallPolicyStatelessRuleGroupReferenceOutput) ToFirewallPolicyStatelessRuleGroupReferenceOutput 

func (o FirewallPolicyStatelessRuleGroupReferenceOutput) ToFirewallPolicyStatelessRuleGroupReferenceOutput() FirewallPolicyStatelessRuleGroupReferenceOutput

func (FirewallPolicyStatelessRuleGroupReferenceOutput) ToFirewallPolicyStatelessRuleGroupReferenceOutputWithContext 

func (o FirewallPolicyStatelessRuleGroupReferenceOutput) ToFirewallPolicyStatelessRuleGroupReferenceOutputWithContext(ctx context.Context) FirewallPolicyStatelessRuleGroupReferenceOutput

type FirewallPolicyTag 

type FirewallPolicyTag struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type FirewallPolicyTagArgs 

type FirewallPolicyTagArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (FirewallPolicyTagArgs) ElementType 

func (FirewallPolicyTagArgs) ElementType() reflect.Type

func (FirewallPolicyTagArgs) ToFirewallPolicyTagOutput 

func (i FirewallPolicyTagArgs) ToFirewallPolicyTagOutput() FirewallPolicyTagOutput

func (FirewallPolicyTagArgs) ToFirewallPolicyTagOutputWithContext 

func (i FirewallPolicyTagArgs) ToFirewallPolicyTagOutputWithContext(ctx context.Context) FirewallPolicyTagOutput

type FirewallPolicyTagArray 

type FirewallPolicyTagArray []FirewallPolicyTagInput

func (FirewallPolicyTagArray) ElementType 

func (FirewallPolicyTagArray) ElementType() reflect.Type

func (FirewallPolicyTagArray) ToFirewallPolicyTagArrayOutput 

func (i FirewallPolicyTagArray) ToFirewallPolicyTagArrayOutput() FirewallPolicyTagArrayOutput

func (FirewallPolicyTagArray) ToFirewallPolicyTagArrayOutputWithContext 

func (i FirewallPolicyTagArray) ToFirewallPolicyTagArrayOutputWithContext(ctx context.Context) FirewallPolicyTagArrayOutput

type FirewallPolicyTagArrayInput 

type FirewallPolicyTagArrayInput interface {
	pulumi.Input

	ToFirewallPolicyTagArrayOutput() FirewallPolicyTagArrayOutput
	ToFirewallPolicyTagArrayOutputWithContext(context.Context) FirewallPolicyTagArrayOutput
}

FirewallPolicyTagArrayInput is an input type that accepts FirewallPolicyTagArray and FirewallPolicyTagArrayOutput values. You can construct a concrete instance of `FirewallPolicyTagArrayInput` via: 

FirewallPolicyTagArray{ FirewallPolicyTagArgs{...} }

type FirewallPolicyTagArrayOutput 

type FirewallPolicyTagArrayOutput struct{ *pulumi.OutputState }

func (FirewallPolicyTagArrayOutput) ElementType 

func (FirewallPolicyTagArrayOutput) ElementType() reflect.Type

func (FirewallPolicyTagArrayOutput) Index 

func (o FirewallPolicyTagArrayOutput) Index(i pulumi.IntInput) FirewallPolicyTagOutput

func (FirewallPolicyTagArrayOutput) ToFirewallPolicyTagArrayOutput 

func (o FirewallPolicyTagArrayOutput) ToFirewallPolicyTagArrayOutput() FirewallPolicyTagArrayOutput

func (FirewallPolicyTagArrayOutput) ToFirewallPolicyTagArrayOutputWithContext 

func (o FirewallPolicyTagArrayOutput) ToFirewallPolicyTagArrayOutputWithContext(ctx context.Context) FirewallPolicyTagArrayOutput

type FirewallPolicyTagInput 

type FirewallPolicyTagInput interface {
	pulumi.Input

	ToFirewallPolicyTagOutput() FirewallPolicyTagOutput
	ToFirewallPolicyTagOutputWithContext(context.Context) FirewallPolicyTagOutput
}

FirewallPolicyTagInput is an input type that accepts FirewallPolicyTagArgs and FirewallPolicyTagOutput values. You can construct a concrete instance of `FirewallPolicyTagInput` via: 

FirewallPolicyTagArgs{...}

type FirewallPolicyTagOutput 

type FirewallPolicyTagOutput struct{ *pulumi.OutputState }

func (FirewallPolicyTagOutput) ElementType 

func (FirewallPolicyTagOutput) ElementType() reflect.Type

func (FirewallPolicyTagOutput) Key 

func (o FirewallPolicyTagOutput) Key() pulumi.StringOutput

func (FirewallPolicyTagOutput) ToFirewallPolicyTagOutput 

func (o FirewallPolicyTagOutput) ToFirewallPolicyTagOutput() FirewallPolicyTagOutput

func (FirewallPolicyTagOutput) ToFirewallPolicyTagOutputWithContext 

func (o FirewallPolicyTagOutput) ToFirewallPolicyTagOutputWithContext(ctx context.Context) FirewallPolicyTagOutput

func (FirewallPolicyTagOutput) Value 

func (o FirewallPolicyTagOutput) Value() pulumi.StringOutput

type FirewallPolicyType added in v0.2.0 

type FirewallPolicyType struct {
	StatefulDefaultActions          []string                                    `pulumi:"statefulDefaultActions"`
	StatefulEngineOptions           *FirewallPolicyStatefulEngineOptions        `pulumi:"statefulEngineOptions"`
	StatefulRuleGroupReferences     []FirewallPolicyStatefulRuleGroupReference  `pulumi:"statefulRuleGroupReferences"`
	StatelessCustomActions          []FirewallPolicyCustomAction                `pulumi:"statelessCustomActions"`
	StatelessDefaultActions         []string                                    `pulumi:"statelessDefaultActions"`
	StatelessFragmentDefaultActions []string                                    `pulumi:"statelessFragmentDefaultActions"`
	StatelessRuleGroupReferences    []FirewallPolicyStatelessRuleGroupReference `pulumi:"statelessRuleGroupReferences"`
}

type FirewallPolicyTypeArgs added in v0.2.0 

type FirewallPolicyTypeArgs struct {
	StatefulDefaultActions          pulumi.StringArrayInput                             `pulumi:"statefulDefaultActions"`
	StatefulEngineOptions           FirewallPolicyStatefulEngineOptionsPtrInput         `pulumi:"statefulEngineOptions"`
	StatefulRuleGroupReferences     FirewallPolicyStatefulRuleGroupReferenceArrayInput  `pulumi:"statefulRuleGroupReferences"`
	StatelessCustomActions          FirewallPolicyCustomActionArrayInput                `pulumi:"statelessCustomActions"`
	StatelessDefaultActions         pulumi.StringArrayInput                             `pulumi:"statelessDefaultActions"`
	StatelessFragmentDefaultActions pulumi.StringArrayInput                             `pulumi:"statelessFragmentDefaultActions"`
	StatelessRuleGroupReferences    FirewallPolicyStatelessRuleGroupReferenceArrayInput `pulumi:"statelessRuleGroupReferences"`
}

func (FirewallPolicyTypeArgs) ElementType added in v0.2.0 

func (FirewallPolicyTypeArgs) ElementType() reflect.Type

func (FirewallPolicyTypeArgs) ToFirewallPolicyTypeOutput added in v0.2.0 

func (i FirewallPolicyTypeArgs) ToFirewallPolicyTypeOutput() FirewallPolicyTypeOutput

func (FirewallPolicyTypeArgs) ToFirewallPolicyTypeOutputWithContext added in v0.2.0 

func (i FirewallPolicyTypeArgs) ToFirewallPolicyTypeOutputWithContext(ctx context.Context) FirewallPolicyTypeOutput

func (FirewallPolicyTypeArgs) ToFirewallPolicyTypePtrOutput added in v0.2.0 

func (i FirewallPolicyTypeArgs) ToFirewallPolicyTypePtrOutput() FirewallPolicyTypePtrOutput

func (FirewallPolicyTypeArgs) ToFirewallPolicyTypePtrOutputWithContext added in v0.2.0 

func (i FirewallPolicyTypeArgs) ToFirewallPolicyTypePtrOutputWithContext(ctx context.Context) FirewallPolicyTypePtrOutput

type FirewallPolicyTypeInput added in v0.2.0 

type FirewallPolicyTypeInput interface {
	pulumi.Input

	ToFirewallPolicyTypeOutput() FirewallPolicyTypeOutput
	ToFirewallPolicyTypeOutputWithContext(context.Context) FirewallPolicyTypeOutput
}

FirewallPolicyTypeInput is an input type that accepts FirewallPolicyTypeArgs and FirewallPolicyTypeOutput values. You can construct a concrete instance of `FirewallPolicyTypeInput` via: 

FirewallPolicyTypeArgs{...}

type FirewallPolicyTypeOutput added in v0.2.0 

type FirewallPolicyTypeOutput struct{ *pulumi.OutputState }

func (FirewallPolicyTypeOutput) ElementType added in v0.2.0 

func (FirewallPolicyTypeOutput) ElementType() reflect.Type

func (FirewallPolicyTypeOutput) StatefulDefaultActions added in v0.3.0 

func (o FirewallPolicyTypeOutput) StatefulDefaultActions() pulumi.StringArrayOutput

func (FirewallPolicyTypeOutput) StatefulEngineOptions added in v0.3.0 

func (o FirewallPolicyTypeOutput) StatefulEngineOptions() FirewallPolicyStatefulEngineOptionsPtrOutput

func (FirewallPolicyTypeOutput) StatefulRuleGroupReferences added in v0.2.0 

func (o FirewallPolicyTypeOutput) StatefulRuleGroupReferences() FirewallPolicyStatefulRuleGroupReferenceArrayOutput

func (FirewallPolicyTypeOutput) StatelessCustomActions added in v0.2.0 

func (o FirewallPolicyTypeOutput) StatelessCustomActions() FirewallPolicyCustomActionArrayOutput

func (FirewallPolicyTypeOutput) StatelessDefaultActions added in v0.2.0 

func (o FirewallPolicyTypeOutput) StatelessDefaultActions() pulumi.StringArrayOutput

func (FirewallPolicyTypeOutput) StatelessFragmentDefaultActions added in v0.2.0 

func (o FirewallPolicyTypeOutput) StatelessFragmentDefaultActions() pulumi.StringArrayOutput

func (FirewallPolicyTypeOutput) StatelessRuleGroupReferences added in v0.2.0 

func (o FirewallPolicyTypeOutput) StatelessRuleGroupReferences() FirewallPolicyStatelessRuleGroupReferenceArrayOutput

func (FirewallPolicyTypeOutput) ToFirewallPolicyTypeOutput added in v0.2.0 

func (o FirewallPolicyTypeOutput) ToFirewallPolicyTypeOutput() FirewallPolicyTypeOutput

func (FirewallPolicyTypeOutput) ToFirewallPolicyTypeOutputWithContext added in v0.2.0 

func (o FirewallPolicyTypeOutput) ToFirewallPolicyTypeOutputWithContext(ctx context.Context) FirewallPolicyTypeOutput

func (FirewallPolicyTypeOutput) ToFirewallPolicyTypePtrOutput added in v0.2.0 

func (o FirewallPolicyTypeOutput) ToFirewallPolicyTypePtrOutput() FirewallPolicyTypePtrOutput

func (FirewallPolicyTypeOutput) ToFirewallPolicyTypePtrOutputWithContext added in v0.2.0 

func (o FirewallPolicyTypeOutput) ToFirewallPolicyTypePtrOutputWithContext(ctx context.Context) FirewallPolicyTypePtrOutput

type FirewallPolicyTypePtrInput added in v0.2.0 

type FirewallPolicyTypePtrInput interface {
	pulumi.Input

	ToFirewallPolicyTypePtrOutput() FirewallPolicyTypePtrOutput
	ToFirewallPolicyTypePtrOutputWithContext(context.Context) FirewallPolicyTypePtrOutput
}

FirewallPolicyTypePtrInput is an input type that accepts FirewallPolicyTypeArgs, FirewallPolicyTypePtr and FirewallPolicyTypePtrOutput values. You can construct a concrete instance of `FirewallPolicyTypePtrInput` via: 

        FirewallPolicyTypeArgs{...}

or:

        nil

func FirewallPolicyTypePtr added in v0.2.0 

func FirewallPolicyTypePtr(v *FirewallPolicyTypeArgs) FirewallPolicyTypePtrInput

type FirewallPolicyTypePtrOutput added in v0.2.0 

type FirewallPolicyTypePtrOutput struct{ *pulumi.OutputState }

func (FirewallPolicyTypePtrOutput) Elem added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) Elem() FirewallPolicyTypeOutput

func (FirewallPolicyTypePtrOutput) ElementType added in v0.2.0 

func (FirewallPolicyTypePtrOutput) ElementType() reflect.Type

func (FirewallPolicyTypePtrOutput) StatefulDefaultActions added in v0.3.0 

func (o FirewallPolicyTypePtrOutput) StatefulDefaultActions() pulumi.StringArrayOutput

func (FirewallPolicyTypePtrOutput) StatefulEngineOptions added in v0.3.0 

func (o FirewallPolicyTypePtrOutput) StatefulEngineOptions() FirewallPolicyStatefulEngineOptionsPtrOutput

func (FirewallPolicyTypePtrOutput) StatefulRuleGroupReferences added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) StatefulRuleGroupReferences() FirewallPolicyStatefulRuleGroupReferenceArrayOutput

func (FirewallPolicyTypePtrOutput) StatelessCustomActions added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) StatelessCustomActions() FirewallPolicyCustomActionArrayOutput

func (FirewallPolicyTypePtrOutput) StatelessDefaultActions added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) StatelessDefaultActions() pulumi.StringArrayOutput

func (FirewallPolicyTypePtrOutput) StatelessFragmentDefaultActions added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) StatelessFragmentDefaultActions() pulumi.StringArrayOutput

func (FirewallPolicyTypePtrOutput) StatelessRuleGroupReferences added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) StatelessRuleGroupReferences() FirewallPolicyStatelessRuleGroupReferenceArrayOutput

func (FirewallPolicyTypePtrOutput) ToFirewallPolicyTypePtrOutput added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) ToFirewallPolicyTypePtrOutput() FirewallPolicyTypePtrOutput

func (FirewallPolicyTypePtrOutput) ToFirewallPolicyTypePtrOutputWithContext added in v0.2.0 

func (o FirewallPolicyTypePtrOutput) ToFirewallPolicyTypePtrOutputWithContext(ctx context.Context) FirewallPolicyTypePtrOutput

type FirewallState 

type FirewallState struct {
}

func (FirewallState) ElementType 

func (FirewallState) ElementType() reflect.Type

type FirewallSubnetMapping 

type FirewallSubnetMapping struct {
	// A SubnetId.
	SubnetId string `pulumi:"subnetId"`
}

type FirewallSubnetMappingArgs 

type FirewallSubnetMappingArgs struct {
	// A SubnetId.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (FirewallSubnetMappingArgs) ElementType 

func (FirewallSubnetMappingArgs) ElementType() reflect.Type

func (FirewallSubnetMappingArgs) ToFirewallSubnetMappingOutput 

func (i FirewallSubnetMappingArgs) ToFirewallSubnetMappingOutput() FirewallSubnetMappingOutput

func (FirewallSubnetMappingArgs) ToFirewallSubnetMappingOutputWithContext 

func (i FirewallSubnetMappingArgs) ToFirewallSubnetMappingOutputWithContext(ctx context.Context) FirewallSubnetMappingOutput

type FirewallSubnetMappingArray 

type FirewallSubnetMappingArray []FirewallSubnetMappingInput

func (FirewallSubnetMappingArray) ElementType 

func (FirewallSubnetMappingArray) ElementType() reflect.Type

func (FirewallSubnetMappingArray) ToFirewallSubnetMappingArrayOutput 

func (i FirewallSubnetMappingArray) ToFirewallSubnetMappingArrayOutput() FirewallSubnetMappingArrayOutput

func (FirewallSubnetMappingArray) ToFirewallSubnetMappingArrayOutputWithContext 

func (i FirewallSubnetMappingArray) ToFirewallSubnetMappingArrayOutputWithContext(ctx context.Context) FirewallSubnetMappingArrayOutput

type FirewallSubnetMappingArrayInput 

type FirewallSubnetMappingArrayInput interface {
	pulumi.Input

	ToFirewallSubnetMappingArrayOutput() FirewallSubnetMappingArrayOutput
	ToFirewallSubnetMappingArrayOutputWithContext(context.Context) FirewallSubnetMappingArrayOutput
}

FirewallSubnetMappingArrayInput is an input type that accepts FirewallSubnetMappingArray and FirewallSubnetMappingArrayOutput values. You can construct a concrete instance of `FirewallSubnetMappingArrayInput` via: 

FirewallSubnetMappingArray{ FirewallSubnetMappingArgs{...} }

type FirewallSubnetMappingArrayOutput 

type FirewallSubnetMappingArrayOutput struct{ *pulumi.OutputState }

func (FirewallSubnetMappingArrayOutput) ElementType 

func (FirewallSubnetMappingArrayOutput) ElementType() reflect.Type

func (FirewallSubnetMappingArrayOutput) Index 

func (o FirewallSubnetMappingArrayOutput) Index(i pulumi.IntInput) FirewallSubnetMappingOutput

func (FirewallSubnetMappingArrayOutput) ToFirewallSubnetMappingArrayOutput 

func (o FirewallSubnetMappingArrayOutput) ToFirewallSubnetMappingArrayOutput() FirewallSubnetMappingArrayOutput

func (FirewallSubnetMappingArrayOutput) ToFirewallSubnetMappingArrayOutputWithContext 

func (o FirewallSubnetMappingArrayOutput) ToFirewallSubnetMappingArrayOutputWithContext(ctx context.Context) FirewallSubnetMappingArrayOutput

type FirewallSubnetMappingInput 

type FirewallSubnetMappingInput interface {
	pulumi.Input

	ToFirewallSubnetMappingOutput() FirewallSubnetMappingOutput
	ToFirewallSubnetMappingOutputWithContext(context.Context) FirewallSubnetMappingOutput
}

FirewallSubnetMappingInput is an input type that accepts FirewallSubnetMappingArgs and FirewallSubnetMappingOutput values. You can construct a concrete instance of `FirewallSubnetMappingInput` via: 

FirewallSubnetMappingArgs{...}

type FirewallSubnetMappingOutput 

type FirewallSubnetMappingOutput struct{ *pulumi.OutputState }

func (FirewallSubnetMappingOutput) ElementType 

func (FirewallSubnetMappingOutput) ElementType() reflect.Type

func (FirewallSubnetMappingOutput) SubnetId 

func (o FirewallSubnetMappingOutput) SubnetId() pulumi.StringOutput

A SubnetId.

func (FirewallSubnetMappingOutput) ToFirewallSubnetMappingOutput 

func (o FirewallSubnetMappingOutput) ToFirewallSubnetMappingOutput() FirewallSubnetMappingOutput

func (FirewallSubnetMappingOutput) ToFirewallSubnetMappingOutputWithContext 

func (o FirewallSubnetMappingOutput) ToFirewallSubnetMappingOutputWithContext(ctx context.Context) FirewallSubnetMappingOutput

type FirewallTag 

type FirewallTag struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type FirewallTagArgs 

type FirewallTagArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (FirewallTagArgs) ElementType 

func (FirewallTagArgs) ElementType() reflect.Type

func (FirewallTagArgs) ToFirewallTagOutput 

func (i FirewallTagArgs) ToFirewallTagOutput() FirewallTagOutput

func (FirewallTagArgs) ToFirewallTagOutputWithContext 

func (i FirewallTagArgs) ToFirewallTagOutputWithContext(ctx context.Context) FirewallTagOutput

type FirewallTagArray 

type FirewallTagArray []FirewallTagInput

func (FirewallTagArray) ElementType 

func (FirewallTagArray) ElementType() reflect.Type

func (FirewallTagArray) ToFirewallTagArrayOutput 

func (i FirewallTagArray) ToFirewallTagArrayOutput() FirewallTagArrayOutput

func (FirewallTagArray) ToFirewallTagArrayOutputWithContext 

func (i FirewallTagArray) ToFirewallTagArrayOutputWithContext(ctx context.Context) FirewallTagArrayOutput

type FirewallTagArrayInput 

type FirewallTagArrayInput interface {
	pulumi.Input

	ToFirewallTagArrayOutput() FirewallTagArrayOutput
	ToFirewallTagArrayOutputWithContext(context.Context) FirewallTagArrayOutput
}

FirewallTagArrayInput is an input type that accepts FirewallTagArray and FirewallTagArrayOutput values. You can construct a concrete instance of `FirewallTagArrayInput` via: 

FirewallTagArray{ FirewallTagArgs{...} }

type FirewallTagArrayOutput 

type FirewallTagArrayOutput struct{ *pulumi.OutputState }

func (FirewallTagArrayOutput) ElementType 

func (FirewallTagArrayOutput) ElementType() reflect.Type

func (FirewallTagArrayOutput) Index 

func (o FirewallTagArrayOutput) Index(i pulumi.IntInput) FirewallTagOutput

func (FirewallTagArrayOutput) ToFirewallTagArrayOutput 

func (o FirewallTagArrayOutput) ToFirewallTagArrayOutput() FirewallTagArrayOutput

func (FirewallTagArrayOutput) ToFirewallTagArrayOutputWithContext 

func (o FirewallTagArrayOutput) ToFirewallTagArrayOutputWithContext(ctx context.Context) FirewallTagArrayOutput

type FirewallTagInput 

type FirewallTagInput interface {
	pulumi.Input

	ToFirewallTagOutput() FirewallTagOutput
	ToFirewallTagOutputWithContext(context.Context) FirewallTagOutput
}

FirewallTagInput is an input type that accepts FirewallTagArgs and FirewallTagOutput values. You can construct a concrete instance of `FirewallTagInput` via: 

FirewallTagArgs{...}

type FirewallTagOutput 

type FirewallTagOutput struct{ *pulumi.OutputState }

func (FirewallTagOutput) ElementType 

func (FirewallTagOutput) ElementType() reflect.Type

func (FirewallTagOutput) Key 

func (o FirewallTagOutput) Key() pulumi.StringOutput

func (FirewallTagOutput) ToFirewallTagOutput 

func (o FirewallTagOutput) ToFirewallTagOutput() FirewallTagOutput

func (FirewallTagOutput) ToFirewallTagOutputWithContext 

func (o FirewallTagOutput) ToFirewallTagOutputWithContext(ctx context.Context) FirewallTagOutput

func (FirewallTagOutput) Value 

func (o FirewallTagOutput) Value() pulumi.StringOutput

type LoggingConfiguration 

type LoggingConfiguration struct {
	pulumi.CustomResourceState

	FirewallArn          pulumi.StringOutput            `pulumi:"firewallArn"`
	FirewallName         pulumi.StringPtrOutput         `pulumi:"firewallName"`
	LoggingConfiguration LoggingConfigurationTypeOutput `pulumi:"loggingConfiguration"`
}

Resource type definition for AWS::NetworkFirewall::LoggingConfiguration

func GetLoggingConfiguration 

func GetLoggingConfiguration(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LoggingConfigurationState, opts ...pulumi.ResourceOption) (*LoggingConfiguration, error)

GetLoggingConfiguration gets an existing LoggingConfiguration resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewLoggingConfiguration 

func NewLoggingConfiguration(ctx *pulumi.Context,
	name string, args *LoggingConfigurationArgs, opts ...pulumi.ResourceOption) (*LoggingConfiguration, error)

NewLoggingConfiguration registers a new resource with the given unique name, arguments, and options.

func (*LoggingConfiguration) ElementType 

func (*LoggingConfiguration) ElementType() reflect.Type

func (*LoggingConfiguration) ToLoggingConfigurationOutput 

func (i *LoggingConfiguration) ToLoggingConfigurationOutput() LoggingConfigurationOutput

func (*LoggingConfiguration) ToLoggingConfigurationOutputWithContext 

func (i *LoggingConfiguration) ToLoggingConfigurationOutputWithContext(ctx context.Context) LoggingConfigurationOutput

type LoggingConfigurationArgs 

type LoggingConfigurationArgs struct {
	FirewallArn          pulumi.StringInput
	FirewallName         pulumi.StringPtrInput
	LoggingConfiguration LoggingConfigurationTypeInput
}

The set of arguments for constructing a LoggingConfiguration resource.

func (LoggingConfigurationArgs) ElementType 

func (LoggingConfigurationArgs) ElementType() reflect.Type

type LoggingConfigurationInput 

type LoggingConfigurationInput interface {
	pulumi.Input

	ToLoggingConfigurationOutput() LoggingConfigurationOutput
	ToLoggingConfigurationOutputWithContext(ctx context.Context) LoggingConfigurationOutput
}

type LoggingConfigurationLogDestinationConfig 

type LoggingConfigurationLogDestinationConfig struct {
	// A key-value pair to configure the logDestinations.
	LogDestination     interface{}                                                `pulumi:"logDestination"`
	LogDestinationType LoggingConfigurationLogDestinationConfigLogDestinationType `pulumi:"logDestinationType"`
	LogType            LoggingConfigurationLogDestinationConfigLogType            `pulumi:"logType"`
}

type LoggingConfigurationLogDestinationConfigArgs 

type LoggingConfigurationLogDestinationConfigArgs struct {
	// A key-value pair to configure the logDestinations.
	LogDestination     pulumi.Input                                                    `pulumi:"logDestination"`
	LogDestinationType LoggingConfigurationLogDestinationConfigLogDestinationTypeInput `pulumi:"logDestinationType"`
	LogType            LoggingConfigurationLogDestinationConfigLogTypeInput            `pulumi:"logType"`
}

func (LoggingConfigurationLogDestinationConfigArgs) ElementType 

func (LoggingConfigurationLogDestinationConfigArgs) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigArgs) ToLoggingConfigurationLogDestinationConfigOutput 

func (i LoggingConfigurationLogDestinationConfigArgs) ToLoggingConfigurationLogDestinationConfigOutput() LoggingConfigurationLogDestinationConfigOutput

func (LoggingConfigurationLogDestinationConfigArgs) ToLoggingConfigurationLogDestinationConfigOutputWithContext 

func (i LoggingConfigurationLogDestinationConfigArgs) ToLoggingConfigurationLogDestinationConfigOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigOutput

type LoggingConfigurationLogDestinationConfigArray 

type LoggingConfigurationLogDestinationConfigArray []LoggingConfigurationLogDestinationConfigInput

func (LoggingConfigurationLogDestinationConfigArray) ElementType 

func (LoggingConfigurationLogDestinationConfigArray) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigArray) ToLoggingConfigurationLogDestinationConfigArrayOutput 

func (i LoggingConfigurationLogDestinationConfigArray) ToLoggingConfigurationLogDestinationConfigArrayOutput() LoggingConfigurationLogDestinationConfigArrayOutput

func (LoggingConfigurationLogDestinationConfigArray) ToLoggingConfigurationLogDestinationConfigArrayOutputWithContext 

func (i LoggingConfigurationLogDestinationConfigArray) ToLoggingConfigurationLogDestinationConfigArrayOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigArrayOutput

type LoggingConfigurationLogDestinationConfigArrayInput 

type LoggingConfigurationLogDestinationConfigArrayInput interface {
	pulumi.Input

	ToLoggingConfigurationLogDestinationConfigArrayOutput() LoggingConfigurationLogDestinationConfigArrayOutput
	ToLoggingConfigurationLogDestinationConfigArrayOutputWithContext(context.Context) LoggingConfigurationLogDestinationConfigArrayOutput
}

LoggingConfigurationLogDestinationConfigArrayInput is an input type that accepts LoggingConfigurationLogDestinationConfigArray and LoggingConfigurationLogDestinationConfigArrayOutput values. You can construct a concrete instance of `LoggingConfigurationLogDestinationConfigArrayInput` via: 

LoggingConfigurationLogDestinationConfigArray{ LoggingConfigurationLogDestinationConfigArgs{...} }

type LoggingConfigurationLogDestinationConfigArrayOutput 

type LoggingConfigurationLogDestinationConfigArrayOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationLogDestinationConfigArrayOutput) ElementType 

func (LoggingConfigurationLogDestinationConfigArrayOutput) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigArrayOutput) Index 

func (o LoggingConfigurationLogDestinationConfigArrayOutput) Index(i pulumi.IntInput) LoggingConfigurationLogDestinationConfigOutput

func (LoggingConfigurationLogDestinationConfigArrayOutput) ToLoggingConfigurationLogDestinationConfigArrayOutput 

func (o LoggingConfigurationLogDestinationConfigArrayOutput) ToLoggingConfigurationLogDestinationConfigArrayOutput() LoggingConfigurationLogDestinationConfigArrayOutput

func (LoggingConfigurationLogDestinationConfigArrayOutput) ToLoggingConfigurationLogDestinationConfigArrayOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigArrayOutput) ToLoggingConfigurationLogDestinationConfigArrayOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigArrayOutput

type LoggingConfigurationLogDestinationConfigInput 

type LoggingConfigurationLogDestinationConfigInput interface {
	pulumi.Input

	ToLoggingConfigurationLogDestinationConfigOutput() LoggingConfigurationLogDestinationConfigOutput
	ToLoggingConfigurationLogDestinationConfigOutputWithContext(context.Context) LoggingConfigurationLogDestinationConfigOutput
}

LoggingConfigurationLogDestinationConfigInput is an input type that accepts LoggingConfigurationLogDestinationConfigArgs and LoggingConfigurationLogDestinationConfigOutput values. You can construct a concrete instance of `LoggingConfigurationLogDestinationConfigInput` via: 

LoggingConfigurationLogDestinationConfigArgs{...}

type LoggingConfigurationLogDestinationConfigLogDestinationType 

type LoggingConfigurationLogDestinationConfigLogDestinationType string

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ElementType 

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutput 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringOutput 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringOutput() pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringPtrOutput 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringPtrOutput() pulumi.StringPtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringPtrOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogDestinationType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type LoggingConfigurationLogDestinationConfigLogDestinationTypeInput 

type LoggingConfigurationLogDestinationConfigLogDestinationTypeInput interface {
	pulumi.Input

	ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput
	ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutputWithContext(context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput
}

LoggingConfigurationLogDestinationConfigLogDestinationTypeInput is an input type that accepts LoggingConfigurationLogDestinationConfigLogDestinationTypeArgs and LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput values. You can construct a concrete instance of `LoggingConfigurationLogDestinationConfigLogDestinationTypeInput` via: 

LoggingConfigurationLogDestinationConfigLogDestinationTypeArgs{...}

type LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput 

type LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ElementType 

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutput 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypeOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringOutput 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringOutput() pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringPtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringPtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type LoggingConfigurationLogDestinationConfigLogDestinationTypePtrInput 

type LoggingConfigurationLogDestinationConfigLogDestinationTypePtrInput interface {
	pulumi.Input

	ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput
	ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext(context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput
}

func LoggingConfigurationLogDestinationConfigLogDestinationTypePtr 

func LoggingConfigurationLogDestinationConfigLogDestinationTypePtr(v string) LoggingConfigurationLogDestinationConfigLogDestinationTypePtrInput

type LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput 

type LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) Elem 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) Elem() LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ElementType 

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput() LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToStringPtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToStringPtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogDestinationTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type LoggingConfigurationLogDestinationConfigLogType 

type LoggingConfigurationLogDestinationConfigLogType string

func (LoggingConfigurationLogDestinationConfigLogType) ElementType 

func (LoggingConfigurationLogDestinationConfigLogType) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypeOutput 

func (e LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypeOutput() LoggingConfigurationLogDestinationConfigLogTypeOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypeOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypeOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogTypeOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput 

func (e LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput() LoggingConfigurationLogDestinationConfigLogTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogType) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToStringOutput 

func (e LoggingConfigurationLogDestinationConfigLogType) ToStringOutput() pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToStringOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToStringPtrOutput 

func (e LoggingConfigurationLogDestinationConfigLogType) ToStringPtrOutput() pulumi.StringPtrOutput

func (LoggingConfigurationLogDestinationConfigLogType) ToStringPtrOutputWithContext 

func (e LoggingConfigurationLogDestinationConfigLogType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type LoggingConfigurationLogDestinationConfigLogTypeInput 

type LoggingConfigurationLogDestinationConfigLogTypeInput interface {
	pulumi.Input

	ToLoggingConfigurationLogDestinationConfigLogTypeOutput() LoggingConfigurationLogDestinationConfigLogTypeOutput
	ToLoggingConfigurationLogDestinationConfigLogTypeOutputWithContext(context.Context) LoggingConfigurationLogDestinationConfigLogTypeOutput
}

LoggingConfigurationLogDestinationConfigLogTypeInput is an input type that accepts LoggingConfigurationLogDestinationConfigLogTypeArgs and LoggingConfigurationLogDestinationConfigLogTypeOutput values. You can construct a concrete instance of `LoggingConfigurationLogDestinationConfigLogTypeInput` via: 

LoggingConfigurationLogDestinationConfigLogTypeArgs{...}

type LoggingConfigurationLogDestinationConfigLogTypeOutput 

type LoggingConfigurationLogDestinationConfigLogTypeOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ElementType 

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypeOutput 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypeOutput() LoggingConfigurationLogDestinationConfigLogTypeOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypeOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypeOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogTypeOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput() LoggingConfigurationLogDestinationConfigLogTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringOutput 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringOutput() pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringPtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringPtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type LoggingConfigurationLogDestinationConfigLogTypePtrInput 

type LoggingConfigurationLogDestinationConfigLogTypePtrInput interface {
	pulumi.Input

	ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput() LoggingConfigurationLogDestinationConfigLogTypePtrOutput
	ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext(context.Context) LoggingConfigurationLogDestinationConfigLogTypePtrOutput
}

func LoggingConfigurationLogDestinationConfigLogTypePtr 

func LoggingConfigurationLogDestinationConfigLogTypePtr(v string) LoggingConfigurationLogDestinationConfigLogTypePtrInput

type LoggingConfigurationLogDestinationConfigLogTypePtrOutput 

type LoggingConfigurationLogDestinationConfigLogTypePtrOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) Elem 

func (o LoggingConfigurationLogDestinationConfigLogTypePtrOutput) Elem() LoggingConfigurationLogDestinationConfigLogTypeOutput

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ElementType 

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutput() LoggingConfigurationLogDestinationConfigLogTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToLoggingConfigurationLogDestinationConfigLogTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigLogTypePtrOutput

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToStringPtrOutput 

func (o LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToStringPtrOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigLogTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type LoggingConfigurationLogDestinationConfigOutput 

type LoggingConfigurationLogDestinationConfigOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationLogDestinationConfigOutput) ElementType 

func (LoggingConfigurationLogDestinationConfigOutput) ElementType() reflect.Type

func (LoggingConfigurationLogDestinationConfigOutput) LogDestination 

func (o LoggingConfigurationLogDestinationConfigOutput) LogDestination() pulumi.AnyOutput

A key-value pair to configure the logDestinations.

func (LoggingConfigurationLogDestinationConfigOutput) LogDestinationType 

func (o LoggingConfigurationLogDestinationConfigOutput) LogDestinationType() LoggingConfigurationLogDestinationConfigLogDestinationTypeOutput

func (LoggingConfigurationLogDestinationConfigOutput) LogType 

func (o LoggingConfigurationLogDestinationConfigOutput) LogType() LoggingConfigurationLogDestinationConfigLogTypeOutput

func (LoggingConfigurationLogDestinationConfigOutput) ToLoggingConfigurationLogDestinationConfigOutput 

func (o LoggingConfigurationLogDestinationConfigOutput) ToLoggingConfigurationLogDestinationConfigOutput() LoggingConfigurationLogDestinationConfigOutput

func (LoggingConfigurationLogDestinationConfigOutput) ToLoggingConfigurationLogDestinationConfigOutputWithContext 

func (o LoggingConfigurationLogDestinationConfigOutput) ToLoggingConfigurationLogDestinationConfigOutputWithContext(ctx context.Context) LoggingConfigurationLogDestinationConfigOutput

type LoggingConfigurationOutput 

type LoggingConfigurationOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationOutput) ElementType 

func (LoggingConfigurationOutput) ElementType() reflect.Type

func (LoggingConfigurationOutput) ToLoggingConfigurationOutput 

func (o LoggingConfigurationOutput) ToLoggingConfigurationOutput() LoggingConfigurationOutput

func (LoggingConfigurationOutput) ToLoggingConfigurationOutputWithContext 

func (o LoggingConfigurationOutput) ToLoggingConfigurationOutputWithContext(ctx context.Context) LoggingConfigurationOutput

type LoggingConfigurationState 

type LoggingConfigurationState struct {
}

func (LoggingConfigurationState) ElementType 

func (LoggingConfigurationState) ElementType() reflect.Type

type LoggingConfigurationType added in v0.2.0 

type LoggingConfigurationType struct {
	LogDestinationConfigs []LoggingConfigurationLogDestinationConfig `pulumi:"logDestinationConfigs"`
}

type LoggingConfigurationTypeArgs added in v0.2.0 

type LoggingConfigurationTypeArgs struct {
	LogDestinationConfigs LoggingConfigurationLogDestinationConfigArrayInput `pulumi:"logDestinationConfigs"`
}

func (LoggingConfigurationTypeArgs) ElementType added in v0.2.0 

func (LoggingConfigurationTypeArgs) ElementType() reflect.Type

func (LoggingConfigurationTypeArgs) ToLoggingConfigurationTypeOutput added in v0.2.0 

func (i LoggingConfigurationTypeArgs) ToLoggingConfigurationTypeOutput() LoggingConfigurationTypeOutput

func (LoggingConfigurationTypeArgs) ToLoggingConfigurationTypeOutputWithContext added in v0.2.0 

func (i LoggingConfigurationTypeArgs) ToLoggingConfigurationTypeOutputWithContext(ctx context.Context) LoggingConfigurationTypeOutput

func (LoggingConfigurationTypeArgs) ToLoggingConfigurationTypePtrOutput added in v0.2.0 

func (i LoggingConfigurationTypeArgs) ToLoggingConfigurationTypePtrOutput() LoggingConfigurationTypePtrOutput

func (LoggingConfigurationTypeArgs) ToLoggingConfigurationTypePtrOutputWithContext added in v0.2.0 

func (i LoggingConfigurationTypeArgs) ToLoggingConfigurationTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationTypePtrOutput

type LoggingConfigurationTypeInput added in v0.2.0 

type LoggingConfigurationTypeInput interface {
	pulumi.Input

	ToLoggingConfigurationTypeOutput() LoggingConfigurationTypeOutput
	ToLoggingConfigurationTypeOutputWithContext(context.Context) LoggingConfigurationTypeOutput
}

LoggingConfigurationTypeInput is an input type that accepts LoggingConfigurationTypeArgs and LoggingConfigurationTypeOutput values. You can construct a concrete instance of `LoggingConfigurationTypeInput` via: 

LoggingConfigurationTypeArgs{...}

type LoggingConfigurationTypeOutput added in v0.2.0 

type LoggingConfigurationTypeOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationTypeOutput) ElementType added in v0.2.0 

func (LoggingConfigurationTypeOutput) ElementType() reflect.Type

func (LoggingConfigurationTypeOutput) LogDestinationConfigs added in v0.2.0 

func (o LoggingConfigurationTypeOutput) LogDestinationConfigs() LoggingConfigurationLogDestinationConfigArrayOutput

func (LoggingConfigurationTypeOutput) ToLoggingConfigurationTypeOutput added in v0.2.0 

func (o LoggingConfigurationTypeOutput) ToLoggingConfigurationTypeOutput() LoggingConfigurationTypeOutput

func (LoggingConfigurationTypeOutput) ToLoggingConfigurationTypeOutputWithContext added in v0.2.0 

func (o LoggingConfigurationTypeOutput) ToLoggingConfigurationTypeOutputWithContext(ctx context.Context) LoggingConfigurationTypeOutput

func (LoggingConfigurationTypeOutput) ToLoggingConfigurationTypePtrOutput added in v0.2.0 

func (o LoggingConfigurationTypeOutput) ToLoggingConfigurationTypePtrOutput() LoggingConfigurationTypePtrOutput

func (LoggingConfigurationTypeOutput) ToLoggingConfigurationTypePtrOutputWithContext added in v0.2.0 

func (o LoggingConfigurationTypeOutput) ToLoggingConfigurationTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationTypePtrOutput

type LoggingConfigurationTypePtrInput added in v0.2.0 

type LoggingConfigurationTypePtrInput interface {
	pulumi.Input

	ToLoggingConfigurationTypePtrOutput() LoggingConfigurationTypePtrOutput
	ToLoggingConfigurationTypePtrOutputWithContext(context.Context) LoggingConfigurationTypePtrOutput
}

LoggingConfigurationTypePtrInput is an input type that accepts LoggingConfigurationTypeArgs, LoggingConfigurationTypePtr and LoggingConfigurationTypePtrOutput values. You can construct a concrete instance of `LoggingConfigurationTypePtrInput` via: 

        LoggingConfigurationTypeArgs{...}

or:

        nil

func LoggingConfigurationTypePtr added in v0.2.0 

func LoggingConfigurationTypePtr(v *LoggingConfigurationTypeArgs) LoggingConfigurationTypePtrInput

type LoggingConfigurationTypePtrOutput added in v0.2.0 

type LoggingConfigurationTypePtrOutput struct{ *pulumi.OutputState }

func (LoggingConfigurationTypePtrOutput) Elem added in v0.2.0 

func (o LoggingConfigurationTypePtrOutput) Elem() LoggingConfigurationTypeOutput

func (LoggingConfigurationTypePtrOutput) ElementType added in v0.2.0 

func (LoggingConfigurationTypePtrOutput) ElementType() reflect.Type

func (LoggingConfigurationTypePtrOutput) LogDestinationConfigs added in v0.2.0 

func (o LoggingConfigurationTypePtrOutput) LogDestinationConfigs() LoggingConfigurationLogDestinationConfigArrayOutput

func (LoggingConfigurationTypePtrOutput) ToLoggingConfigurationTypePtrOutput added in v0.2.0 

func (o LoggingConfigurationTypePtrOutput) ToLoggingConfigurationTypePtrOutput() LoggingConfigurationTypePtrOutput

func (LoggingConfigurationTypePtrOutput) ToLoggingConfigurationTypePtrOutputWithContext added in v0.2.0 

func (o LoggingConfigurationTypePtrOutput) ToLoggingConfigurationTypePtrOutputWithContext(ctx context.Context) LoggingConfigurationTypePtrOutput

type RuleGroup 

type RuleGroup struct {
	pulumi.CustomResourceState

	Capacity      pulumi.IntOutput        `pulumi:"capacity"`
	Description   pulumi.StringPtrOutput  `pulumi:"description"`
	RuleGroup     RuleGroupTypePtrOutput  `pulumi:"ruleGroup"`
	RuleGroupArn  pulumi.StringOutput     `pulumi:"ruleGroupArn"`
	RuleGroupId   pulumi.StringOutput     `pulumi:"ruleGroupId"`
	RuleGroupName pulumi.StringOutput     `pulumi:"ruleGroupName"`
	Tags          RuleGroupTagArrayOutput `pulumi:"tags"`
	Type          RuleGroupTypeEnumOutput `pulumi:"type"`
}

Resource type definition for AWS::NetworkFirewall::RuleGroup

func GetRuleGroup 

func GetRuleGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RuleGroupState, opts ...pulumi.ResourceOption) (*RuleGroup, error)

GetRuleGroup gets an existing RuleGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRuleGroup 

func NewRuleGroup(ctx *pulumi.Context,
	name string, args *RuleGroupArgs, opts ...pulumi.ResourceOption) (*RuleGroup, error)

NewRuleGroup registers a new resource with the given unique name, arguments, and options.

func (*RuleGroup) ElementType 

func (*RuleGroup) ElementType() reflect.Type

func (*RuleGroup) ToRuleGroupOutput 

func (i *RuleGroup) ToRuleGroupOutput() RuleGroupOutput

func (*RuleGroup) ToRuleGroupOutputWithContext 

func (i *RuleGroup) ToRuleGroupOutputWithContext(ctx context.Context) RuleGroupOutput

type RuleGroupActionDefinition 

type RuleGroupActionDefinition struct {
	PublishMetricAction *RuleGroupPublishMetricAction `pulumi:"publishMetricAction"`
}

type RuleGroupActionDefinitionArgs 

type RuleGroupActionDefinitionArgs struct {
	PublishMetricAction RuleGroupPublishMetricActionPtrInput `pulumi:"publishMetricAction"`
}

func (RuleGroupActionDefinitionArgs) ElementType 

func (RuleGroupActionDefinitionArgs) ElementType() reflect.Type

func (RuleGroupActionDefinitionArgs) ToRuleGroupActionDefinitionOutput 

func (i RuleGroupActionDefinitionArgs) ToRuleGroupActionDefinitionOutput() RuleGroupActionDefinitionOutput

func (RuleGroupActionDefinitionArgs) ToRuleGroupActionDefinitionOutputWithContext 

func (i RuleGroupActionDefinitionArgs) ToRuleGroupActionDefinitionOutputWithContext(ctx context.Context) RuleGroupActionDefinitionOutput

type RuleGroupActionDefinitionInput 

type RuleGroupActionDefinitionInput interface {
	pulumi.Input

	ToRuleGroupActionDefinitionOutput() RuleGroupActionDefinitionOutput
	ToRuleGroupActionDefinitionOutputWithContext(context.Context) RuleGroupActionDefinitionOutput
}

RuleGroupActionDefinitionInput is an input type that accepts RuleGroupActionDefinitionArgs and RuleGroupActionDefinitionOutput values. You can construct a concrete instance of `RuleGroupActionDefinitionInput` via: 

RuleGroupActionDefinitionArgs{...}

type RuleGroupActionDefinitionOutput 

type RuleGroupActionDefinitionOutput struct{ *pulumi.OutputState }

func (RuleGroupActionDefinitionOutput) ElementType 

func (RuleGroupActionDefinitionOutput) ElementType() reflect.Type

func (RuleGroupActionDefinitionOutput) PublishMetricAction 

func (o RuleGroupActionDefinitionOutput) PublishMetricAction() RuleGroupPublishMetricActionPtrOutput

func (RuleGroupActionDefinitionOutput) ToRuleGroupActionDefinitionOutput 

func (o RuleGroupActionDefinitionOutput) ToRuleGroupActionDefinitionOutput() RuleGroupActionDefinitionOutput

func (RuleGroupActionDefinitionOutput) ToRuleGroupActionDefinitionOutputWithContext 

func (o RuleGroupActionDefinitionOutput) ToRuleGroupActionDefinitionOutputWithContext(ctx context.Context) RuleGroupActionDefinitionOutput

type RuleGroupAddress 

type RuleGroupAddress struct {
	AddressDefinition string `pulumi:"addressDefinition"`
}

type RuleGroupAddressArgs 

type RuleGroupAddressArgs struct {
	AddressDefinition pulumi.StringInput `pulumi:"addressDefinition"`
}

func (RuleGroupAddressArgs) ElementType 

func (RuleGroupAddressArgs) ElementType() reflect.Type

func (RuleGroupAddressArgs) ToRuleGroupAddressOutput 

func (i RuleGroupAddressArgs) ToRuleGroupAddressOutput() RuleGroupAddressOutput

func (RuleGroupAddressArgs) ToRuleGroupAddressOutputWithContext 

func (i RuleGroupAddressArgs) ToRuleGroupAddressOutputWithContext(ctx context.Context) RuleGroupAddressOutput

type RuleGroupAddressArray 

type RuleGroupAddressArray []RuleGroupAddressInput

func (RuleGroupAddressArray) ElementType 

func (RuleGroupAddressArray) ElementType() reflect.Type

func (RuleGroupAddressArray) ToRuleGroupAddressArrayOutput 

func (i RuleGroupAddressArray) ToRuleGroupAddressArrayOutput() RuleGroupAddressArrayOutput

func (RuleGroupAddressArray) ToRuleGroupAddressArrayOutputWithContext 

func (i RuleGroupAddressArray) ToRuleGroupAddressArrayOutputWithContext(ctx context.Context) RuleGroupAddressArrayOutput

type RuleGroupAddressArrayInput 

type RuleGroupAddressArrayInput interface {
	pulumi.Input

	ToRuleGroupAddressArrayOutput() RuleGroupAddressArrayOutput
	ToRuleGroupAddressArrayOutputWithContext(context.Context) RuleGroupAddressArrayOutput
}

RuleGroupAddressArrayInput is an input type that accepts RuleGroupAddressArray and RuleGroupAddressArrayOutput values. You can construct a concrete instance of `RuleGroupAddressArrayInput` via: 

RuleGroupAddressArray{ RuleGroupAddressArgs{...} }

type RuleGroupAddressArrayOutput 

type RuleGroupAddressArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupAddressArrayOutput) ElementType 

func (RuleGroupAddressArrayOutput) ElementType() reflect.Type

func (RuleGroupAddressArrayOutput) Index 

func (o RuleGroupAddressArrayOutput) Index(i pulumi.IntInput) RuleGroupAddressOutput

func (RuleGroupAddressArrayOutput) ToRuleGroupAddressArrayOutput 

func (o RuleGroupAddressArrayOutput) ToRuleGroupAddressArrayOutput() RuleGroupAddressArrayOutput

func (RuleGroupAddressArrayOutput) ToRuleGroupAddressArrayOutputWithContext 

func (o RuleGroupAddressArrayOutput) ToRuleGroupAddressArrayOutputWithContext(ctx context.Context) RuleGroupAddressArrayOutput

type RuleGroupAddressInput 

type RuleGroupAddressInput interface {
	pulumi.Input

	ToRuleGroupAddressOutput() RuleGroupAddressOutput
	ToRuleGroupAddressOutputWithContext(context.Context) RuleGroupAddressOutput
}

RuleGroupAddressInput is an input type that accepts RuleGroupAddressArgs and RuleGroupAddressOutput values. You can construct a concrete instance of `RuleGroupAddressInput` via: 

RuleGroupAddressArgs{...}

type RuleGroupAddressOutput 

type RuleGroupAddressOutput struct{ *pulumi.OutputState }

func (RuleGroupAddressOutput) AddressDefinition 

func (o RuleGroupAddressOutput) AddressDefinition() pulumi.StringOutput

func (RuleGroupAddressOutput) ElementType 

func (RuleGroupAddressOutput) ElementType() reflect.Type

func (RuleGroupAddressOutput) ToRuleGroupAddressOutput 

func (o RuleGroupAddressOutput) ToRuleGroupAddressOutput() RuleGroupAddressOutput

func (RuleGroupAddressOutput) ToRuleGroupAddressOutputWithContext 

func (o RuleGroupAddressOutput) ToRuleGroupAddressOutputWithContext(ctx context.Context) RuleGroupAddressOutput

type RuleGroupArgs 

type RuleGroupArgs struct {
	Capacity      pulumi.IntInput
	Description   pulumi.StringPtrInput
	RuleGroup     RuleGroupTypePtrInput
	RuleGroupName pulumi.StringPtrInput
	Tags          RuleGroupTagArrayInput
	Type          RuleGroupTypeEnumInput
}

The set of arguments for constructing a RuleGroup resource.

func (RuleGroupArgs) ElementType 

func (RuleGroupArgs) ElementType() reflect.Type

type RuleGroupCustomAction 

type RuleGroupCustomAction struct {
	ActionDefinition RuleGroupActionDefinition `pulumi:"actionDefinition"`
	ActionName       string                    `pulumi:"actionName"`
}

type RuleGroupCustomActionArgs 

type RuleGroupCustomActionArgs struct {
	ActionDefinition RuleGroupActionDefinitionInput `pulumi:"actionDefinition"`
	ActionName       pulumi.StringInput             `pulumi:"actionName"`
}

func (RuleGroupCustomActionArgs) ElementType 

func (RuleGroupCustomActionArgs) ElementType() reflect.Type

func (RuleGroupCustomActionArgs) ToRuleGroupCustomActionOutput 

func (i RuleGroupCustomActionArgs) ToRuleGroupCustomActionOutput() RuleGroupCustomActionOutput

func (RuleGroupCustomActionArgs) ToRuleGroupCustomActionOutputWithContext 

func (i RuleGroupCustomActionArgs) ToRuleGroupCustomActionOutputWithContext(ctx context.Context) RuleGroupCustomActionOutput

type RuleGroupCustomActionArray 

type RuleGroupCustomActionArray []RuleGroupCustomActionInput

func (RuleGroupCustomActionArray) ElementType 

func (RuleGroupCustomActionArray) ElementType() reflect.Type

func (RuleGroupCustomActionArray) ToRuleGroupCustomActionArrayOutput 

func (i RuleGroupCustomActionArray) ToRuleGroupCustomActionArrayOutput() RuleGroupCustomActionArrayOutput

func (RuleGroupCustomActionArray) ToRuleGroupCustomActionArrayOutputWithContext 

func (i RuleGroupCustomActionArray) ToRuleGroupCustomActionArrayOutputWithContext(ctx context.Context) RuleGroupCustomActionArrayOutput

type RuleGroupCustomActionArrayInput 

type RuleGroupCustomActionArrayInput interface {
	pulumi.Input

	ToRuleGroupCustomActionArrayOutput() RuleGroupCustomActionArrayOutput
	ToRuleGroupCustomActionArrayOutputWithContext(context.Context) RuleGroupCustomActionArrayOutput
}

RuleGroupCustomActionArrayInput is an input type that accepts RuleGroupCustomActionArray and RuleGroupCustomActionArrayOutput values. You can construct a concrete instance of `RuleGroupCustomActionArrayInput` via: 

RuleGroupCustomActionArray{ RuleGroupCustomActionArgs{...} }

type RuleGroupCustomActionArrayOutput 

type RuleGroupCustomActionArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupCustomActionArrayOutput) ElementType 

func (RuleGroupCustomActionArrayOutput) ElementType() reflect.Type

func (RuleGroupCustomActionArrayOutput) Index 

func (o RuleGroupCustomActionArrayOutput) Index(i pulumi.IntInput) RuleGroupCustomActionOutput

func (RuleGroupCustomActionArrayOutput) ToRuleGroupCustomActionArrayOutput 

func (o RuleGroupCustomActionArrayOutput) ToRuleGroupCustomActionArrayOutput() RuleGroupCustomActionArrayOutput

func (RuleGroupCustomActionArrayOutput) ToRuleGroupCustomActionArrayOutputWithContext 

func (o RuleGroupCustomActionArrayOutput) ToRuleGroupCustomActionArrayOutputWithContext(ctx context.Context) RuleGroupCustomActionArrayOutput

type RuleGroupCustomActionInput 

type RuleGroupCustomActionInput interface {
	pulumi.Input

	ToRuleGroupCustomActionOutput() RuleGroupCustomActionOutput
	ToRuleGroupCustomActionOutputWithContext(context.Context) RuleGroupCustomActionOutput
}

RuleGroupCustomActionInput is an input type that accepts RuleGroupCustomActionArgs and RuleGroupCustomActionOutput values. You can construct a concrete instance of `RuleGroupCustomActionInput` via: 

RuleGroupCustomActionArgs{...}

type RuleGroupCustomActionOutput 

type RuleGroupCustomActionOutput struct{ *pulumi.OutputState }

func (RuleGroupCustomActionOutput) ActionDefinition 

func (o RuleGroupCustomActionOutput) ActionDefinition() RuleGroupActionDefinitionOutput

func (RuleGroupCustomActionOutput) ActionName 

func (o RuleGroupCustomActionOutput) ActionName() pulumi.StringOutput

func (RuleGroupCustomActionOutput) ElementType 

func (RuleGroupCustomActionOutput) ElementType() reflect.Type

func (RuleGroupCustomActionOutput) ToRuleGroupCustomActionOutput 

func (o RuleGroupCustomActionOutput) ToRuleGroupCustomActionOutput() RuleGroupCustomActionOutput

func (RuleGroupCustomActionOutput) ToRuleGroupCustomActionOutputWithContext 

func (o RuleGroupCustomActionOutput) ToRuleGroupCustomActionOutputWithContext(ctx context.Context) RuleGroupCustomActionOutput

type RuleGroupDimension 

type RuleGroupDimension struct {
	Value string `pulumi:"value"`
}

type RuleGroupDimensionArgs 

type RuleGroupDimensionArgs struct {
	Value pulumi.StringInput `pulumi:"value"`
}

func (RuleGroupDimensionArgs) ElementType 

func (RuleGroupDimensionArgs) ElementType() reflect.Type

func (RuleGroupDimensionArgs) ToRuleGroupDimensionOutput 

func (i RuleGroupDimensionArgs) ToRuleGroupDimensionOutput() RuleGroupDimensionOutput

func (RuleGroupDimensionArgs) ToRuleGroupDimensionOutputWithContext 

func (i RuleGroupDimensionArgs) ToRuleGroupDimensionOutputWithContext(ctx context.Context) RuleGroupDimensionOutput

type RuleGroupDimensionArray 

type RuleGroupDimensionArray []RuleGroupDimensionInput

func (RuleGroupDimensionArray) ElementType 

func (RuleGroupDimensionArray) ElementType() reflect.Type

func (RuleGroupDimensionArray) ToRuleGroupDimensionArrayOutput 

func (i RuleGroupDimensionArray) ToRuleGroupDimensionArrayOutput() RuleGroupDimensionArrayOutput

func (RuleGroupDimensionArray) ToRuleGroupDimensionArrayOutputWithContext 

func (i RuleGroupDimensionArray) ToRuleGroupDimensionArrayOutputWithContext(ctx context.Context) RuleGroupDimensionArrayOutput

type RuleGroupDimensionArrayInput 

type RuleGroupDimensionArrayInput interface {
	pulumi.Input

	ToRuleGroupDimensionArrayOutput() RuleGroupDimensionArrayOutput
	ToRuleGroupDimensionArrayOutputWithContext(context.Context) RuleGroupDimensionArrayOutput
}

RuleGroupDimensionArrayInput is an input type that accepts RuleGroupDimensionArray and RuleGroupDimensionArrayOutput values. You can construct a concrete instance of `RuleGroupDimensionArrayInput` via: 

RuleGroupDimensionArray{ RuleGroupDimensionArgs{...} }

type RuleGroupDimensionArrayOutput 

type RuleGroupDimensionArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupDimensionArrayOutput) ElementType 

func (RuleGroupDimensionArrayOutput) ElementType() reflect.Type

func (RuleGroupDimensionArrayOutput) Index 

func (o RuleGroupDimensionArrayOutput) Index(i pulumi.IntInput) RuleGroupDimensionOutput

func (RuleGroupDimensionArrayOutput) ToRuleGroupDimensionArrayOutput 

func (o RuleGroupDimensionArrayOutput) ToRuleGroupDimensionArrayOutput() RuleGroupDimensionArrayOutput

func (RuleGroupDimensionArrayOutput) ToRuleGroupDimensionArrayOutputWithContext 

func (o RuleGroupDimensionArrayOutput) ToRuleGroupDimensionArrayOutputWithContext(ctx context.Context) RuleGroupDimensionArrayOutput

type RuleGroupDimensionInput 

type RuleGroupDimensionInput interface {
	pulumi.Input

	ToRuleGroupDimensionOutput() RuleGroupDimensionOutput
	ToRuleGroupDimensionOutputWithContext(context.Context) RuleGroupDimensionOutput
}

RuleGroupDimensionInput is an input type that accepts RuleGroupDimensionArgs and RuleGroupDimensionOutput values. You can construct a concrete instance of `RuleGroupDimensionInput` via: 

RuleGroupDimensionArgs{...}

type RuleGroupDimensionOutput 

type RuleGroupDimensionOutput struct{ *pulumi.OutputState }

func (RuleGroupDimensionOutput) ElementType 

func (RuleGroupDimensionOutput) ElementType() reflect.Type

func (RuleGroupDimensionOutput) ToRuleGroupDimensionOutput 

func (o RuleGroupDimensionOutput) ToRuleGroupDimensionOutput() RuleGroupDimensionOutput

func (RuleGroupDimensionOutput) ToRuleGroupDimensionOutputWithContext 

func (o RuleGroupDimensionOutput) ToRuleGroupDimensionOutputWithContext(ctx context.Context) RuleGroupDimensionOutput

func (RuleGroupDimensionOutput) Value 

func (o RuleGroupDimensionOutput) Value() pulumi.StringOutput

type RuleGroupGeneratedRulesType 

type RuleGroupGeneratedRulesType string

func (RuleGroupGeneratedRulesType) ElementType 

func (RuleGroupGeneratedRulesType) ElementType() reflect.Type

func (RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypeOutput 

func (e RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypeOutput() RuleGroupGeneratedRulesTypeOutput

func (RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypeOutputWithContext 

func (e RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypeOutputWithContext(ctx context.Context) RuleGroupGeneratedRulesTypeOutput

func (RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypePtrOutput 

func (e RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypePtrOutput() RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypePtrOutputWithContext 

func (e RuleGroupGeneratedRulesType) ToRuleGroupGeneratedRulesTypePtrOutputWithContext(ctx context.Context) RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupGeneratedRulesType) ToStringOutput 

func (e RuleGroupGeneratedRulesType) ToStringOutput() pulumi.StringOutput

func (RuleGroupGeneratedRulesType) ToStringOutputWithContext 

func (e RuleGroupGeneratedRulesType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupGeneratedRulesType) ToStringPtrOutput 

func (e RuleGroupGeneratedRulesType) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupGeneratedRulesType) ToStringPtrOutputWithContext 

func (e RuleGroupGeneratedRulesType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupGeneratedRulesTypeInput 

type RuleGroupGeneratedRulesTypeInput interface {
	pulumi.Input

	ToRuleGroupGeneratedRulesTypeOutput() RuleGroupGeneratedRulesTypeOutput
	ToRuleGroupGeneratedRulesTypeOutputWithContext(context.Context) RuleGroupGeneratedRulesTypeOutput
}

RuleGroupGeneratedRulesTypeInput is an input type that accepts RuleGroupGeneratedRulesTypeArgs and RuleGroupGeneratedRulesTypeOutput values. You can construct a concrete instance of `RuleGroupGeneratedRulesTypeInput` via: 

RuleGroupGeneratedRulesTypeArgs{...}

type RuleGroupGeneratedRulesTypeOutput 

type RuleGroupGeneratedRulesTypeOutput struct{ *pulumi.OutputState }

func (RuleGroupGeneratedRulesTypeOutput) ElementType 

func (RuleGroupGeneratedRulesTypeOutput) ElementType() reflect.Type

func (RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypeOutput 

func (o RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypeOutput() RuleGroupGeneratedRulesTypeOutput

func (RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypeOutputWithContext 

func (o RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypeOutputWithContext(ctx context.Context) RuleGroupGeneratedRulesTypeOutput

func (RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypePtrOutput 

func (o RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypePtrOutput() RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypePtrOutputWithContext 

func (o RuleGroupGeneratedRulesTypeOutput) ToRuleGroupGeneratedRulesTypePtrOutputWithContext(ctx context.Context) RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupGeneratedRulesTypeOutput) ToStringOutput 

func (o RuleGroupGeneratedRulesTypeOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupGeneratedRulesTypeOutput) ToStringOutputWithContext 

func (o RuleGroupGeneratedRulesTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupGeneratedRulesTypeOutput) ToStringPtrOutput 

func (o RuleGroupGeneratedRulesTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupGeneratedRulesTypeOutput) ToStringPtrOutputWithContext 

func (o RuleGroupGeneratedRulesTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupGeneratedRulesTypePtrInput 

type RuleGroupGeneratedRulesTypePtrInput interface {
	pulumi.Input

	ToRuleGroupGeneratedRulesTypePtrOutput() RuleGroupGeneratedRulesTypePtrOutput
	ToRuleGroupGeneratedRulesTypePtrOutputWithContext(context.Context) RuleGroupGeneratedRulesTypePtrOutput
}

func RuleGroupGeneratedRulesTypePtr 

func RuleGroupGeneratedRulesTypePtr(v string) RuleGroupGeneratedRulesTypePtrInput

type RuleGroupGeneratedRulesTypePtrOutput 

type RuleGroupGeneratedRulesTypePtrOutput struct{ *pulumi.OutputState }

func (RuleGroupGeneratedRulesTypePtrOutput) Elem 

func (o RuleGroupGeneratedRulesTypePtrOutput) Elem() RuleGroupGeneratedRulesTypeOutput

func (RuleGroupGeneratedRulesTypePtrOutput) ElementType 

func (RuleGroupGeneratedRulesTypePtrOutput) ElementType() reflect.Type

func (RuleGroupGeneratedRulesTypePtrOutput) ToRuleGroupGeneratedRulesTypePtrOutput 

func (o RuleGroupGeneratedRulesTypePtrOutput) ToRuleGroupGeneratedRulesTypePtrOutput() RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupGeneratedRulesTypePtrOutput) ToRuleGroupGeneratedRulesTypePtrOutputWithContext 

func (o RuleGroupGeneratedRulesTypePtrOutput) ToRuleGroupGeneratedRulesTypePtrOutputWithContext(ctx context.Context) RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupGeneratedRulesTypePtrOutput) ToStringPtrOutput 

func (o RuleGroupGeneratedRulesTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupGeneratedRulesTypePtrOutput) ToStringPtrOutputWithContext 

func (o RuleGroupGeneratedRulesTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupHeader 

type RuleGroupHeader struct {
	Destination     string                   `pulumi:"destination"`
	DestinationPort string                   `pulumi:"destinationPort"`
	Direction       RuleGroupHeaderDirection `pulumi:"direction"`
	Protocol        RuleGroupHeaderProtocol  `pulumi:"protocol"`
	Source          string                   `pulumi:"source"`
	SourcePort      string                   `pulumi:"sourcePort"`
}

type RuleGroupHeaderArgs 

type RuleGroupHeaderArgs struct {
	Destination     pulumi.StringInput            `pulumi:"destination"`
	DestinationPort pulumi.StringInput            `pulumi:"destinationPort"`
	Direction       RuleGroupHeaderDirectionInput `pulumi:"direction"`
	Protocol        RuleGroupHeaderProtocolInput  `pulumi:"protocol"`
	Source          pulumi.StringInput            `pulumi:"source"`
	SourcePort      pulumi.StringInput            `pulumi:"sourcePort"`
}

func (RuleGroupHeaderArgs) ElementType 

func (RuleGroupHeaderArgs) ElementType() reflect.Type

func (RuleGroupHeaderArgs) ToRuleGroupHeaderOutput 

func (i RuleGroupHeaderArgs) ToRuleGroupHeaderOutput() RuleGroupHeaderOutput

func (RuleGroupHeaderArgs) ToRuleGroupHeaderOutputWithContext 

func (i RuleGroupHeaderArgs) ToRuleGroupHeaderOutputWithContext(ctx context.Context) RuleGroupHeaderOutput

type RuleGroupHeaderDirection 

type RuleGroupHeaderDirection string

func (RuleGroupHeaderDirection) ElementType 

func (RuleGroupHeaderDirection) ElementType() reflect.Type

func (RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionOutput 

func (e RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionOutput() RuleGroupHeaderDirectionOutput

func (RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionOutputWithContext 

func (e RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionOutputWithContext(ctx context.Context) RuleGroupHeaderDirectionOutput

func (RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionPtrOutput 

func (e RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionPtrOutput() RuleGroupHeaderDirectionPtrOutput

func (RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionPtrOutputWithContext 

func (e RuleGroupHeaderDirection) ToRuleGroupHeaderDirectionPtrOutputWithContext(ctx context.Context) RuleGroupHeaderDirectionPtrOutput

func (RuleGroupHeaderDirection) ToStringOutput 

func (e RuleGroupHeaderDirection) ToStringOutput() pulumi.StringOutput

func (RuleGroupHeaderDirection) ToStringOutputWithContext 

func (e RuleGroupHeaderDirection) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupHeaderDirection) ToStringPtrOutput 

func (e RuleGroupHeaderDirection) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupHeaderDirection) ToStringPtrOutputWithContext 

func (e RuleGroupHeaderDirection) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupHeaderDirectionInput 

type RuleGroupHeaderDirectionInput interface {
	pulumi.Input

	ToRuleGroupHeaderDirectionOutput() RuleGroupHeaderDirectionOutput
	ToRuleGroupHeaderDirectionOutputWithContext(context.Context) RuleGroupHeaderDirectionOutput
}

RuleGroupHeaderDirectionInput is an input type that accepts RuleGroupHeaderDirectionArgs and RuleGroupHeaderDirectionOutput values. You can construct a concrete instance of `RuleGroupHeaderDirectionInput` via: 

RuleGroupHeaderDirectionArgs{...}

type RuleGroupHeaderDirectionOutput 

type RuleGroupHeaderDirectionOutput struct{ *pulumi.OutputState }

func (RuleGroupHeaderDirectionOutput) ElementType 

func (RuleGroupHeaderDirectionOutput) ElementType() reflect.Type

func (RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionOutput 

func (o RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionOutput() RuleGroupHeaderDirectionOutput

func (RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionOutputWithContext 

func (o RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionOutputWithContext(ctx context.Context) RuleGroupHeaderDirectionOutput

func (RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionPtrOutput 

func (o RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionPtrOutput() RuleGroupHeaderDirectionPtrOutput

func (RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionPtrOutputWithContext 

func (o RuleGroupHeaderDirectionOutput) ToRuleGroupHeaderDirectionPtrOutputWithContext(ctx context.Context) RuleGroupHeaderDirectionPtrOutput

func (RuleGroupHeaderDirectionOutput) ToStringOutput 

func (o RuleGroupHeaderDirectionOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupHeaderDirectionOutput) ToStringOutputWithContext 

func (o RuleGroupHeaderDirectionOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupHeaderDirectionOutput) ToStringPtrOutput 

func (o RuleGroupHeaderDirectionOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupHeaderDirectionOutput) ToStringPtrOutputWithContext 

func (o RuleGroupHeaderDirectionOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupHeaderDirectionPtrInput 

type RuleGroupHeaderDirectionPtrInput interface {
	pulumi.Input

	ToRuleGroupHeaderDirectionPtrOutput() RuleGroupHeaderDirectionPtrOutput
	ToRuleGroupHeaderDirectionPtrOutputWithContext(context.Context) RuleGroupHeaderDirectionPtrOutput
}

func RuleGroupHeaderDirectionPtr 

func RuleGroupHeaderDirectionPtr(v string) RuleGroupHeaderDirectionPtrInput

type RuleGroupHeaderDirectionPtrOutput 

type RuleGroupHeaderDirectionPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupHeaderDirectionPtrOutput) Elem 

func (o RuleGroupHeaderDirectionPtrOutput) Elem() RuleGroupHeaderDirectionOutput

func (RuleGroupHeaderDirectionPtrOutput) ElementType 

func (RuleGroupHeaderDirectionPtrOutput) ElementType() reflect.Type

func (RuleGroupHeaderDirectionPtrOutput) ToRuleGroupHeaderDirectionPtrOutput 

func (o RuleGroupHeaderDirectionPtrOutput) ToRuleGroupHeaderDirectionPtrOutput() RuleGroupHeaderDirectionPtrOutput

func (RuleGroupHeaderDirectionPtrOutput) ToRuleGroupHeaderDirectionPtrOutputWithContext 

func (o RuleGroupHeaderDirectionPtrOutput) ToRuleGroupHeaderDirectionPtrOutputWithContext(ctx context.Context) RuleGroupHeaderDirectionPtrOutput

func (RuleGroupHeaderDirectionPtrOutput) ToStringPtrOutput 

func (o RuleGroupHeaderDirectionPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupHeaderDirectionPtrOutput) ToStringPtrOutputWithContext 

func (o RuleGroupHeaderDirectionPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupHeaderInput 

type RuleGroupHeaderInput interface {
	pulumi.Input

	ToRuleGroupHeaderOutput() RuleGroupHeaderOutput
	ToRuleGroupHeaderOutputWithContext(context.Context) RuleGroupHeaderOutput
}

RuleGroupHeaderInput is an input type that accepts RuleGroupHeaderArgs and RuleGroupHeaderOutput values. You can construct a concrete instance of `RuleGroupHeaderInput` via: 

RuleGroupHeaderArgs{...}

type RuleGroupHeaderOutput 

type RuleGroupHeaderOutput struct{ *pulumi.OutputState }

func (RuleGroupHeaderOutput) Destination 

func (o RuleGroupHeaderOutput) Destination() pulumi.StringOutput

func (RuleGroupHeaderOutput) DestinationPort 

func (o RuleGroupHeaderOutput) DestinationPort() pulumi.StringOutput

func (RuleGroupHeaderOutput) Direction 

func (o RuleGroupHeaderOutput) Direction() RuleGroupHeaderDirectionOutput

func (RuleGroupHeaderOutput) ElementType 

func (RuleGroupHeaderOutput) ElementType() reflect.Type

func (RuleGroupHeaderOutput) Protocol 

func (o RuleGroupHeaderOutput) Protocol() RuleGroupHeaderProtocolOutput

func (RuleGroupHeaderOutput) Source 

func (o RuleGroupHeaderOutput) Source() pulumi.StringOutput

func (RuleGroupHeaderOutput) SourcePort 

func (o RuleGroupHeaderOutput) SourcePort() pulumi.StringOutput

func (RuleGroupHeaderOutput) ToRuleGroupHeaderOutput 

func (o RuleGroupHeaderOutput) ToRuleGroupHeaderOutput() RuleGroupHeaderOutput

func (RuleGroupHeaderOutput) ToRuleGroupHeaderOutputWithContext 

func (o RuleGroupHeaderOutput) ToRuleGroupHeaderOutputWithContext(ctx context.Context) RuleGroupHeaderOutput

type RuleGroupHeaderProtocol 

type RuleGroupHeaderProtocol string

func (RuleGroupHeaderProtocol) ElementType 

func (RuleGroupHeaderProtocol) ElementType() reflect.Type

func (RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolOutput 

func (e RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolOutput() RuleGroupHeaderProtocolOutput

func (RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolOutputWithContext 

func (e RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolOutputWithContext(ctx context.Context) RuleGroupHeaderProtocolOutput

func (RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolPtrOutput 

func (e RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolPtrOutput() RuleGroupHeaderProtocolPtrOutput

func (RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolPtrOutputWithContext 

func (e RuleGroupHeaderProtocol) ToRuleGroupHeaderProtocolPtrOutputWithContext(ctx context.Context) RuleGroupHeaderProtocolPtrOutput

func (RuleGroupHeaderProtocol) ToStringOutput 

func (e RuleGroupHeaderProtocol) ToStringOutput() pulumi.StringOutput

func (RuleGroupHeaderProtocol) ToStringOutputWithContext 

func (e RuleGroupHeaderProtocol) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupHeaderProtocol) ToStringPtrOutput 

func (e RuleGroupHeaderProtocol) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupHeaderProtocol) ToStringPtrOutputWithContext 

func (e RuleGroupHeaderProtocol) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupHeaderProtocolInput 

type RuleGroupHeaderProtocolInput interface {
	pulumi.Input

	ToRuleGroupHeaderProtocolOutput() RuleGroupHeaderProtocolOutput
	ToRuleGroupHeaderProtocolOutputWithContext(context.Context) RuleGroupHeaderProtocolOutput
}

RuleGroupHeaderProtocolInput is an input type that accepts RuleGroupHeaderProtocolArgs and RuleGroupHeaderProtocolOutput values. You can construct a concrete instance of `RuleGroupHeaderProtocolInput` via: 

RuleGroupHeaderProtocolArgs{...}

type RuleGroupHeaderProtocolOutput 

type RuleGroupHeaderProtocolOutput struct{ *pulumi.OutputState }

func (RuleGroupHeaderProtocolOutput) ElementType 

func (RuleGroupHeaderProtocolOutput) ElementType() reflect.Type

func (RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolOutput 

func (o RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolOutput() RuleGroupHeaderProtocolOutput

func (RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolOutputWithContext 

func (o RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolOutputWithContext(ctx context.Context) RuleGroupHeaderProtocolOutput

func (RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolPtrOutput 

func (o RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolPtrOutput() RuleGroupHeaderProtocolPtrOutput

func (RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolPtrOutputWithContext 

func (o RuleGroupHeaderProtocolOutput) ToRuleGroupHeaderProtocolPtrOutputWithContext(ctx context.Context) RuleGroupHeaderProtocolPtrOutput

func (RuleGroupHeaderProtocolOutput) ToStringOutput 

func (o RuleGroupHeaderProtocolOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupHeaderProtocolOutput) ToStringOutputWithContext 

func (o RuleGroupHeaderProtocolOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupHeaderProtocolOutput) ToStringPtrOutput 

func (o RuleGroupHeaderProtocolOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupHeaderProtocolOutput) ToStringPtrOutputWithContext 

func (o RuleGroupHeaderProtocolOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupHeaderProtocolPtrInput 

type RuleGroupHeaderProtocolPtrInput interface {
	pulumi.Input

	ToRuleGroupHeaderProtocolPtrOutput() RuleGroupHeaderProtocolPtrOutput
	ToRuleGroupHeaderProtocolPtrOutputWithContext(context.Context) RuleGroupHeaderProtocolPtrOutput
}

func RuleGroupHeaderProtocolPtr 

func RuleGroupHeaderProtocolPtr(v string) RuleGroupHeaderProtocolPtrInput

type RuleGroupHeaderProtocolPtrOutput 

type RuleGroupHeaderProtocolPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupHeaderProtocolPtrOutput) Elem 

func (o RuleGroupHeaderProtocolPtrOutput) Elem() RuleGroupHeaderProtocolOutput

func (RuleGroupHeaderProtocolPtrOutput) ElementType 

func (RuleGroupHeaderProtocolPtrOutput) ElementType() reflect.Type

func (RuleGroupHeaderProtocolPtrOutput) ToRuleGroupHeaderProtocolPtrOutput 

func (o RuleGroupHeaderProtocolPtrOutput) ToRuleGroupHeaderProtocolPtrOutput() RuleGroupHeaderProtocolPtrOutput

func (RuleGroupHeaderProtocolPtrOutput) ToRuleGroupHeaderProtocolPtrOutputWithContext 

func (o RuleGroupHeaderProtocolPtrOutput) ToRuleGroupHeaderProtocolPtrOutputWithContext(ctx context.Context) RuleGroupHeaderProtocolPtrOutput

func (RuleGroupHeaderProtocolPtrOutput) ToStringPtrOutput 

func (o RuleGroupHeaderProtocolPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupHeaderProtocolPtrOutput) ToStringPtrOutputWithContext 

func (o RuleGroupHeaderProtocolPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupInput 

type RuleGroupInput interface {
	pulumi.Input

	ToRuleGroupOutput() RuleGroupOutput
	ToRuleGroupOutputWithContext(ctx context.Context) RuleGroupOutput
}

type RuleGroupMatchAttributes 

type RuleGroupMatchAttributes struct {
	DestinationPorts []RuleGroupPortRange    `pulumi:"destinationPorts"`
	Destinations     []RuleGroupAddress      `pulumi:"destinations"`
	Protocols        []int                   `pulumi:"protocols"`
	SourcePorts      []RuleGroupPortRange    `pulumi:"sourcePorts"`
	Sources          []RuleGroupAddress      `pulumi:"sources"`
	TCPFlags         []RuleGroupTCPFlagField `pulumi:"tCPFlags"`
}

type RuleGroupMatchAttributesArgs 

type RuleGroupMatchAttributesArgs struct {
	DestinationPorts RuleGroupPortRangeArrayInput    `pulumi:"destinationPorts"`
	Destinations     RuleGroupAddressArrayInput      `pulumi:"destinations"`
	Protocols        pulumi.IntArrayInput            `pulumi:"protocols"`
	SourcePorts      RuleGroupPortRangeArrayInput    `pulumi:"sourcePorts"`
	Sources          RuleGroupAddressArrayInput      `pulumi:"sources"`
	TCPFlags         RuleGroupTCPFlagFieldArrayInput `pulumi:"tCPFlags"`
}

func (RuleGroupMatchAttributesArgs) ElementType 

func (RuleGroupMatchAttributesArgs) ElementType() reflect.Type

func (RuleGroupMatchAttributesArgs) ToRuleGroupMatchAttributesOutput 

func (i RuleGroupMatchAttributesArgs) ToRuleGroupMatchAttributesOutput() RuleGroupMatchAttributesOutput

func (RuleGroupMatchAttributesArgs) ToRuleGroupMatchAttributesOutputWithContext 

func (i RuleGroupMatchAttributesArgs) ToRuleGroupMatchAttributesOutputWithContext(ctx context.Context) RuleGroupMatchAttributesOutput

type RuleGroupMatchAttributesInput 

type RuleGroupMatchAttributesInput interface {
	pulumi.Input

	ToRuleGroupMatchAttributesOutput() RuleGroupMatchAttributesOutput
	ToRuleGroupMatchAttributesOutputWithContext(context.Context) RuleGroupMatchAttributesOutput
}

RuleGroupMatchAttributesInput is an input type that accepts RuleGroupMatchAttributesArgs and RuleGroupMatchAttributesOutput values. You can construct a concrete instance of `RuleGroupMatchAttributesInput` via: 

RuleGroupMatchAttributesArgs{...}

type RuleGroupMatchAttributesOutput 

type RuleGroupMatchAttributesOutput struct{ *pulumi.OutputState }

func (RuleGroupMatchAttributesOutput) DestinationPorts 

func (o RuleGroupMatchAttributesOutput) DestinationPorts() RuleGroupPortRangeArrayOutput

func (RuleGroupMatchAttributesOutput) Destinations 

func (o RuleGroupMatchAttributesOutput) Destinations() RuleGroupAddressArrayOutput

func (RuleGroupMatchAttributesOutput) ElementType 

func (RuleGroupMatchAttributesOutput) ElementType() reflect.Type

func (RuleGroupMatchAttributesOutput) Protocols 

func (o RuleGroupMatchAttributesOutput) Protocols() pulumi.IntArrayOutput

func (RuleGroupMatchAttributesOutput) SourcePorts 

func (o RuleGroupMatchAttributesOutput) SourcePorts() RuleGroupPortRangeArrayOutput

func (RuleGroupMatchAttributesOutput) Sources 

func (o RuleGroupMatchAttributesOutput) Sources() RuleGroupAddressArrayOutput

func (RuleGroupMatchAttributesOutput) TCPFlags 

func (o RuleGroupMatchAttributesOutput) TCPFlags() RuleGroupTCPFlagFieldArrayOutput

func (RuleGroupMatchAttributesOutput) ToRuleGroupMatchAttributesOutput 

func (o RuleGroupMatchAttributesOutput) ToRuleGroupMatchAttributesOutput() RuleGroupMatchAttributesOutput

func (RuleGroupMatchAttributesOutput) ToRuleGroupMatchAttributesOutputWithContext 

func (o RuleGroupMatchAttributesOutput) ToRuleGroupMatchAttributesOutputWithContext(ctx context.Context) RuleGroupMatchAttributesOutput

type RuleGroupOutput 

type RuleGroupOutput struct{ *pulumi.OutputState }

func (RuleGroupOutput) ElementType 

func (RuleGroupOutput) ElementType() reflect.Type

func (RuleGroupOutput) ToRuleGroupOutput 

func (o RuleGroupOutput) ToRuleGroupOutput() RuleGroupOutput

func (RuleGroupOutput) ToRuleGroupOutputWithContext 

func (o RuleGroupOutput) ToRuleGroupOutputWithContext(ctx context.Context) RuleGroupOutput

type RuleGroupPortRange 

type RuleGroupPortRange struct {
	FromPort int `pulumi:"fromPort"`
	ToPort   int `pulumi:"toPort"`
}

type RuleGroupPortRangeArgs 

type RuleGroupPortRangeArgs struct {
	FromPort pulumi.IntInput `pulumi:"fromPort"`
	ToPort   pulumi.IntInput `pulumi:"toPort"`
}

func (RuleGroupPortRangeArgs) ElementType 

func (RuleGroupPortRangeArgs) ElementType() reflect.Type

func (RuleGroupPortRangeArgs) ToRuleGroupPortRangeOutput 

func (i RuleGroupPortRangeArgs) ToRuleGroupPortRangeOutput() RuleGroupPortRangeOutput

func (RuleGroupPortRangeArgs) ToRuleGroupPortRangeOutputWithContext 

func (i RuleGroupPortRangeArgs) ToRuleGroupPortRangeOutputWithContext(ctx context.Context) RuleGroupPortRangeOutput

type RuleGroupPortRangeArray 

type RuleGroupPortRangeArray []RuleGroupPortRangeInput

func (RuleGroupPortRangeArray) ElementType 

func (RuleGroupPortRangeArray) ElementType() reflect.Type

func (RuleGroupPortRangeArray) ToRuleGroupPortRangeArrayOutput 

func (i RuleGroupPortRangeArray) ToRuleGroupPortRangeArrayOutput() RuleGroupPortRangeArrayOutput

func (RuleGroupPortRangeArray) ToRuleGroupPortRangeArrayOutputWithContext 

func (i RuleGroupPortRangeArray) ToRuleGroupPortRangeArrayOutputWithContext(ctx context.Context) RuleGroupPortRangeArrayOutput

type RuleGroupPortRangeArrayInput 

type RuleGroupPortRangeArrayInput interface {
	pulumi.Input

	ToRuleGroupPortRangeArrayOutput() RuleGroupPortRangeArrayOutput
	ToRuleGroupPortRangeArrayOutputWithContext(context.Context) RuleGroupPortRangeArrayOutput
}

RuleGroupPortRangeArrayInput is an input type that accepts RuleGroupPortRangeArray and RuleGroupPortRangeArrayOutput values. You can construct a concrete instance of `RuleGroupPortRangeArrayInput` via: 

RuleGroupPortRangeArray{ RuleGroupPortRangeArgs{...} }

type RuleGroupPortRangeArrayOutput 

type RuleGroupPortRangeArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupPortRangeArrayOutput) ElementType 

func (RuleGroupPortRangeArrayOutput) ElementType() reflect.Type

func (RuleGroupPortRangeArrayOutput) Index 

func (o RuleGroupPortRangeArrayOutput) Index(i pulumi.IntInput) RuleGroupPortRangeOutput

func (RuleGroupPortRangeArrayOutput) ToRuleGroupPortRangeArrayOutput 

func (o RuleGroupPortRangeArrayOutput) ToRuleGroupPortRangeArrayOutput() RuleGroupPortRangeArrayOutput

func (RuleGroupPortRangeArrayOutput) ToRuleGroupPortRangeArrayOutputWithContext 

func (o RuleGroupPortRangeArrayOutput) ToRuleGroupPortRangeArrayOutputWithContext(ctx context.Context) RuleGroupPortRangeArrayOutput

type RuleGroupPortRangeInput 

type RuleGroupPortRangeInput interface {
	pulumi.Input

	ToRuleGroupPortRangeOutput() RuleGroupPortRangeOutput
	ToRuleGroupPortRangeOutputWithContext(context.Context) RuleGroupPortRangeOutput
}

RuleGroupPortRangeInput is an input type that accepts RuleGroupPortRangeArgs and RuleGroupPortRangeOutput values. You can construct a concrete instance of `RuleGroupPortRangeInput` via: 

RuleGroupPortRangeArgs{...}

type RuleGroupPortRangeOutput 

type RuleGroupPortRangeOutput struct{ *pulumi.OutputState }

func (RuleGroupPortRangeOutput) ElementType 

func (RuleGroupPortRangeOutput) ElementType() reflect.Type

func (RuleGroupPortRangeOutput) FromPort 

func (o RuleGroupPortRangeOutput) FromPort() pulumi.IntOutput

func (RuleGroupPortRangeOutput) ToPort 

func (o RuleGroupPortRangeOutput) ToPort() pulumi.IntOutput

func (RuleGroupPortRangeOutput) ToRuleGroupPortRangeOutput 

func (o RuleGroupPortRangeOutput) ToRuleGroupPortRangeOutput() RuleGroupPortRangeOutput

func (RuleGroupPortRangeOutput) ToRuleGroupPortRangeOutputWithContext 

func (o RuleGroupPortRangeOutput) ToRuleGroupPortRangeOutputWithContext(ctx context.Context) RuleGroupPortRangeOutput

type RuleGroupPublishMetricAction 

type RuleGroupPublishMetricAction struct {
	Dimensions []RuleGroupDimension `pulumi:"dimensions"`
}

type RuleGroupPublishMetricActionArgs 

type RuleGroupPublishMetricActionArgs struct {
	Dimensions RuleGroupDimensionArrayInput `pulumi:"dimensions"`
}

func (RuleGroupPublishMetricActionArgs) ElementType 

func (RuleGroupPublishMetricActionArgs) ElementType() reflect.Type

func (RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionOutput 

func (i RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionOutput() RuleGroupPublishMetricActionOutput

func (RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionOutputWithContext 

func (i RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionOutputWithContext(ctx context.Context) RuleGroupPublishMetricActionOutput

func (RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionPtrOutput 

func (i RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionPtrOutput() RuleGroupPublishMetricActionPtrOutput

func (RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionPtrOutputWithContext 

func (i RuleGroupPublishMetricActionArgs) ToRuleGroupPublishMetricActionPtrOutputWithContext(ctx context.Context) RuleGroupPublishMetricActionPtrOutput

type RuleGroupPublishMetricActionInput 

type RuleGroupPublishMetricActionInput interface {
	pulumi.Input

	ToRuleGroupPublishMetricActionOutput() RuleGroupPublishMetricActionOutput
	ToRuleGroupPublishMetricActionOutputWithContext(context.Context) RuleGroupPublishMetricActionOutput
}

RuleGroupPublishMetricActionInput is an input type that accepts RuleGroupPublishMetricActionArgs and RuleGroupPublishMetricActionOutput values. You can construct a concrete instance of `RuleGroupPublishMetricActionInput` via: 

RuleGroupPublishMetricActionArgs{...}

type RuleGroupPublishMetricActionOutput 

type RuleGroupPublishMetricActionOutput struct{ *pulumi.OutputState }

func (RuleGroupPublishMetricActionOutput) Dimensions 

func (o RuleGroupPublishMetricActionOutput) Dimensions() RuleGroupDimensionArrayOutput

func (RuleGroupPublishMetricActionOutput) ElementType 

func (RuleGroupPublishMetricActionOutput) ElementType() reflect.Type

func (RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionOutput 

func (o RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionOutput() RuleGroupPublishMetricActionOutput

func (RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionOutputWithContext 

func (o RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionOutputWithContext(ctx context.Context) RuleGroupPublishMetricActionOutput

func (RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionPtrOutput 

func (o RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionPtrOutput() RuleGroupPublishMetricActionPtrOutput

func (RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionPtrOutputWithContext 

func (o RuleGroupPublishMetricActionOutput) ToRuleGroupPublishMetricActionPtrOutputWithContext(ctx context.Context) RuleGroupPublishMetricActionPtrOutput

type RuleGroupPublishMetricActionPtrInput 

type RuleGroupPublishMetricActionPtrInput interface {
	pulumi.Input

	ToRuleGroupPublishMetricActionPtrOutput() RuleGroupPublishMetricActionPtrOutput
	ToRuleGroupPublishMetricActionPtrOutputWithContext(context.Context) RuleGroupPublishMetricActionPtrOutput
}

RuleGroupPublishMetricActionPtrInput is an input type that accepts RuleGroupPublishMetricActionArgs, RuleGroupPublishMetricActionPtr and RuleGroupPublishMetricActionPtrOutput values. You can construct a concrete instance of `RuleGroupPublishMetricActionPtrInput` via: 

        RuleGroupPublishMetricActionArgs{...}

or:

        nil

func RuleGroupPublishMetricActionPtr 

func RuleGroupPublishMetricActionPtr(v *RuleGroupPublishMetricActionArgs) RuleGroupPublishMetricActionPtrInput

type RuleGroupPublishMetricActionPtrOutput 

type RuleGroupPublishMetricActionPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupPublishMetricActionPtrOutput) Dimensions 

func (o RuleGroupPublishMetricActionPtrOutput) Dimensions() RuleGroupDimensionArrayOutput

func (RuleGroupPublishMetricActionPtrOutput) Elem 

func (o RuleGroupPublishMetricActionPtrOutput) Elem() RuleGroupPublishMetricActionOutput

func (RuleGroupPublishMetricActionPtrOutput) ElementType 

func (RuleGroupPublishMetricActionPtrOutput) ElementType() reflect.Type

func (RuleGroupPublishMetricActionPtrOutput) ToRuleGroupPublishMetricActionPtrOutput 

func (o RuleGroupPublishMetricActionPtrOutput) ToRuleGroupPublishMetricActionPtrOutput() RuleGroupPublishMetricActionPtrOutput

func (RuleGroupPublishMetricActionPtrOutput) ToRuleGroupPublishMetricActionPtrOutputWithContext 

func (o RuleGroupPublishMetricActionPtrOutput) ToRuleGroupPublishMetricActionPtrOutputWithContext(ctx context.Context) RuleGroupPublishMetricActionPtrOutput

type RuleGroupRuleDefinition 

type RuleGroupRuleDefinition struct {
	Actions         []string                 `pulumi:"actions"`
	MatchAttributes RuleGroupMatchAttributes `pulumi:"matchAttributes"`
}

type RuleGroupRuleDefinitionArgs 

type RuleGroupRuleDefinitionArgs struct {
	Actions         pulumi.StringArrayInput       `pulumi:"actions"`
	MatchAttributes RuleGroupMatchAttributesInput `pulumi:"matchAttributes"`
}

func (RuleGroupRuleDefinitionArgs) ElementType 

func (RuleGroupRuleDefinitionArgs) ElementType() reflect.Type

func (RuleGroupRuleDefinitionArgs) ToRuleGroupRuleDefinitionOutput 

func (i RuleGroupRuleDefinitionArgs) ToRuleGroupRuleDefinitionOutput() RuleGroupRuleDefinitionOutput

func (RuleGroupRuleDefinitionArgs) ToRuleGroupRuleDefinitionOutputWithContext 

func (i RuleGroupRuleDefinitionArgs) ToRuleGroupRuleDefinitionOutputWithContext(ctx context.Context) RuleGroupRuleDefinitionOutput

type RuleGroupRuleDefinitionInput 

type RuleGroupRuleDefinitionInput interface {
	pulumi.Input

	ToRuleGroupRuleDefinitionOutput() RuleGroupRuleDefinitionOutput
	ToRuleGroupRuleDefinitionOutputWithContext(context.Context) RuleGroupRuleDefinitionOutput
}

RuleGroupRuleDefinitionInput is an input type that accepts RuleGroupRuleDefinitionArgs and RuleGroupRuleDefinitionOutput values. You can construct a concrete instance of `RuleGroupRuleDefinitionInput` via: 

RuleGroupRuleDefinitionArgs{...}

type RuleGroupRuleDefinitionOutput 

type RuleGroupRuleDefinitionOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleDefinitionOutput) Actions 

func (o RuleGroupRuleDefinitionOutput) Actions() pulumi.StringArrayOutput

func (RuleGroupRuleDefinitionOutput) ElementType 

func (RuleGroupRuleDefinitionOutput) ElementType() reflect.Type

func (RuleGroupRuleDefinitionOutput) MatchAttributes 

func (o RuleGroupRuleDefinitionOutput) MatchAttributes() RuleGroupMatchAttributesOutput

func (RuleGroupRuleDefinitionOutput) ToRuleGroupRuleDefinitionOutput 

func (o RuleGroupRuleDefinitionOutput) ToRuleGroupRuleDefinitionOutput() RuleGroupRuleDefinitionOutput

func (RuleGroupRuleDefinitionOutput) ToRuleGroupRuleDefinitionOutputWithContext 

func (o RuleGroupRuleDefinitionOutput) ToRuleGroupRuleDefinitionOutputWithContext(ctx context.Context) RuleGroupRuleDefinitionOutput

type RuleGroupRuleOption 

type RuleGroupRuleOption struct {
	Keyword  string   `pulumi:"keyword"`
	Settings []string `pulumi:"settings"`
}

type RuleGroupRuleOptionArgs 

type RuleGroupRuleOptionArgs struct {
	Keyword  pulumi.StringInput      `pulumi:"keyword"`
	Settings pulumi.StringArrayInput `pulumi:"settings"`
}

func (RuleGroupRuleOptionArgs) ElementType 

func (RuleGroupRuleOptionArgs) ElementType() reflect.Type

func (RuleGroupRuleOptionArgs) ToRuleGroupRuleOptionOutput 

func (i RuleGroupRuleOptionArgs) ToRuleGroupRuleOptionOutput() RuleGroupRuleOptionOutput

func (RuleGroupRuleOptionArgs) ToRuleGroupRuleOptionOutputWithContext 

func (i RuleGroupRuleOptionArgs) ToRuleGroupRuleOptionOutputWithContext(ctx context.Context) RuleGroupRuleOptionOutput

type RuleGroupRuleOptionArray 

type RuleGroupRuleOptionArray []RuleGroupRuleOptionInput

func (RuleGroupRuleOptionArray) ElementType 

func (RuleGroupRuleOptionArray) ElementType() reflect.Type

func (RuleGroupRuleOptionArray) ToRuleGroupRuleOptionArrayOutput 

func (i RuleGroupRuleOptionArray) ToRuleGroupRuleOptionArrayOutput() RuleGroupRuleOptionArrayOutput

func (RuleGroupRuleOptionArray) ToRuleGroupRuleOptionArrayOutputWithContext 

func (i RuleGroupRuleOptionArray) ToRuleGroupRuleOptionArrayOutputWithContext(ctx context.Context) RuleGroupRuleOptionArrayOutput

type RuleGroupRuleOptionArrayInput 

type RuleGroupRuleOptionArrayInput interface {
	pulumi.Input

	ToRuleGroupRuleOptionArrayOutput() RuleGroupRuleOptionArrayOutput
	ToRuleGroupRuleOptionArrayOutputWithContext(context.Context) RuleGroupRuleOptionArrayOutput
}

RuleGroupRuleOptionArrayInput is an input type that accepts RuleGroupRuleOptionArray and RuleGroupRuleOptionArrayOutput values. You can construct a concrete instance of `RuleGroupRuleOptionArrayInput` via: 

RuleGroupRuleOptionArray{ RuleGroupRuleOptionArgs{...} }

type RuleGroupRuleOptionArrayOutput 

type RuleGroupRuleOptionArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleOptionArrayOutput) ElementType 

func (RuleGroupRuleOptionArrayOutput) ElementType() reflect.Type

func (RuleGroupRuleOptionArrayOutput) Index 

func (o RuleGroupRuleOptionArrayOutput) Index(i pulumi.IntInput) RuleGroupRuleOptionOutput

func (RuleGroupRuleOptionArrayOutput) ToRuleGroupRuleOptionArrayOutput 

func (o RuleGroupRuleOptionArrayOutput) ToRuleGroupRuleOptionArrayOutput() RuleGroupRuleOptionArrayOutput

func (RuleGroupRuleOptionArrayOutput) ToRuleGroupRuleOptionArrayOutputWithContext 

func (o RuleGroupRuleOptionArrayOutput) ToRuleGroupRuleOptionArrayOutputWithContext(ctx context.Context) RuleGroupRuleOptionArrayOutput

type RuleGroupRuleOptionInput 

type RuleGroupRuleOptionInput interface {
	pulumi.Input

	ToRuleGroupRuleOptionOutput() RuleGroupRuleOptionOutput
	ToRuleGroupRuleOptionOutputWithContext(context.Context) RuleGroupRuleOptionOutput
}

RuleGroupRuleOptionInput is an input type that accepts RuleGroupRuleOptionArgs and RuleGroupRuleOptionOutput values. You can construct a concrete instance of `RuleGroupRuleOptionInput` via: 

RuleGroupRuleOptionArgs{...}

type RuleGroupRuleOptionOutput 

type RuleGroupRuleOptionOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleOptionOutput) ElementType 

func (RuleGroupRuleOptionOutput) ElementType() reflect.Type

func (RuleGroupRuleOptionOutput) Keyword 

func (o RuleGroupRuleOptionOutput) Keyword() pulumi.StringOutput

func (RuleGroupRuleOptionOutput) Settings 

func (o RuleGroupRuleOptionOutput) Settings() pulumi.StringArrayOutput

func (RuleGroupRuleOptionOutput) ToRuleGroupRuleOptionOutput 

func (o RuleGroupRuleOptionOutput) ToRuleGroupRuleOptionOutput() RuleGroupRuleOptionOutput

func (RuleGroupRuleOptionOutput) ToRuleGroupRuleOptionOutputWithContext 

func (o RuleGroupRuleOptionOutput) ToRuleGroupRuleOptionOutputWithContext(ctx context.Context) RuleGroupRuleOptionOutput

type RuleGroupRuleOrder added in v0.3.0 

type RuleGroupRuleOrder string

func (RuleGroupRuleOrder) ElementType added in v0.3.0 

func (RuleGroupRuleOrder) ElementType() reflect.Type

func (RuleGroupRuleOrder) ToRuleGroupRuleOrderOutput added in v0.3.0 

func (e RuleGroupRuleOrder) ToRuleGroupRuleOrderOutput() RuleGroupRuleOrderOutput

func (RuleGroupRuleOrder) ToRuleGroupRuleOrderOutputWithContext added in v0.3.0 

func (e RuleGroupRuleOrder) ToRuleGroupRuleOrderOutputWithContext(ctx context.Context) RuleGroupRuleOrderOutput

func (RuleGroupRuleOrder) ToRuleGroupRuleOrderPtrOutput added in v0.3.0 

func (e RuleGroupRuleOrder) ToRuleGroupRuleOrderPtrOutput() RuleGroupRuleOrderPtrOutput

func (RuleGroupRuleOrder) ToRuleGroupRuleOrderPtrOutputWithContext added in v0.3.0 

func (e RuleGroupRuleOrder) ToRuleGroupRuleOrderPtrOutputWithContext(ctx context.Context) RuleGroupRuleOrderPtrOutput

func (RuleGroupRuleOrder) ToStringOutput added in v0.3.0 

func (e RuleGroupRuleOrder) ToStringOutput() pulumi.StringOutput

func (RuleGroupRuleOrder) ToStringOutputWithContext added in v0.3.0 

func (e RuleGroupRuleOrder) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupRuleOrder) ToStringPtrOutput added in v0.3.0 

func (e RuleGroupRuleOrder) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupRuleOrder) ToStringPtrOutputWithContext added in v0.3.0 

func (e RuleGroupRuleOrder) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupRuleOrderInput added in v0.3.0 

type RuleGroupRuleOrderInput interface {
	pulumi.Input

	ToRuleGroupRuleOrderOutput() RuleGroupRuleOrderOutput
	ToRuleGroupRuleOrderOutputWithContext(context.Context) RuleGroupRuleOrderOutput
}

RuleGroupRuleOrderInput is an input type that accepts RuleGroupRuleOrderArgs and RuleGroupRuleOrderOutput values. You can construct a concrete instance of `RuleGroupRuleOrderInput` via: 

RuleGroupRuleOrderArgs{...}

type RuleGroupRuleOrderOutput added in v0.3.0 

type RuleGroupRuleOrderOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleOrderOutput) ElementType added in v0.3.0 

func (RuleGroupRuleOrderOutput) ElementType() reflect.Type

func (RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderOutput added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderOutput() RuleGroupRuleOrderOutput

func (RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderOutputWithContext added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderOutputWithContext(ctx context.Context) RuleGroupRuleOrderOutput

func (RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderPtrOutput added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderPtrOutput() RuleGroupRuleOrderPtrOutput

func (RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderPtrOutputWithContext added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToRuleGroupRuleOrderPtrOutputWithContext(ctx context.Context) RuleGroupRuleOrderPtrOutput

func (RuleGroupRuleOrderOutput) ToStringOutput added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupRuleOrderOutput) ToStringOutputWithContext added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupRuleOrderOutput) ToStringPtrOutput added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupRuleOrderOutput) ToStringPtrOutputWithContext added in v0.3.0 

func (o RuleGroupRuleOrderOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupRuleOrderPtrInput added in v0.3.0 

type RuleGroupRuleOrderPtrInput interface {
	pulumi.Input

	ToRuleGroupRuleOrderPtrOutput() RuleGroupRuleOrderPtrOutput
	ToRuleGroupRuleOrderPtrOutputWithContext(context.Context) RuleGroupRuleOrderPtrOutput
}

func RuleGroupRuleOrderPtr added in v0.3.0 

func RuleGroupRuleOrderPtr(v string) RuleGroupRuleOrderPtrInput

type RuleGroupRuleOrderPtrOutput added in v0.3.0 

type RuleGroupRuleOrderPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleOrderPtrOutput) Elem added in v0.3.0 

func (o RuleGroupRuleOrderPtrOutput) Elem() RuleGroupRuleOrderOutput

func (RuleGroupRuleOrderPtrOutput) ElementType added in v0.3.0 

func (RuleGroupRuleOrderPtrOutput) ElementType() reflect.Type

func (RuleGroupRuleOrderPtrOutput) ToRuleGroupRuleOrderPtrOutput added in v0.3.0 

func (o RuleGroupRuleOrderPtrOutput) ToRuleGroupRuleOrderPtrOutput() RuleGroupRuleOrderPtrOutput

func (RuleGroupRuleOrderPtrOutput) ToRuleGroupRuleOrderPtrOutputWithContext added in v0.3.0 

func (o RuleGroupRuleOrderPtrOutput) ToRuleGroupRuleOrderPtrOutputWithContext(ctx context.Context) RuleGroupRuleOrderPtrOutput

func (RuleGroupRuleOrderPtrOutput) ToStringPtrOutput added in v0.3.0 

func (o RuleGroupRuleOrderPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupRuleOrderPtrOutput) ToStringPtrOutputWithContext added in v0.3.0 

func (o RuleGroupRuleOrderPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupRuleVariables 

type RuleGroupRuleVariables struct {
	IPSets   interface{} `pulumi:"iPSets"`
	PortSets interface{} `pulumi:"portSets"`
}

type RuleGroupRuleVariablesArgs 

type RuleGroupRuleVariablesArgs struct {
	IPSets   pulumi.Input `pulumi:"iPSets"`
	PortSets pulumi.Input `pulumi:"portSets"`
}

func (RuleGroupRuleVariablesArgs) ElementType 

func (RuleGroupRuleVariablesArgs) ElementType() reflect.Type

func (RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesOutput 

func (i RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesOutput() RuleGroupRuleVariablesOutput

func (RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesOutputWithContext 

func (i RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesOutputWithContext(ctx context.Context) RuleGroupRuleVariablesOutput

func (RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesPtrOutput 

func (i RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesPtrOutput() RuleGroupRuleVariablesPtrOutput

func (RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesPtrOutputWithContext 

func (i RuleGroupRuleVariablesArgs) ToRuleGroupRuleVariablesPtrOutputWithContext(ctx context.Context) RuleGroupRuleVariablesPtrOutput

type RuleGroupRuleVariablesInput 

type RuleGroupRuleVariablesInput interface {
	pulumi.Input

	ToRuleGroupRuleVariablesOutput() RuleGroupRuleVariablesOutput
	ToRuleGroupRuleVariablesOutputWithContext(context.Context) RuleGroupRuleVariablesOutput
}

RuleGroupRuleVariablesInput is an input type that accepts RuleGroupRuleVariablesArgs and RuleGroupRuleVariablesOutput values. You can construct a concrete instance of `RuleGroupRuleVariablesInput` via: 

RuleGroupRuleVariablesArgs{...}

type RuleGroupRuleVariablesOutput 

type RuleGroupRuleVariablesOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleVariablesOutput) ElementType 

func (RuleGroupRuleVariablesOutput) ElementType() reflect.Type

func (RuleGroupRuleVariablesOutput) IPSets 

func (o RuleGroupRuleVariablesOutput) IPSets() pulumi.AnyOutput

func (RuleGroupRuleVariablesOutput) PortSets 

func (o RuleGroupRuleVariablesOutput) PortSets() pulumi.AnyOutput

func (RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesOutput 

func (o RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesOutput() RuleGroupRuleVariablesOutput

func (RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesOutputWithContext 

func (o RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesOutputWithContext(ctx context.Context) RuleGroupRuleVariablesOutput

func (RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesPtrOutput 

func (o RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesPtrOutput() RuleGroupRuleVariablesPtrOutput

func (RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesPtrOutputWithContext 

func (o RuleGroupRuleVariablesOutput) ToRuleGroupRuleVariablesPtrOutputWithContext(ctx context.Context) RuleGroupRuleVariablesPtrOutput

type RuleGroupRuleVariablesPtrInput 

type RuleGroupRuleVariablesPtrInput interface {
	pulumi.Input

	ToRuleGroupRuleVariablesPtrOutput() RuleGroupRuleVariablesPtrOutput
	ToRuleGroupRuleVariablesPtrOutputWithContext(context.Context) RuleGroupRuleVariablesPtrOutput
}

RuleGroupRuleVariablesPtrInput is an input type that accepts RuleGroupRuleVariablesArgs, RuleGroupRuleVariablesPtr and RuleGroupRuleVariablesPtrOutput values. You can construct a concrete instance of `RuleGroupRuleVariablesPtrInput` via: 

        RuleGroupRuleVariablesArgs{...}

or:

        nil

func RuleGroupRuleVariablesPtr 

func RuleGroupRuleVariablesPtr(v *RuleGroupRuleVariablesArgs) RuleGroupRuleVariablesPtrInput

type RuleGroupRuleVariablesPtrOutput 

type RuleGroupRuleVariablesPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupRuleVariablesPtrOutput) Elem 

func (o RuleGroupRuleVariablesPtrOutput) Elem() RuleGroupRuleVariablesOutput

func (RuleGroupRuleVariablesPtrOutput) ElementType 

func (RuleGroupRuleVariablesPtrOutput) ElementType() reflect.Type

func (RuleGroupRuleVariablesPtrOutput) IPSets 

func (o RuleGroupRuleVariablesPtrOutput) IPSets() pulumi.AnyOutput

func (RuleGroupRuleVariablesPtrOutput) PortSets 

func (o RuleGroupRuleVariablesPtrOutput) PortSets() pulumi.AnyOutput

func (RuleGroupRuleVariablesPtrOutput) ToRuleGroupRuleVariablesPtrOutput 

func (o RuleGroupRuleVariablesPtrOutput) ToRuleGroupRuleVariablesPtrOutput() RuleGroupRuleVariablesPtrOutput

func (RuleGroupRuleVariablesPtrOutput) ToRuleGroupRuleVariablesPtrOutputWithContext 

func (o RuleGroupRuleVariablesPtrOutput) ToRuleGroupRuleVariablesPtrOutputWithContext(ctx context.Context) RuleGroupRuleVariablesPtrOutput

type RuleGroupRulesSource 

type RuleGroupRulesSource struct {
	RulesSourceList                *RuleGroupRulesSourceList                `pulumi:"rulesSourceList"`
	RulesString                    *string                                  `pulumi:"rulesString"`
	StatefulRules                  []RuleGroupStatefulRule                  `pulumi:"statefulRules"`
	StatelessRulesAndCustomActions *RuleGroupStatelessRulesAndCustomActions `pulumi:"statelessRulesAndCustomActions"`
}

type RuleGroupRulesSourceArgs 

type RuleGroupRulesSourceArgs struct {
	RulesSourceList                RuleGroupRulesSourceListPtrInput                `pulumi:"rulesSourceList"`
	RulesString                    pulumi.StringPtrInput                           `pulumi:"rulesString"`
	StatefulRules                  RuleGroupStatefulRuleArrayInput                 `pulumi:"statefulRules"`
	StatelessRulesAndCustomActions RuleGroupStatelessRulesAndCustomActionsPtrInput `pulumi:"statelessRulesAndCustomActions"`
}

func (RuleGroupRulesSourceArgs) ElementType 

func (RuleGroupRulesSourceArgs) ElementType() reflect.Type

func (RuleGroupRulesSourceArgs) ToRuleGroupRulesSourceOutput 

func (i RuleGroupRulesSourceArgs) ToRuleGroupRulesSourceOutput() RuleGroupRulesSourceOutput

func (RuleGroupRulesSourceArgs) ToRuleGroupRulesSourceOutputWithContext 

func (i RuleGroupRulesSourceArgs) ToRuleGroupRulesSourceOutputWithContext(ctx context.Context) RuleGroupRulesSourceOutput

func (RuleGroupRulesSourceArgs) ToRuleGroupRulesSourcePtrOutput 

func (i RuleGroupRulesSourceArgs) ToRuleGroupRulesSourcePtrOutput() RuleGroupRulesSourcePtrOutput

func (RuleGroupRulesSourceArgs) ToRuleGroupRulesSourcePtrOutputWithContext 

func (i RuleGroupRulesSourceArgs) ToRuleGroupRulesSourcePtrOutputWithContext(ctx context.Context) RuleGroupRulesSourcePtrOutput

type RuleGroupRulesSourceInput 

type RuleGroupRulesSourceInput interface {
	pulumi.Input

	ToRuleGroupRulesSourceOutput() RuleGroupRulesSourceOutput
	ToRuleGroupRulesSourceOutputWithContext(context.Context) RuleGroupRulesSourceOutput
}

RuleGroupRulesSourceInput is an input type that accepts RuleGroupRulesSourceArgs and RuleGroupRulesSourceOutput values. You can construct a concrete instance of `RuleGroupRulesSourceInput` via: 

RuleGroupRulesSourceArgs{...}

type RuleGroupRulesSourceList 

type RuleGroupRulesSourceList struct {
	GeneratedRulesType RuleGroupGeneratedRulesType `pulumi:"generatedRulesType"`
	TargetTypes        []RuleGroupTargetType       `pulumi:"targetTypes"`
	Targets            []string                    `pulumi:"targets"`
}

type RuleGroupRulesSourceListArgs 

type RuleGroupRulesSourceListArgs struct {
	GeneratedRulesType RuleGroupGeneratedRulesTypeInput `pulumi:"generatedRulesType"`
	TargetTypes        RuleGroupTargetTypeArrayInput    `pulumi:"targetTypes"`
	Targets            pulumi.StringArrayInput          `pulumi:"targets"`
}

func (RuleGroupRulesSourceListArgs) ElementType 

func (RuleGroupRulesSourceListArgs) ElementType() reflect.Type

func (RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListOutput 

func (i RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListOutput() RuleGroupRulesSourceListOutput

func (RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListOutputWithContext 

func (i RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListOutputWithContext(ctx context.Context) RuleGroupRulesSourceListOutput

func (RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListPtrOutput 

func (i RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListPtrOutput() RuleGroupRulesSourceListPtrOutput

func (RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListPtrOutputWithContext 

func (i RuleGroupRulesSourceListArgs) ToRuleGroupRulesSourceListPtrOutputWithContext(ctx context.Context) RuleGroupRulesSourceListPtrOutput

type RuleGroupRulesSourceListInput 

type RuleGroupRulesSourceListInput interface {
	pulumi.Input

	ToRuleGroupRulesSourceListOutput() RuleGroupRulesSourceListOutput
	ToRuleGroupRulesSourceListOutputWithContext(context.Context) RuleGroupRulesSourceListOutput
}

RuleGroupRulesSourceListInput is an input type that accepts RuleGroupRulesSourceListArgs and RuleGroupRulesSourceListOutput values. You can construct a concrete instance of `RuleGroupRulesSourceListInput` via: 

RuleGroupRulesSourceListArgs{...}

type RuleGroupRulesSourceListOutput 

type RuleGroupRulesSourceListOutput struct{ *pulumi.OutputState }

func (RuleGroupRulesSourceListOutput) ElementType 

func (RuleGroupRulesSourceListOutput) ElementType() reflect.Type

func (RuleGroupRulesSourceListOutput) GeneratedRulesType 

func (o RuleGroupRulesSourceListOutput) GeneratedRulesType() RuleGroupGeneratedRulesTypeOutput

func (RuleGroupRulesSourceListOutput) TargetTypes 

func (o RuleGroupRulesSourceListOutput) TargetTypes() RuleGroupTargetTypeArrayOutput

func (RuleGroupRulesSourceListOutput) Targets 

func (o RuleGroupRulesSourceListOutput) Targets() pulumi.StringArrayOutput

func (RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListOutput 

func (o RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListOutput() RuleGroupRulesSourceListOutput

func (RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListOutputWithContext 

func (o RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListOutputWithContext(ctx context.Context) RuleGroupRulesSourceListOutput

func (RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListPtrOutput 

func (o RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListPtrOutput() RuleGroupRulesSourceListPtrOutput

func (RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListPtrOutputWithContext 

func (o RuleGroupRulesSourceListOutput) ToRuleGroupRulesSourceListPtrOutputWithContext(ctx context.Context) RuleGroupRulesSourceListPtrOutput

type RuleGroupRulesSourceListPtrInput 

type RuleGroupRulesSourceListPtrInput interface {
	pulumi.Input

	ToRuleGroupRulesSourceListPtrOutput() RuleGroupRulesSourceListPtrOutput
	ToRuleGroupRulesSourceListPtrOutputWithContext(context.Context) RuleGroupRulesSourceListPtrOutput
}

RuleGroupRulesSourceListPtrInput is an input type that accepts RuleGroupRulesSourceListArgs, RuleGroupRulesSourceListPtr and RuleGroupRulesSourceListPtrOutput values. You can construct a concrete instance of `RuleGroupRulesSourceListPtrInput` via: 

        RuleGroupRulesSourceListArgs{...}

or:

        nil

func RuleGroupRulesSourceListPtr 

func RuleGroupRulesSourceListPtr(v *RuleGroupRulesSourceListArgs) RuleGroupRulesSourceListPtrInput

type RuleGroupRulesSourceListPtrOutput 

type RuleGroupRulesSourceListPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupRulesSourceListPtrOutput) Elem 

func (o RuleGroupRulesSourceListPtrOutput) Elem() RuleGroupRulesSourceListOutput

func (RuleGroupRulesSourceListPtrOutput) ElementType 

func (RuleGroupRulesSourceListPtrOutput) ElementType() reflect.Type

func (RuleGroupRulesSourceListPtrOutput) GeneratedRulesType 

func (o RuleGroupRulesSourceListPtrOutput) GeneratedRulesType() RuleGroupGeneratedRulesTypePtrOutput

func (RuleGroupRulesSourceListPtrOutput) TargetTypes 

func (o RuleGroupRulesSourceListPtrOutput) TargetTypes() RuleGroupTargetTypeArrayOutput

func (RuleGroupRulesSourceListPtrOutput) Targets 

func (o RuleGroupRulesSourceListPtrOutput) Targets() pulumi.StringArrayOutput

func (RuleGroupRulesSourceListPtrOutput) ToRuleGroupRulesSourceListPtrOutput 

func (o RuleGroupRulesSourceListPtrOutput) ToRuleGroupRulesSourceListPtrOutput() RuleGroupRulesSourceListPtrOutput

func (RuleGroupRulesSourceListPtrOutput) ToRuleGroupRulesSourceListPtrOutputWithContext 

func (o RuleGroupRulesSourceListPtrOutput) ToRuleGroupRulesSourceListPtrOutputWithContext(ctx context.Context) RuleGroupRulesSourceListPtrOutput

type RuleGroupRulesSourceOutput 

type RuleGroupRulesSourceOutput struct{ *pulumi.OutputState }

func (RuleGroupRulesSourceOutput) ElementType 

func (RuleGroupRulesSourceOutput) ElementType() reflect.Type

func (RuleGroupRulesSourceOutput) RulesSourceList 

func (o RuleGroupRulesSourceOutput) RulesSourceList() RuleGroupRulesSourceListPtrOutput

func (RuleGroupRulesSourceOutput) RulesString 

func (o RuleGroupRulesSourceOutput) RulesString() pulumi.StringPtrOutput

func (RuleGroupRulesSourceOutput) StatefulRules 

func (o RuleGroupRulesSourceOutput) StatefulRules() RuleGroupStatefulRuleArrayOutput

func (RuleGroupRulesSourceOutput) StatelessRulesAndCustomActions 

func (o RuleGroupRulesSourceOutput) StatelessRulesAndCustomActions() RuleGroupStatelessRulesAndCustomActionsPtrOutput

func (RuleGroupRulesSourceOutput) ToRuleGroupRulesSourceOutput 

func (o RuleGroupRulesSourceOutput) ToRuleGroupRulesSourceOutput() RuleGroupRulesSourceOutput

func (RuleGroupRulesSourceOutput) ToRuleGroupRulesSourceOutputWithContext 

func (o RuleGroupRulesSourceOutput) ToRuleGroupRulesSourceOutputWithContext(ctx context.Context) RuleGroupRulesSourceOutput

func (RuleGroupRulesSourceOutput) ToRuleGroupRulesSourcePtrOutput 

func (o RuleGroupRulesSourceOutput) ToRuleGroupRulesSourcePtrOutput() RuleGroupRulesSourcePtrOutput

func (RuleGroupRulesSourceOutput) ToRuleGroupRulesSourcePtrOutputWithContext 

func (o RuleGroupRulesSourceOutput) ToRuleGroupRulesSourcePtrOutputWithContext(ctx context.Context) RuleGroupRulesSourcePtrOutput

type RuleGroupRulesSourcePtrInput 

type RuleGroupRulesSourcePtrInput interface {
	pulumi.Input

	ToRuleGroupRulesSourcePtrOutput() RuleGroupRulesSourcePtrOutput
	ToRuleGroupRulesSourcePtrOutputWithContext(context.Context) RuleGroupRulesSourcePtrOutput
}

RuleGroupRulesSourcePtrInput is an input type that accepts RuleGroupRulesSourceArgs, RuleGroupRulesSourcePtr and RuleGroupRulesSourcePtrOutput values. You can construct a concrete instance of `RuleGroupRulesSourcePtrInput` via: 

        RuleGroupRulesSourceArgs{...}

or:

        nil

func RuleGroupRulesSourcePtr 

func RuleGroupRulesSourcePtr(v *RuleGroupRulesSourceArgs) RuleGroupRulesSourcePtrInput

type RuleGroupRulesSourcePtrOutput 

type RuleGroupRulesSourcePtrOutput struct{ *pulumi.OutputState }

func (RuleGroupRulesSourcePtrOutput) Elem 

func (o RuleGroupRulesSourcePtrOutput) Elem() RuleGroupRulesSourceOutput

func (RuleGroupRulesSourcePtrOutput) ElementType 

func (RuleGroupRulesSourcePtrOutput) ElementType() reflect.Type

func (RuleGroupRulesSourcePtrOutput) RulesSourceList 

func (o RuleGroupRulesSourcePtrOutput) RulesSourceList() RuleGroupRulesSourceListPtrOutput

func (RuleGroupRulesSourcePtrOutput) RulesString 

func (o RuleGroupRulesSourcePtrOutput) RulesString() pulumi.StringPtrOutput

func (RuleGroupRulesSourcePtrOutput) StatefulRules 

func (o RuleGroupRulesSourcePtrOutput) StatefulRules() RuleGroupStatefulRuleArrayOutput

func (RuleGroupRulesSourcePtrOutput) StatelessRulesAndCustomActions 

func (o RuleGroupRulesSourcePtrOutput) StatelessRulesAndCustomActions() RuleGroupStatelessRulesAndCustomActionsPtrOutput

func (RuleGroupRulesSourcePtrOutput) ToRuleGroupRulesSourcePtrOutput 

func (o RuleGroupRulesSourcePtrOutput) ToRuleGroupRulesSourcePtrOutput() RuleGroupRulesSourcePtrOutput

func (RuleGroupRulesSourcePtrOutput) ToRuleGroupRulesSourcePtrOutputWithContext 

func (o RuleGroupRulesSourcePtrOutput) ToRuleGroupRulesSourcePtrOutputWithContext(ctx context.Context) RuleGroupRulesSourcePtrOutput

type RuleGroupState 

type RuleGroupState struct {
}

func (RuleGroupState) ElementType 

func (RuleGroupState) ElementType() reflect.Type

type RuleGroupStatefulRule 

type RuleGroupStatefulRule struct {
	Action      RuleGroupStatefulRuleAction `pulumi:"action"`
	Header      RuleGroupHeader             `pulumi:"header"`
	RuleOptions []RuleGroupRuleOption       `pulumi:"ruleOptions"`
}

type RuleGroupStatefulRuleAction 

type RuleGroupStatefulRuleAction string

func (RuleGroupStatefulRuleAction) ElementType 

func (RuleGroupStatefulRuleAction) ElementType() reflect.Type

func (RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionOutput 

func (e RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionOutput() RuleGroupStatefulRuleActionOutput

func (RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionOutputWithContext 

func (e RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionOutputWithContext(ctx context.Context) RuleGroupStatefulRuleActionOutput

func (RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionPtrOutput 

func (e RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionPtrOutput() RuleGroupStatefulRuleActionPtrOutput

func (RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionPtrOutputWithContext 

func (e RuleGroupStatefulRuleAction) ToRuleGroupStatefulRuleActionPtrOutputWithContext(ctx context.Context) RuleGroupStatefulRuleActionPtrOutput

func (RuleGroupStatefulRuleAction) ToStringOutput 

func (e RuleGroupStatefulRuleAction) ToStringOutput() pulumi.StringOutput

func (RuleGroupStatefulRuleAction) ToStringOutputWithContext 

func (e RuleGroupStatefulRuleAction) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupStatefulRuleAction) ToStringPtrOutput 

func (e RuleGroupStatefulRuleAction) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupStatefulRuleAction) ToStringPtrOutputWithContext 

func (e RuleGroupStatefulRuleAction) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupStatefulRuleActionInput 

type RuleGroupStatefulRuleActionInput interface {
	pulumi.Input

	ToRuleGroupStatefulRuleActionOutput() RuleGroupStatefulRuleActionOutput
	ToRuleGroupStatefulRuleActionOutputWithContext(context.Context) RuleGroupStatefulRuleActionOutput
}

RuleGroupStatefulRuleActionInput is an input type that accepts RuleGroupStatefulRuleActionArgs and RuleGroupStatefulRuleActionOutput values. You can construct a concrete instance of `RuleGroupStatefulRuleActionInput` via: 

RuleGroupStatefulRuleActionArgs{...}

type RuleGroupStatefulRuleActionOutput 

type RuleGroupStatefulRuleActionOutput struct{ *pulumi.OutputState }

func (RuleGroupStatefulRuleActionOutput) ElementType 

func (RuleGroupStatefulRuleActionOutput) ElementType() reflect.Type

func (RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionOutput 

func (o RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionOutput() RuleGroupStatefulRuleActionOutput

func (RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionOutputWithContext 

func (o RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionOutputWithContext(ctx context.Context) RuleGroupStatefulRuleActionOutput

func (RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionPtrOutput 

func (o RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionPtrOutput() RuleGroupStatefulRuleActionPtrOutput

func (RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionPtrOutputWithContext 

func (o RuleGroupStatefulRuleActionOutput) ToRuleGroupStatefulRuleActionPtrOutputWithContext(ctx context.Context) RuleGroupStatefulRuleActionPtrOutput

func (RuleGroupStatefulRuleActionOutput) ToStringOutput 

func (o RuleGroupStatefulRuleActionOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupStatefulRuleActionOutput) ToStringOutputWithContext 

func (o RuleGroupStatefulRuleActionOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupStatefulRuleActionOutput) ToStringPtrOutput 

func (o RuleGroupStatefulRuleActionOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupStatefulRuleActionOutput) ToStringPtrOutputWithContext 

func (o RuleGroupStatefulRuleActionOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupStatefulRuleActionPtrInput 

type RuleGroupStatefulRuleActionPtrInput interface {
	pulumi.Input

	ToRuleGroupStatefulRuleActionPtrOutput() RuleGroupStatefulRuleActionPtrOutput
	ToRuleGroupStatefulRuleActionPtrOutputWithContext(context.Context) RuleGroupStatefulRuleActionPtrOutput
}

func RuleGroupStatefulRuleActionPtr 

func RuleGroupStatefulRuleActionPtr(v string) RuleGroupStatefulRuleActionPtrInput

type RuleGroupStatefulRuleActionPtrOutput 

type RuleGroupStatefulRuleActionPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupStatefulRuleActionPtrOutput) Elem 

func (o RuleGroupStatefulRuleActionPtrOutput) Elem() RuleGroupStatefulRuleActionOutput

func (RuleGroupStatefulRuleActionPtrOutput) ElementType 

func (RuleGroupStatefulRuleActionPtrOutput) ElementType() reflect.Type

func (RuleGroupStatefulRuleActionPtrOutput) ToRuleGroupStatefulRuleActionPtrOutput 

func (o RuleGroupStatefulRuleActionPtrOutput) ToRuleGroupStatefulRuleActionPtrOutput() RuleGroupStatefulRuleActionPtrOutput

func (RuleGroupStatefulRuleActionPtrOutput) ToRuleGroupStatefulRuleActionPtrOutputWithContext 

func (o RuleGroupStatefulRuleActionPtrOutput) ToRuleGroupStatefulRuleActionPtrOutputWithContext(ctx context.Context) RuleGroupStatefulRuleActionPtrOutput

func (RuleGroupStatefulRuleActionPtrOutput) ToStringPtrOutput 

func (o RuleGroupStatefulRuleActionPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupStatefulRuleActionPtrOutput) ToStringPtrOutputWithContext 

func (o RuleGroupStatefulRuleActionPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupStatefulRuleArgs 

type RuleGroupStatefulRuleArgs struct {
	Action      RuleGroupStatefulRuleActionInput `pulumi:"action"`
	Header      RuleGroupHeaderInput             `pulumi:"header"`
	RuleOptions RuleGroupRuleOptionArrayInput    `pulumi:"ruleOptions"`
}

func (RuleGroupStatefulRuleArgs) ElementType 

func (RuleGroupStatefulRuleArgs) ElementType() reflect.Type

func (RuleGroupStatefulRuleArgs) ToRuleGroupStatefulRuleOutput 

func (i RuleGroupStatefulRuleArgs) ToRuleGroupStatefulRuleOutput() RuleGroupStatefulRuleOutput

func (RuleGroupStatefulRuleArgs) ToRuleGroupStatefulRuleOutputWithContext 

func (i RuleGroupStatefulRuleArgs) ToRuleGroupStatefulRuleOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOutput

type RuleGroupStatefulRuleArray 

type RuleGroupStatefulRuleArray []RuleGroupStatefulRuleInput

func (RuleGroupStatefulRuleArray) ElementType 

func (RuleGroupStatefulRuleArray) ElementType() reflect.Type

func (RuleGroupStatefulRuleArray) ToRuleGroupStatefulRuleArrayOutput 

func (i RuleGroupStatefulRuleArray) ToRuleGroupStatefulRuleArrayOutput() RuleGroupStatefulRuleArrayOutput

func (RuleGroupStatefulRuleArray) ToRuleGroupStatefulRuleArrayOutputWithContext 

func (i RuleGroupStatefulRuleArray) ToRuleGroupStatefulRuleArrayOutputWithContext(ctx context.Context) RuleGroupStatefulRuleArrayOutput

type RuleGroupStatefulRuleArrayInput 

type RuleGroupStatefulRuleArrayInput interface {
	pulumi.Input

	ToRuleGroupStatefulRuleArrayOutput() RuleGroupStatefulRuleArrayOutput
	ToRuleGroupStatefulRuleArrayOutputWithContext(context.Context) RuleGroupStatefulRuleArrayOutput
}

RuleGroupStatefulRuleArrayInput is an input type that accepts RuleGroupStatefulRuleArray and RuleGroupStatefulRuleArrayOutput values. You can construct a concrete instance of `RuleGroupStatefulRuleArrayInput` via: 

RuleGroupStatefulRuleArray{ RuleGroupStatefulRuleArgs{...} }

type RuleGroupStatefulRuleArrayOutput 

type RuleGroupStatefulRuleArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupStatefulRuleArrayOutput) ElementType 

func (RuleGroupStatefulRuleArrayOutput) ElementType() reflect.Type

func (RuleGroupStatefulRuleArrayOutput) Index 

func (o RuleGroupStatefulRuleArrayOutput) Index(i pulumi.IntInput) RuleGroupStatefulRuleOutput

func (RuleGroupStatefulRuleArrayOutput) ToRuleGroupStatefulRuleArrayOutput 

func (o RuleGroupStatefulRuleArrayOutput) ToRuleGroupStatefulRuleArrayOutput() RuleGroupStatefulRuleArrayOutput

func (RuleGroupStatefulRuleArrayOutput) ToRuleGroupStatefulRuleArrayOutputWithContext 

func (o RuleGroupStatefulRuleArrayOutput) ToRuleGroupStatefulRuleArrayOutputWithContext(ctx context.Context) RuleGroupStatefulRuleArrayOutput

type RuleGroupStatefulRuleInput 

type RuleGroupStatefulRuleInput interface {
	pulumi.Input

	ToRuleGroupStatefulRuleOutput() RuleGroupStatefulRuleOutput
	ToRuleGroupStatefulRuleOutputWithContext(context.Context) RuleGroupStatefulRuleOutput
}

RuleGroupStatefulRuleInput is an input type that accepts RuleGroupStatefulRuleArgs and RuleGroupStatefulRuleOutput values. You can construct a concrete instance of `RuleGroupStatefulRuleInput` via: 

RuleGroupStatefulRuleArgs{...}

type RuleGroupStatefulRuleOptions added in v0.3.0 

type RuleGroupStatefulRuleOptions struct {
	RuleOrder *RuleGroupRuleOrder `pulumi:"ruleOrder"`
}

type RuleGroupStatefulRuleOptionsArgs added in v0.3.0 

type RuleGroupStatefulRuleOptionsArgs struct {
	RuleOrder RuleGroupRuleOrderPtrInput `pulumi:"ruleOrder"`
}

func (RuleGroupStatefulRuleOptionsArgs) ElementType added in v0.3.0 

func (RuleGroupStatefulRuleOptionsArgs) ElementType() reflect.Type

func (RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsOutput added in v0.3.0 

func (i RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsOutput() RuleGroupStatefulRuleOptionsOutput

func (RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsOutputWithContext added in v0.3.0 

func (i RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOptionsOutput

func (RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsPtrOutput added in v0.3.0 

func (i RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsPtrOutput() RuleGroupStatefulRuleOptionsPtrOutput

func (RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsPtrOutputWithContext added in v0.3.0 

func (i RuleGroupStatefulRuleOptionsArgs) ToRuleGroupStatefulRuleOptionsPtrOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOptionsPtrOutput

type RuleGroupStatefulRuleOptionsInput added in v0.3.0 

type RuleGroupStatefulRuleOptionsInput interface {
	pulumi.Input

	ToRuleGroupStatefulRuleOptionsOutput() RuleGroupStatefulRuleOptionsOutput
	ToRuleGroupStatefulRuleOptionsOutputWithContext(context.Context) RuleGroupStatefulRuleOptionsOutput
}

RuleGroupStatefulRuleOptionsInput is an input type that accepts RuleGroupStatefulRuleOptionsArgs and RuleGroupStatefulRuleOptionsOutput values. You can construct a concrete instance of `RuleGroupStatefulRuleOptionsInput` via: 

RuleGroupStatefulRuleOptionsArgs{...}

type RuleGroupStatefulRuleOptionsOutput added in v0.3.0 

type RuleGroupStatefulRuleOptionsOutput struct{ *pulumi.OutputState }

func (RuleGroupStatefulRuleOptionsOutput) ElementType added in v0.3.0 

func (RuleGroupStatefulRuleOptionsOutput) ElementType() reflect.Type

func (RuleGroupStatefulRuleOptionsOutput) RuleOrder added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsOutput) RuleOrder() RuleGroupRuleOrderPtrOutput

func (RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsOutput added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsOutput() RuleGroupStatefulRuleOptionsOutput

func (RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsOutputWithContext added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOptionsOutput

func (RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsPtrOutput added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsPtrOutput() RuleGroupStatefulRuleOptionsPtrOutput

func (RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsPtrOutputWithContext added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsOutput) ToRuleGroupStatefulRuleOptionsPtrOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOptionsPtrOutput

type RuleGroupStatefulRuleOptionsPtrInput added in v0.3.0 

type RuleGroupStatefulRuleOptionsPtrInput interface {
	pulumi.Input

	ToRuleGroupStatefulRuleOptionsPtrOutput() RuleGroupStatefulRuleOptionsPtrOutput
	ToRuleGroupStatefulRuleOptionsPtrOutputWithContext(context.Context) RuleGroupStatefulRuleOptionsPtrOutput
}

RuleGroupStatefulRuleOptionsPtrInput is an input type that accepts RuleGroupStatefulRuleOptionsArgs, RuleGroupStatefulRuleOptionsPtr and RuleGroupStatefulRuleOptionsPtrOutput values. You can construct a concrete instance of `RuleGroupStatefulRuleOptionsPtrInput` via: 

        RuleGroupStatefulRuleOptionsArgs{...}

or:

        nil

func RuleGroupStatefulRuleOptionsPtr added in v0.3.0 

func RuleGroupStatefulRuleOptionsPtr(v *RuleGroupStatefulRuleOptionsArgs) RuleGroupStatefulRuleOptionsPtrInput

type RuleGroupStatefulRuleOptionsPtrOutput added in v0.3.0 

type RuleGroupStatefulRuleOptionsPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupStatefulRuleOptionsPtrOutput) Elem added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsPtrOutput) Elem() RuleGroupStatefulRuleOptionsOutput

func (RuleGroupStatefulRuleOptionsPtrOutput) ElementType added in v0.3.0 

func (RuleGroupStatefulRuleOptionsPtrOutput) ElementType() reflect.Type

func (RuleGroupStatefulRuleOptionsPtrOutput) RuleOrder added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsPtrOutput) RuleOrder() RuleGroupRuleOrderPtrOutput

func (RuleGroupStatefulRuleOptionsPtrOutput) ToRuleGroupStatefulRuleOptionsPtrOutput added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsPtrOutput) ToRuleGroupStatefulRuleOptionsPtrOutput() RuleGroupStatefulRuleOptionsPtrOutput

func (RuleGroupStatefulRuleOptionsPtrOutput) ToRuleGroupStatefulRuleOptionsPtrOutputWithContext added in v0.3.0 

func (o RuleGroupStatefulRuleOptionsPtrOutput) ToRuleGroupStatefulRuleOptionsPtrOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOptionsPtrOutput

type RuleGroupStatefulRuleOutput 

type RuleGroupStatefulRuleOutput struct{ *pulumi.OutputState }

func (RuleGroupStatefulRuleOutput) Action 

func (o RuleGroupStatefulRuleOutput) Action() RuleGroupStatefulRuleActionOutput

func (RuleGroupStatefulRuleOutput) ElementType 

func (RuleGroupStatefulRuleOutput) ElementType() reflect.Type

func (RuleGroupStatefulRuleOutput) Header 

func (o RuleGroupStatefulRuleOutput) Header() RuleGroupHeaderOutput

func (RuleGroupStatefulRuleOutput) RuleOptions 

func (o RuleGroupStatefulRuleOutput) RuleOptions() RuleGroupRuleOptionArrayOutput

func (RuleGroupStatefulRuleOutput) ToRuleGroupStatefulRuleOutput 

func (o RuleGroupStatefulRuleOutput) ToRuleGroupStatefulRuleOutput() RuleGroupStatefulRuleOutput

func (RuleGroupStatefulRuleOutput) ToRuleGroupStatefulRuleOutputWithContext 

func (o RuleGroupStatefulRuleOutput) ToRuleGroupStatefulRuleOutputWithContext(ctx context.Context) RuleGroupStatefulRuleOutput

type RuleGroupStatelessRule 

type RuleGroupStatelessRule struct {
	Priority       int                     `pulumi:"priority"`
	RuleDefinition RuleGroupRuleDefinition `pulumi:"ruleDefinition"`
}

type RuleGroupStatelessRuleArgs 

type RuleGroupStatelessRuleArgs struct {
	Priority       pulumi.IntInput              `pulumi:"priority"`
	RuleDefinition RuleGroupRuleDefinitionInput `pulumi:"ruleDefinition"`
}

func (RuleGroupStatelessRuleArgs) ElementType 

func (RuleGroupStatelessRuleArgs) ElementType() reflect.Type

func (RuleGroupStatelessRuleArgs) ToRuleGroupStatelessRuleOutput 

func (i RuleGroupStatelessRuleArgs) ToRuleGroupStatelessRuleOutput() RuleGroupStatelessRuleOutput

func (RuleGroupStatelessRuleArgs) ToRuleGroupStatelessRuleOutputWithContext 

func (i RuleGroupStatelessRuleArgs) ToRuleGroupStatelessRuleOutputWithContext(ctx context.Context) RuleGroupStatelessRuleOutput

type RuleGroupStatelessRuleArray 

type RuleGroupStatelessRuleArray []RuleGroupStatelessRuleInput

func (RuleGroupStatelessRuleArray) ElementType 

func (RuleGroupStatelessRuleArray) ElementType() reflect.Type

func (RuleGroupStatelessRuleArray) ToRuleGroupStatelessRuleArrayOutput 

func (i RuleGroupStatelessRuleArray) ToRuleGroupStatelessRuleArrayOutput() RuleGroupStatelessRuleArrayOutput

func (RuleGroupStatelessRuleArray) ToRuleGroupStatelessRuleArrayOutputWithContext 

func (i RuleGroupStatelessRuleArray) ToRuleGroupStatelessRuleArrayOutputWithContext(ctx context.Context) RuleGroupStatelessRuleArrayOutput

type RuleGroupStatelessRuleArrayInput 

type RuleGroupStatelessRuleArrayInput interface {
	pulumi.Input

	ToRuleGroupStatelessRuleArrayOutput() RuleGroupStatelessRuleArrayOutput
	ToRuleGroupStatelessRuleArrayOutputWithContext(context.Context) RuleGroupStatelessRuleArrayOutput
}

RuleGroupStatelessRuleArrayInput is an input type that accepts RuleGroupStatelessRuleArray and RuleGroupStatelessRuleArrayOutput values. You can construct a concrete instance of `RuleGroupStatelessRuleArrayInput` via: 

RuleGroupStatelessRuleArray{ RuleGroupStatelessRuleArgs{...} }

type RuleGroupStatelessRuleArrayOutput 

type RuleGroupStatelessRuleArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupStatelessRuleArrayOutput) ElementType 

func (RuleGroupStatelessRuleArrayOutput) ElementType() reflect.Type

func (RuleGroupStatelessRuleArrayOutput) Index 

func (o RuleGroupStatelessRuleArrayOutput) Index(i pulumi.IntInput) RuleGroupStatelessRuleOutput

func (RuleGroupStatelessRuleArrayOutput) ToRuleGroupStatelessRuleArrayOutput 

func (o RuleGroupStatelessRuleArrayOutput) ToRuleGroupStatelessRuleArrayOutput() RuleGroupStatelessRuleArrayOutput

func (RuleGroupStatelessRuleArrayOutput) ToRuleGroupStatelessRuleArrayOutputWithContext 

func (o RuleGroupStatelessRuleArrayOutput) ToRuleGroupStatelessRuleArrayOutputWithContext(ctx context.Context) RuleGroupStatelessRuleArrayOutput

type RuleGroupStatelessRuleInput 

type RuleGroupStatelessRuleInput interface {
	pulumi.Input

	ToRuleGroupStatelessRuleOutput() RuleGroupStatelessRuleOutput
	ToRuleGroupStatelessRuleOutputWithContext(context.Context) RuleGroupStatelessRuleOutput
}

RuleGroupStatelessRuleInput is an input type that accepts RuleGroupStatelessRuleArgs and RuleGroupStatelessRuleOutput values. You can construct a concrete instance of `RuleGroupStatelessRuleInput` via: 

RuleGroupStatelessRuleArgs{...}

type RuleGroupStatelessRuleOutput 

type RuleGroupStatelessRuleOutput struct{ *pulumi.OutputState }

func (RuleGroupStatelessRuleOutput) ElementType 

func (RuleGroupStatelessRuleOutput) ElementType() reflect.Type

func (RuleGroupStatelessRuleOutput) Priority 

func (o RuleGroupStatelessRuleOutput) Priority() pulumi.IntOutput

func (RuleGroupStatelessRuleOutput) RuleDefinition 

func (o RuleGroupStatelessRuleOutput) RuleDefinition() RuleGroupRuleDefinitionOutput

func (RuleGroupStatelessRuleOutput) ToRuleGroupStatelessRuleOutput 

func (o RuleGroupStatelessRuleOutput) ToRuleGroupStatelessRuleOutput() RuleGroupStatelessRuleOutput

func (RuleGroupStatelessRuleOutput) ToRuleGroupStatelessRuleOutputWithContext 

func (o RuleGroupStatelessRuleOutput) ToRuleGroupStatelessRuleOutputWithContext(ctx context.Context) RuleGroupStatelessRuleOutput

type RuleGroupStatelessRulesAndCustomActions 

type RuleGroupStatelessRulesAndCustomActions struct {
	CustomActions  []RuleGroupCustomAction  `pulumi:"customActions"`
	StatelessRules []RuleGroupStatelessRule `pulumi:"statelessRules"`
}

type RuleGroupStatelessRulesAndCustomActionsArgs 

type RuleGroupStatelessRulesAndCustomActionsArgs struct {
	CustomActions  RuleGroupCustomActionArrayInput  `pulumi:"customActions"`
	StatelessRules RuleGroupStatelessRuleArrayInput `pulumi:"statelessRules"`
}

func (RuleGroupStatelessRulesAndCustomActionsArgs) ElementType 

func (RuleGroupStatelessRulesAndCustomActionsArgs) ElementType() reflect.Type

func (RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsOutput 

func (i RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsOutput() RuleGroupStatelessRulesAndCustomActionsOutput

func (RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsOutputWithContext 

func (i RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsOutputWithContext(ctx context.Context) RuleGroupStatelessRulesAndCustomActionsOutput

func (RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsPtrOutput 

func (i RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsPtrOutput() RuleGroupStatelessRulesAndCustomActionsPtrOutput

func (RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext 

func (i RuleGroupStatelessRulesAndCustomActionsArgs) ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext(ctx context.Context) RuleGroupStatelessRulesAndCustomActionsPtrOutput

type RuleGroupStatelessRulesAndCustomActionsInput 

type RuleGroupStatelessRulesAndCustomActionsInput interface {
	pulumi.Input

	ToRuleGroupStatelessRulesAndCustomActionsOutput() RuleGroupStatelessRulesAndCustomActionsOutput
	ToRuleGroupStatelessRulesAndCustomActionsOutputWithContext(context.Context) RuleGroupStatelessRulesAndCustomActionsOutput
}

RuleGroupStatelessRulesAndCustomActionsInput is an input type that accepts RuleGroupStatelessRulesAndCustomActionsArgs and RuleGroupStatelessRulesAndCustomActionsOutput values. You can construct a concrete instance of `RuleGroupStatelessRulesAndCustomActionsInput` via: 

RuleGroupStatelessRulesAndCustomActionsArgs{...}

type RuleGroupStatelessRulesAndCustomActionsOutput 

type RuleGroupStatelessRulesAndCustomActionsOutput struct{ *pulumi.OutputState }

func (RuleGroupStatelessRulesAndCustomActionsOutput) CustomActions 

func (o RuleGroupStatelessRulesAndCustomActionsOutput) CustomActions() RuleGroupCustomActionArrayOutput

func (RuleGroupStatelessRulesAndCustomActionsOutput) ElementType 

func (RuleGroupStatelessRulesAndCustomActionsOutput) ElementType() reflect.Type

func (RuleGroupStatelessRulesAndCustomActionsOutput) StatelessRules 

func (o RuleGroupStatelessRulesAndCustomActionsOutput) StatelessRules() RuleGroupStatelessRuleArrayOutput

func (RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsOutput 

func (o RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsOutput() RuleGroupStatelessRulesAndCustomActionsOutput

func (RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsOutputWithContext 

func (o RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsOutputWithContext(ctx context.Context) RuleGroupStatelessRulesAndCustomActionsOutput

func (RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutput 

func (o RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutput() RuleGroupStatelessRulesAndCustomActionsPtrOutput

func (RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext 

func (o RuleGroupStatelessRulesAndCustomActionsOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext(ctx context.Context) RuleGroupStatelessRulesAndCustomActionsPtrOutput

type RuleGroupStatelessRulesAndCustomActionsPtrInput 

type RuleGroupStatelessRulesAndCustomActionsPtrInput interface {
	pulumi.Input

	ToRuleGroupStatelessRulesAndCustomActionsPtrOutput() RuleGroupStatelessRulesAndCustomActionsPtrOutput
	ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext(context.Context) RuleGroupStatelessRulesAndCustomActionsPtrOutput
}

RuleGroupStatelessRulesAndCustomActionsPtrInput is an input type that accepts RuleGroupStatelessRulesAndCustomActionsArgs, RuleGroupStatelessRulesAndCustomActionsPtr and RuleGroupStatelessRulesAndCustomActionsPtrOutput values. You can construct a concrete instance of `RuleGroupStatelessRulesAndCustomActionsPtrInput` via: 

        RuleGroupStatelessRulesAndCustomActionsArgs{...}

or:

        nil

func RuleGroupStatelessRulesAndCustomActionsPtr 

func RuleGroupStatelessRulesAndCustomActionsPtr(v *RuleGroupStatelessRulesAndCustomActionsArgs) RuleGroupStatelessRulesAndCustomActionsPtrInput

type RuleGroupStatelessRulesAndCustomActionsPtrOutput 

type RuleGroupStatelessRulesAndCustomActionsPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) CustomActions 

func (o RuleGroupStatelessRulesAndCustomActionsPtrOutput) CustomActions() RuleGroupCustomActionArrayOutput

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) Elem 

func (o RuleGroupStatelessRulesAndCustomActionsPtrOutput) Elem() RuleGroupStatelessRulesAndCustomActionsOutput

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) ElementType 

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) ElementType() reflect.Type

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) StatelessRules 

func (o RuleGroupStatelessRulesAndCustomActionsPtrOutput) StatelessRules() RuleGroupStatelessRuleArrayOutput

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutput 

func (o RuleGroupStatelessRulesAndCustomActionsPtrOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutput() RuleGroupStatelessRulesAndCustomActionsPtrOutput

func (RuleGroupStatelessRulesAndCustomActionsPtrOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext 

func (o RuleGroupStatelessRulesAndCustomActionsPtrOutput) ToRuleGroupStatelessRulesAndCustomActionsPtrOutputWithContext(ctx context.Context) RuleGroupStatelessRulesAndCustomActionsPtrOutput

type RuleGroupTCPFlag 

type RuleGroupTCPFlag string

func (RuleGroupTCPFlag) ElementType 

func (RuleGroupTCPFlag) ElementType() reflect.Type

func (RuleGroupTCPFlag) ToRuleGroupTCPFlagOutput 

func (e RuleGroupTCPFlag) ToRuleGroupTCPFlagOutput() RuleGroupTCPFlagOutput

func (RuleGroupTCPFlag) ToRuleGroupTCPFlagOutputWithContext 

func (e RuleGroupTCPFlag) ToRuleGroupTCPFlagOutputWithContext(ctx context.Context) RuleGroupTCPFlagOutput

func (RuleGroupTCPFlag) ToRuleGroupTCPFlagPtrOutput 

func (e RuleGroupTCPFlag) ToRuleGroupTCPFlagPtrOutput() RuleGroupTCPFlagPtrOutput

func (RuleGroupTCPFlag) ToRuleGroupTCPFlagPtrOutputWithContext 

func (e RuleGroupTCPFlag) ToRuleGroupTCPFlagPtrOutputWithContext(ctx context.Context) RuleGroupTCPFlagPtrOutput

func (RuleGroupTCPFlag) ToStringOutput 

func (e RuleGroupTCPFlag) ToStringOutput() pulumi.StringOutput

func (RuleGroupTCPFlag) ToStringOutputWithContext 

func (e RuleGroupTCPFlag) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupTCPFlag) ToStringPtrOutput 

func (e RuleGroupTCPFlag) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTCPFlag) ToStringPtrOutputWithContext 

func (e RuleGroupTCPFlag) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTCPFlagArray 

type RuleGroupTCPFlagArray []RuleGroupTCPFlag

func (RuleGroupTCPFlagArray) ElementType 

func (RuleGroupTCPFlagArray) ElementType() reflect.Type

func (RuleGroupTCPFlagArray) ToRuleGroupTCPFlagArrayOutput 

func (i RuleGroupTCPFlagArray) ToRuleGroupTCPFlagArrayOutput() RuleGroupTCPFlagArrayOutput

func (RuleGroupTCPFlagArray) ToRuleGroupTCPFlagArrayOutputWithContext 

func (i RuleGroupTCPFlagArray) ToRuleGroupTCPFlagArrayOutputWithContext(ctx context.Context) RuleGroupTCPFlagArrayOutput

type RuleGroupTCPFlagArrayInput 

type RuleGroupTCPFlagArrayInput interface {
	pulumi.Input

	ToRuleGroupTCPFlagArrayOutput() RuleGroupTCPFlagArrayOutput
	ToRuleGroupTCPFlagArrayOutputWithContext(context.Context) RuleGroupTCPFlagArrayOutput
}

RuleGroupTCPFlagArrayInput is an input type that accepts RuleGroupTCPFlagArray and RuleGroupTCPFlagArrayOutput values. You can construct a concrete instance of `RuleGroupTCPFlagArrayInput` via: 

RuleGroupTCPFlagArray{ RuleGroupTCPFlagArgs{...} }

type RuleGroupTCPFlagArrayOutput 

type RuleGroupTCPFlagArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupTCPFlagArrayOutput) ElementType 

func (RuleGroupTCPFlagArrayOutput) ElementType() reflect.Type

func (RuleGroupTCPFlagArrayOutput) Index 

func (o RuleGroupTCPFlagArrayOutput) Index(i pulumi.IntInput) RuleGroupTCPFlagOutput

func (RuleGroupTCPFlagArrayOutput) ToRuleGroupTCPFlagArrayOutput 

func (o RuleGroupTCPFlagArrayOutput) ToRuleGroupTCPFlagArrayOutput() RuleGroupTCPFlagArrayOutput

func (RuleGroupTCPFlagArrayOutput) ToRuleGroupTCPFlagArrayOutputWithContext 

func (o RuleGroupTCPFlagArrayOutput) ToRuleGroupTCPFlagArrayOutputWithContext(ctx context.Context) RuleGroupTCPFlagArrayOutput

type RuleGroupTCPFlagField 

type RuleGroupTCPFlagField struct {
	Flags []RuleGroupTCPFlag `pulumi:"flags"`
	Masks []RuleGroupTCPFlag `pulumi:"masks"`
}

type RuleGroupTCPFlagFieldArgs 

type RuleGroupTCPFlagFieldArgs struct {
	Flags RuleGroupTCPFlagArrayInput `pulumi:"flags"`
	Masks RuleGroupTCPFlagArrayInput `pulumi:"masks"`
}

func (RuleGroupTCPFlagFieldArgs) ElementType 

func (RuleGroupTCPFlagFieldArgs) ElementType() reflect.Type

func (RuleGroupTCPFlagFieldArgs) ToRuleGroupTCPFlagFieldOutput 

func (i RuleGroupTCPFlagFieldArgs) ToRuleGroupTCPFlagFieldOutput() RuleGroupTCPFlagFieldOutput

func (RuleGroupTCPFlagFieldArgs) ToRuleGroupTCPFlagFieldOutputWithContext 

func (i RuleGroupTCPFlagFieldArgs) ToRuleGroupTCPFlagFieldOutputWithContext(ctx context.Context) RuleGroupTCPFlagFieldOutput

type RuleGroupTCPFlagFieldArray 

type RuleGroupTCPFlagFieldArray []RuleGroupTCPFlagFieldInput

func (RuleGroupTCPFlagFieldArray) ElementType 

func (RuleGroupTCPFlagFieldArray) ElementType() reflect.Type

func (RuleGroupTCPFlagFieldArray) ToRuleGroupTCPFlagFieldArrayOutput 

func (i RuleGroupTCPFlagFieldArray) ToRuleGroupTCPFlagFieldArrayOutput() RuleGroupTCPFlagFieldArrayOutput

func (RuleGroupTCPFlagFieldArray) ToRuleGroupTCPFlagFieldArrayOutputWithContext 

func (i RuleGroupTCPFlagFieldArray) ToRuleGroupTCPFlagFieldArrayOutputWithContext(ctx context.Context) RuleGroupTCPFlagFieldArrayOutput

type RuleGroupTCPFlagFieldArrayInput 

type RuleGroupTCPFlagFieldArrayInput interface {
	pulumi.Input

	ToRuleGroupTCPFlagFieldArrayOutput() RuleGroupTCPFlagFieldArrayOutput
	ToRuleGroupTCPFlagFieldArrayOutputWithContext(context.Context) RuleGroupTCPFlagFieldArrayOutput
}

RuleGroupTCPFlagFieldArrayInput is an input type that accepts RuleGroupTCPFlagFieldArray and RuleGroupTCPFlagFieldArrayOutput values. You can construct a concrete instance of `RuleGroupTCPFlagFieldArrayInput` via: 

RuleGroupTCPFlagFieldArray{ RuleGroupTCPFlagFieldArgs{...} }

type RuleGroupTCPFlagFieldArrayOutput 

type RuleGroupTCPFlagFieldArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupTCPFlagFieldArrayOutput) ElementType 

func (RuleGroupTCPFlagFieldArrayOutput) ElementType() reflect.Type

func (RuleGroupTCPFlagFieldArrayOutput) Index 

func (o RuleGroupTCPFlagFieldArrayOutput) Index(i pulumi.IntInput) RuleGroupTCPFlagFieldOutput

func (RuleGroupTCPFlagFieldArrayOutput) ToRuleGroupTCPFlagFieldArrayOutput 

func (o RuleGroupTCPFlagFieldArrayOutput) ToRuleGroupTCPFlagFieldArrayOutput() RuleGroupTCPFlagFieldArrayOutput

func (RuleGroupTCPFlagFieldArrayOutput) ToRuleGroupTCPFlagFieldArrayOutputWithContext 

func (o RuleGroupTCPFlagFieldArrayOutput) ToRuleGroupTCPFlagFieldArrayOutputWithContext(ctx context.Context) RuleGroupTCPFlagFieldArrayOutput

type RuleGroupTCPFlagFieldInput 

type RuleGroupTCPFlagFieldInput interface {
	pulumi.Input

	ToRuleGroupTCPFlagFieldOutput() RuleGroupTCPFlagFieldOutput
	ToRuleGroupTCPFlagFieldOutputWithContext(context.Context) RuleGroupTCPFlagFieldOutput
}

RuleGroupTCPFlagFieldInput is an input type that accepts RuleGroupTCPFlagFieldArgs and RuleGroupTCPFlagFieldOutput values. You can construct a concrete instance of `RuleGroupTCPFlagFieldInput` via: 

RuleGroupTCPFlagFieldArgs{...}

type RuleGroupTCPFlagFieldOutput 

type RuleGroupTCPFlagFieldOutput struct{ *pulumi.OutputState }

func (RuleGroupTCPFlagFieldOutput) ElementType 

func (RuleGroupTCPFlagFieldOutput) ElementType() reflect.Type

func (RuleGroupTCPFlagFieldOutput) Flags 

func (o RuleGroupTCPFlagFieldOutput) Flags() RuleGroupTCPFlagArrayOutput

func (RuleGroupTCPFlagFieldOutput) Masks 

func (o RuleGroupTCPFlagFieldOutput) Masks() RuleGroupTCPFlagArrayOutput

func (RuleGroupTCPFlagFieldOutput) ToRuleGroupTCPFlagFieldOutput 

func (o RuleGroupTCPFlagFieldOutput) ToRuleGroupTCPFlagFieldOutput() RuleGroupTCPFlagFieldOutput

func (RuleGroupTCPFlagFieldOutput) ToRuleGroupTCPFlagFieldOutputWithContext 

func (o RuleGroupTCPFlagFieldOutput) ToRuleGroupTCPFlagFieldOutputWithContext(ctx context.Context) RuleGroupTCPFlagFieldOutput

type RuleGroupTCPFlagInput 

type RuleGroupTCPFlagInput interface {
	pulumi.Input

	ToRuleGroupTCPFlagOutput() RuleGroupTCPFlagOutput
	ToRuleGroupTCPFlagOutputWithContext(context.Context) RuleGroupTCPFlagOutput
}

RuleGroupTCPFlagInput is an input type that accepts RuleGroupTCPFlagArgs and RuleGroupTCPFlagOutput values. You can construct a concrete instance of `RuleGroupTCPFlagInput` via: 

RuleGroupTCPFlagArgs{...}

type RuleGroupTCPFlagOutput 

type RuleGroupTCPFlagOutput struct{ *pulumi.OutputState }

func (RuleGroupTCPFlagOutput) ElementType 

func (RuleGroupTCPFlagOutput) ElementType() reflect.Type

func (RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagOutput 

func (o RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagOutput() RuleGroupTCPFlagOutput

func (RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagOutputWithContext 

func (o RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagOutputWithContext(ctx context.Context) RuleGroupTCPFlagOutput

func (RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagPtrOutput 

func (o RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagPtrOutput() RuleGroupTCPFlagPtrOutput

func (RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagPtrOutputWithContext 

func (o RuleGroupTCPFlagOutput) ToRuleGroupTCPFlagPtrOutputWithContext(ctx context.Context) RuleGroupTCPFlagPtrOutput

func (RuleGroupTCPFlagOutput) ToStringOutput 

func (o RuleGroupTCPFlagOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupTCPFlagOutput) ToStringOutputWithContext 

func (o RuleGroupTCPFlagOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupTCPFlagOutput) ToStringPtrOutput 

func (o RuleGroupTCPFlagOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTCPFlagOutput) ToStringPtrOutputWithContext 

func (o RuleGroupTCPFlagOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTCPFlagPtrInput 

type RuleGroupTCPFlagPtrInput interface {
	pulumi.Input

	ToRuleGroupTCPFlagPtrOutput() RuleGroupTCPFlagPtrOutput
	ToRuleGroupTCPFlagPtrOutputWithContext(context.Context) RuleGroupTCPFlagPtrOutput
}

func RuleGroupTCPFlagPtr 

func RuleGroupTCPFlagPtr(v string) RuleGroupTCPFlagPtrInput

type RuleGroupTCPFlagPtrOutput 

type RuleGroupTCPFlagPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupTCPFlagPtrOutput) Elem 

func (o RuleGroupTCPFlagPtrOutput) Elem() RuleGroupTCPFlagOutput

func (RuleGroupTCPFlagPtrOutput) ElementType 

func (RuleGroupTCPFlagPtrOutput) ElementType() reflect.Type

func (RuleGroupTCPFlagPtrOutput) ToRuleGroupTCPFlagPtrOutput 

func (o RuleGroupTCPFlagPtrOutput) ToRuleGroupTCPFlagPtrOutput() RuleGroupTCPFlagPtrOutput

func (RuleGroupTCPFlagPtrOutput) ToRuleGroupTCPFlagPtrOutputWithContext 

func (o RuleGroupTCPFlagPtrOutput) ToRuleGroupTCPFlagPtrOutputWithContext(ctx context.Context) RuleGroupTCPFlagPtrOutput

func (RuleGroupTCPFlagPtrOutput) ToStringPtrOutput 

func (o RuleGroupTCPFlagPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTCPFlagPtrOutput) ToStringPtrOutputWithContext 

func (o RuleGroupTCPFlagPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTag 

type RuleGroupTag struct {
	Key   string `pulumi:"key"`
	Value string `pulumi:"value"`
}

type RuleGroupTagArgs 

type RuleGroupTagArgs struct {
	Key   pulumi.StringInput `pulumi:"key"`
	Value pulumi.StringInput `pulumi:"value"`
}

func (RuleGroupTagArgs) ElementType 

func (RuleGroupTagArgs) ElementType() reflect.Type

func (RuleGroupTagArgs) ToRuleGroupTagOutput 

func (i RuleGroupTagArgs) ToRuleGroupTagOutput() RuleGroupTagOutput

func (RuleGroupTagArgs) ToRuleGroupTagOutputWithContext 

func (i RuleGroupTagArgs) ToRuleGroupTagOutputWithContext(ctx context.Context) RuleGroupTagOutput

type RuleGroupTagArray 

type RuleGroupTagArray []RuleGroupTagInput

func (RuleGroupTagArray) ElementType 

func (RuleGroupTagArray) ElementType() reflect.Type

func (RuleGroupTagArray) ToRuleGroupTagArrayOutput 

func (i RuleGroupTagArray) ToRuleGroupTagArrayOutput() RuleGroupTagArrayOutput

func (RuleGroupTagArray) ToRuleGroupTagArrayOutputWithContext 

func (i RuleGroupTagArray) ToRuleGroupTagArrayOutputWithContext(ctx context.Context) RuleGroupTagArrayOutput

type RuleGroupTagArrayInput 

type RuleGroupTagArrayInput interface {
	pulumi.Input

	ToRuleGroupTagArrayOutput() RuleGroupTagArrayOutput
	ToRuleGroupTagArrayOutputWithContext(context.Context) RuleGroupTagArrayOutput
}

RuleGroupTagArrayInput is an input type that accepts RuleGroupTagArray and RuleGroupTagArrayOutput values. You can construct a concrete instance of `RuleGroupTagArrayInput` via: 

RuleGroupTagArray{ RuleGroupTagArgs{...} }

type RuleGroupTagArrayOutput 

type RuleGroupTagArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupTagArrayOutput) ElementType 

func (RuleGroupTagArrayOutput) ElementType() reflect.Type

func (RuleGroupTagArrayOutput) Index 

func (o RuleGroupTagArrayOutput) Index(i pulumi.IntInput) RuleGroupTagOutput

func (RuleGroupTagArrayOutput) ToRuleGroupTagArrayOutput 

func (o RuleGroupTagArrayOutput) ToRuleGroupTagArrayOutput() RuleGroupTagArrayOutput

func (RuleGroupTagArrayOutput) ToRuleGroupTagArrayOutputWithContext 

func (o RuleGroupTagArrayOutput) ToRuleGroupTagArrayOutputWithContext(ctx context.Context) RuleGroupTagArrayOutput

type RuleGroupTagInput 

type RuleGroupTagInput interface {
	pulumi.Input

	ToRuleGroupTagOutput() RuleGroupTagOutput
	ToRuleGroupTagOutputWithContext(context.Context) RuleGroupTagOutput
}

RuleGroupTagInput is an input type that accepts RuleGroupTagArgs and RuleGroupTagOutput values. You can construct a concrete instance of `RuleGroupTagInput` via: 

RuleGroupTagArgs{...}

type RuleGroupTagOutput 

type RuleGroupTagOutput struct{ *pulumi.OutputState }

func (RuleGroupTagOutput) ElementType 

func (RuleGroupTagOutput) ElementType() reflect.Type

func (RuleGroupTagOutput) Key 

func (o RuleGroupTagOutput) Key() pulumi.StringOutput

func (RuleGroupTagOutput) ToRuleGroupTagOutput 

func (o RuleGroupTagOutput) ToRuleGroupTagOutput() RuleGroupTagOutput

func (RuleGroupTagOutput) ToRuleGroupTagOutputWithContext 

func (o RuleGroupTagOutput) ToRuleGroupTagOutputWithContext(ctx context.Context) RuleGroupTagOutput

func (RuleGroupTagOutput) Value 

func (o RuleGroupTagOutput) Value() pulumi.StringOutput

type RuleGroupTargetType 

type RuleGroupTargetType string

func (RuleGroupTargetType) ElementType 

func (RuleGroupTargetType) ElementType() reflect.Type

func (RuleGroupTargetType) ToRuleGroupTargetTypeOutput 

func (e RuleGroupTargetType) ToRuleGroupTargetTypeOutput() RuleGroupTargetTypeOutput

func (RuleGroupTargetType) ToRuleGroupTargetTypeOutputWithContext 

func (e RuleGroupTargetType) ToRuleGroupTargetTypeOutputWithContext(ctx context.Context) RuleGroupTargetTypeOutput

func (RuleGroupTargetType) ToRuleGroupTargetTypePtrOutput 

func (e RuleGroupTargetType) ToRuleGroupTargetTypePtrOutput() RuleGroupTargetTypePtrOutput

func (RuleGroupTargetType) ToRuleGroupTargetTypePtrOutputWithContext 

func (e RuleGroupTargetType) ToRuleGroupTargetTypePtrOutputWithContext(ctx context.Context) RuleGroupTargetTypePtrOutput

func (RuleGroupTargetType) ToStringOutput 

func (e RuleGroupTargetType) ToStringOutput() pulumi.StringOutput

func (RuleGroupTargetType) ToStringOutputWithContext 

func (e RuleGroupTargetType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupTargetType) ToStringPtrOutput 

func (e RuleGroupTargetType) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTargetType) ToStringPtrOutputWithContext 

func (e RuleGroupTargetType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTargetTypeArray 

type RuleGroupTargetTypeArray []RuleGroupTargetType

func (RuleGroupTargetTypeArray) ElementType 

func (RuleGroupTargetTypeArray) ElementType() reflect.Type

func (RuleGroupTargetTypeArray) ToRuleGroupTargetTypeArrayOutput 

func (i RuleGroupTargetTypeArray) ToRuleGroupTargetTypeArrayOutput() RuleGroupTargetTypeArrayOutput

func (RuleGroupTargetTypeArray) ToRuleGroupTargetTypeArrayOutputWithContext 

func (i RuleGroupTargetTypeArray) ToRuleGroupTargetTypeArrayOutputWithContext(ctx context.Context) RuleGroupTargetTypeArrayOutput

type RuleGroupTargetTypeArrayInput 

type RuleGroupTargetTypeArrayInput interface {
	pulumi.Input

	ToRuleGroupTargetTypeArrayOutput() RuleGroupTargetTypeArrayOutput
	ToRuleGroupTargetTypeArrayOutputWithContext(context.Context) RuleGroupTargetTypeArrayOutput
}

RuleGroupTargetTypeArrayInput is an input type that accepts RuleGroupTargetTypeArray and RuleGroupTargetTypeArrayOutput values. You can construct a concrete instance of `RuleGroupTargetTypeArrayInput` via: 

RuleGroupTargetTypeArray{ RuleGroupTargetTypeArgs{...} }

type RuleGroupTargetTypeArrayOutput 

type RuleGroupTargetTypeArrayOutput struct{ *pulumi.OutputState }

func (RuleGroupTargetTypeArrayOutput) ElementType 

func (RuleGroupTargetTypeArrayOutput) ElementType() reflect.Type

func (RuleGroupTargetTypeArrayOutput) Index 

func (o RuleGroupTargetTypeArrayOutput) Index(i pulumi.IntInput) RuleGroupTargetTypeOutput

func (RuleGroupTargetTypeArrayOutput) ToRuleGroupTargetTypeArrayOutput 

func (o RuleGroupTargetTypeArrayOutput) ToRuleGroupTargetTypeArrayOutput() RuleGroupTargetTypeArrayOutput

func (RuleGroupTargetTypeArrayOutput) ToRuleGroupTargetTypeArrayOutputWithContext 

func (o RuleGroupTargetTypeArrayOutput) ToRuleGroupTargetTypeArrayOutputWithContext(ctx context.Context) RuleGroupTargetTypeArrayOutput

type RuleGroupTargetTypeInput 

type RuleGroupTargetTypeInput interface {
	pulumi.Input

	ToRuleGroupTargetTypeOutput() RuleGroupTargetTypeOutput
	ToRuleGroupTargetTypeOutputWithContext(context.Context) RuleGroupTargetTypeOutput
}

RuleGroupTargetTypeInput is an input type that accepts RuleGroupTargetTypeArgs and RuleGroupTargetTypeOutput values. You can construct a concrete instance of `RuleGroupTargetTypeInput` via: 

RuleGroupTargetTypeArgs{...}

type RuleGroupTargetTypeOutput 

type RuleGroupTargetTypeOutput struct{ *pulumi.OutputState }

func (RuleGroupTargetTypeOutput) ElementType 

func (RuleGroupTargetTypeOutput) ElementType() reflect.Type

func (RuleGroupTargetTypeOutput) ToRuleGroupTargetTypeOutput 

func (o RuleGroupTargetTypeOutput) ToRuleGroupTargetTypeOutput() RuleGroupTargetTypeOutput

func (RuleGroupTargetTypeOutput) ToRuleGroupTargetTypeOutputWithContext 

func (o RuleGroupTargetTypeOutput) ToRuleGroupTargetTypeOutputWithContext(ctx context.Context) RuleGroupTargetTypeOutput

func (RuleGroupTargetTypeOutput) ToRuleGroupTargetTypePtrOutput 

func (o RuleGroupTargetTypeOutput) ToRuleGroupTargetTypePtrOutput() RuleGroupTargetTypePtrOutput

func (RuleGroupTargetTypeOutput) ToRuleGroupTargetTypePtrOutputWithContext 

func (o RuleGroupTargetTypeOutput) ToRuleGroupTargetTypePtrOutputWithContext(ctx context.Context) RuleGroupTargetTypePtrOutput

func (RuleGroupTargetTypeOutput) ToStringOutput 

func (o RuleGroupTargetTypeOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupTargetTypeOutput) ToStringOutputWithContext 

func (o RuleGroupTargetTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupTargetTypeOutput) ToStringPtrOutput 

func (o RuleGroupTargetTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTargetTypeOutput) ToStringPtrOutputWithContext 

func (o RuleGroupTargetTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTargetTypePtrInput 

type RuleGroupTargetTypePtrInput interface {
	pulumi.Input

	ToRuleGroupTargetTypePtrOutput() RuleGroupTargetTypePtrOutput
	ToRuleGroupTargetTypePtrOutputWithContext(context.Context) RuleGroupTargetTypePtrOutput
}

func RuleGroupTargetTypePtr 

func RuleGroupTargetTypePtr(v string) RuleGroupTargetTypePtrInput

type RuleGroupTargetTypePtrOutput 

type RuleGroupTargetTypePtrOutput struct{ *pulumi.OutputState }

func (RuleGroupTargetTypePtrOutput) Elem 

func (o RuleGroupTargetTypePtrOutput) Elem() RuleGroupTargetTypeOutput

func (RuleGroupTargetTypePtrOutput) ElementType 

func (RuleGroupTargetTypePtrOutput) ElementType() reflect.Type

func (RuleGroupTargetTypePtrOutput) ToRuleGroupTargetTypePtrOutput 

func (o RuleGroupTargetTypePtrOutput) ToRuleGroupTargetTypePtrOutput() RuleGroupTargetTypePtrOutput

func (RuleGroupTargetTypePtrOutput) ToRuleGroupTargetTypePtrOutputWithContext 

func (o RuleGroupTargetTypePtrOutput) ToRuleGroupTargetTypePtrOutputWithContext(ctx context.Context) RuleGroupTargetTypePtrOutput

func (RuleGroupTargetTypePtrOutput) ToStringPtrOutput 

func (o RuleGroupTargetTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTargetTypePtrOutput) ToStringPtrOutputWithContext 

func (o RuleGroupTargetTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupType 

type RuleGroupType struct {
	RuleVariables       *RuleGroupRuleVariables       `pulumi:"ruleVariables"`
	RulesSource         RuleGroupRulesSource          `pulumi:"rulesSource"`
	StatefulRuleOptions *RuleGroupStatefulRuleOptions `pulumi:"statefulRuleOptions"`
}

type RuleGroupTypeArgs added in v0.2.0 

type RuleGroupTypeArgs struct {
	RuleVariables       RuleGroupRuleVariablesPtrInput       `pulumi:"ruleVariables"`
	RulesSource         RuleGroupRulesSourceInput            `pulumi:"rulesSource"`
	StatefulRuleOptions RuleGroupStatefulRuleOptionsPtrInput `pulumi:"statefulRuleOptions"`
}

func (RuleGroupTypeArgs) ElementType added in v0.2.0 

func (RuleGroupTypeArgs) ElementType() reflect.Type

func (RuleGroupTypeArgs) ToRuleGroupTypeOutput added in v0.2.0 

func (i RuleGroupTypeArgs) ToRuleGroupTypeOutput() RuleGroupTypeOutput

func (RuleGroupTypeArgs) ToRuleGroupTypeOutputWithContext added in v0.2.0 

func (i RuleGroupTypeArgs) ToRuleGroupTypeOutputWithContext(ctx context.Context) RuleGroupTypeOutput

func (RuleGroupTypeArgs) ToRuleGroupTypePtrOutput added in v0.2.0 

func (i RuleGroupTypeArgs) ToRuleGroupTypePtrOutput() RuleGroupTypePtrOutput

func (RuleGroupTypeArgs) ToRuleGroupTypePtrOutputWithContext added in v0.2.0 

func (i RuleGroupTypeArgs) ToRuleGroupTypePtrOutputWithContext(ctx context.Context) RuleGroupTypePtrOutput

type RuleGroupTypeEnum added in v0.2.0 

type RuleGroupTypeEnum string

func (RuleGroupTypeEnum) ElementType added in v0.2.0 

func (RuleGroupTypeEnum) ElementType() reflect.Type

func (RuleGroupTypeEnum) ToRuleGroupTypeEnumOutput added in v0.2.0 

func (e RuleGroupTypeEnum) ToRuleGroupTypeEnumOutput() RuleGroupTypeEnumOutput

func (RuleGroupTypeEnum) ToRuleGroupTypeEnumOutputWithContext added in v0.2.0 

func (e RuleGroupTypeEnum) ToRuleGroupTypeEnumOutputWithContext(ctx context.Context) RuleGroupTypeEnumOutput

func (RuleGroupTypeEnum) ToRuleGroupTypeEnumPtrOutput added in v0.2.0 

func (e RuleGroupTypeEnum) ToRuleGroupTypeEnumPtrOutput() RuleGroupTypeEnumPtrOutput

func (RuleGroupTypeEnum) ToRuleGroupTypeEnumPtrOutputWithContext added in v0.2.0 

func (e RuleGroupTypeEnum) ToRuleGroupTypeEnumPtrOutputWithContext(ctx context.Context) RuleGroupTypeEnumPtrOutput

func (RuleGroupTypeEnum) ToStringOutput added in v0.2.0 

func (e RuleGroupTypeEnum) ToStringOutput() pulumi.StringOutput

func (RuleGroupTypeEnum) ToStringOutputWithContext added in v0.2.0 

func (e RuleGroupTypeEnum) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupTypeEnum) ToStringPtrOutput added in v0.2.0 

func (e RuleGroupTypeEnum) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTypeEnum) ToStringPtrOutputWithContext added in v0.2.0 

func (e RuleGroupTypeEnum) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTypeEnumInput added in v0.2.0 

type RuleGroupTypeEnumInput interface {
	pulumi.Input

	ToRuleGroupTypeEnumOutput() RuleGroupTypeEnumOutput
	ToRuleGroupTypeEnumOutputWithContext(context.Context) RuleGroupTypeEnumOutput
}

RuleGroupTypeEnumInput is an input type that accepts RuleGroupTypeEnumArgs and RuleGroupTypeEnumOutput values. You can construct a concrete instance of `RuleGroupTypeEnumInput` via: 

RuleGroupTypeEnumArgs{...}

type RuleGroupTypeEnumOutput added in v0.2.0 

type RuleGroupTypeEnumOutput struct{ *pulumi.OutputState }

func (RuleGroupTypeEnumOutput) ElementType added in v0.2.0 

func (RuleGroupTypeEnumOutput) ElementType() reflect.Type

func (RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumOutput added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumOutput() RuleGroupTypeEnumOutput

func (RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumOutputWithContext added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumOutputWithContext(ctx context.Context) RuleGroupTypeEnumOutput

func (RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumPtrOutput added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumPtrOutput() RuleGroupTypeEnumPtrOutput

func (RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumPtrOutputWithContext added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToRuleGroupTypeEnumPtrOutputWithContext(ctx context.Context) RuleGroupTypeEnumPtrOutput

func (RuleGroupTypeEnumOutput) ToStringOutput added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToStringOutput() pulumi.StringOutput

func (RuleGroupTypeEnumOutput) ToStringOutputWithContext added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RuleGroupTypeEnumOutput) ToStringPtrOutput added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTypeEnumOutput) ToStringPtrOutputWithContext added in v0.2.0 

func (o RuleGroupTypeEnumOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTypeEnumPtrInput added in v0.2.0 

type RuleGroupTypeEnumPtrInput interface {
	pulumi.Input

	ToRuleGroupTypeEnumPtrOutput() RuleGroupTypeEnumPtrOutput
	ToRuleGroupTypeEnumPtrOutputWithContext(context.Context) RuleGroupTypeEnumPtrOutput
}

func RuleGroupTypeEnumPtr added in v0.2.0 

func RuleGroupTypeEnumPtr(v string) RuleGroupTypeEnumPtrInput

type RuleGroupTypeEnumPtrOutput added in v0.2.0 

type RuleGroupTypeEnumPtrOutput struct{ *pulumi.OutputState }

func (RuleGroupTypeEnumPtrOutput) Elem added in v0.2.0 

func (o RuleGroupTypeEnumPtrOutput) Elem() RuleGroupTypeEnumOutput

func (RuleGroupTypeEnumPtrOutput) ElementType added in v0.2.0 

func (RuleGroupTypeEnumPtrOutput) ElementType() reflect.Type

func (RuleGroupTypeEnumPtrOutput) ToRuleGroupTypeEnumPtrOutput added in v0.2.0 

func (o RuleGroupTypeEnumPtrOutput) ToRuleGroupTypeEnumPtrOutput() RuleGroupTypeEnumPtrOutput

func (RuleGroupTypeEnumPtrOutput) ToRuleGroupTypeEnumPtrOutputWithContext added in v0.2.0 

func (o RuleGroupTypeEnumPtrOutput) ToRuleGroupTypeEnumPtrOutputWithContext(ctx context.Context) RuleGroupTypeEnumPtrOutput

func (RuleGroupTypeEnumPtrOutput) ToStringPtrOutput added in v0.2.0 

func (o RuleGroupTypeEnumPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RuleGroupTypeEnumPtrOutput) ToStringPtrOutputWithContext added in v0.2.0 

func (o RuleGroupTypeEnumPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RuleGroupTypeInput 

type RuleGroupTypeInput interface {
	pulumi.Input

	ToRuleGroupTypeOutput() RuleGroupTypeOutput
	ToRuleGroupTypeOutputWithContext(context.Context) RuleGroupTypeOutput
}

RuleGroupTypeInput is an input type that accepts RuleGroupTypeArgs and RuleGroupTypeOutput values. You can construct a concrete instance of `RuleGroupTypeInput` via: 

RuleGroupTypeArgs{...}

type RuleGroupTypeOutput 

type RuleGroupTypeOutput struct{ *pulumi.OutputState }

func (RuleGroupTypeOutput) ElementType 

func (RuleGroupTypeOutput) ElementType() reflect.Type

func (RuleGroupTypeOutput) RuleVariables added in v0.2.0 

func (o RuleGroupTypeOutput) RuleVariables() RuleGroupRuleVariablesPtrOutput

func (RuleGroupTypeOutput) RulesSource added in v0.2.0 

func (o RuleGroupTypeOutput) RulesSource() RuleGroupRulesSourceOutput

func (RuleGroupTypeOutput) StatefulRuleOptions added in v0.3.0 

func (o RuleGroupTypeOutput) StatefulRuleOptions() RuleGroupStatefulRuleOptionsPtrOutput

func (RuleGroupTypeOutput) ToRuleGroupTypeOutput 

func (o RuleGroupTypeOutput) ToRuleGroupTypeOutput() RuleGroupTypeOutput

func (RuleGroupTypeOutput) ToRuleGroupTypeOutputWithContext 

func (o RuleGroupTypeOutput) ToRuleGroupTypeOutputWithContext(ctx context.Context) RuleGroupTypeOutput

func (RuleGroupTypeOutput) ToRuleGroupTypePtrOutput 

func (o RuleGroupTypeOutput) ToRuleGroupTypePtrOutput() RuleGroupTypePtrOutput

func (RuleGroupTypeOutput) ToRuleGroupTypePtrOutputWithContext 

func (o RuleGroupTypeOutput) ToRuleGroupTypePtrOutputWithContext(ctx context.Context) RuleGroupTypePtrOutput

type RuleGroupTypePtrInput 

type RuleGroupTypePtrInput interface {
	pulumi.Input

	ToRuleGroupTypePtrOutput() RuleGroupTypePtrOutput
	ToRuleGroupTypePtrOutputWithContext(context.Context) RuleGroupTypePtrOutput
}

RuleGroupTypePtrInput is an input type that accepts RuleGroupTypeArgs, RuleGroupTypePtr and RuleGroupTypePtrOutput values. You can construct a concrete instance of `RuleGroupTypePtrInput` via: 

        RuleGroupTypeArgs{...}

or:

        nil

func RuleGroupTypePtr 

func RuleGroupTypePtr(v *RuleGroupTypeArgs) RuleGroupTypePtrInput

type RuleGroupTypePtrOutput 

type RuleGroupTypePtrOutput struct{ *pulumi.OutputState }

func (RuleGroupTypePtrOutput) Elem 

func (o RuleGroupTypePtrOutput) Elem() RuleGroupTypeOutput

func (RuleGroupTypePtrOutput) ElementType 

func (RuleGroupTypePtrOutput) ElementType() reflect.Type

func (RuleGroupTypePtrOutput) RuleVariables added in v0.2.0 

func (o RuleGroupTypePtrOutput) RuleVariables() RuleGroupRuleVariablesPtrOutput

func (RuleGroupTypePtrOutput) RulesSource added in v0.2.0 

func (o RuleGroupTypePtrOutput) RulesSource() RuleGroupRulesSourcePtrOutput

func (RuleGroupTypePtrOutput) StatefulRuleOptions added in v0.3.0 

func (o RuleGroupTypePtrOutput) StatefulRuleOptions() RuleGroupStatefulRuleOptionsPtrOutput

func (RuleGroupTypePtrOutput) ToRuleGroupTypePtrOutput 

func (o RuleGroupTypePtrOutput) ToRuleGroupTypePtrOutput() RuleGroupTypePtrOutput

func (RuleGroupTypePtrOutput) ToRuleGroupTypePtrOutputWithContext 

func (o RuleGroupTypePtrOutput) ToRuleGroupTypePtrOutputWithContext(ctx context.Context) RuleGroupTypePtrOutput

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.