1. Packages
  2. Strata Cloud Manager Provider
  3. API Docs
  4. VulnerabilityProtectionSignature
Strata Cloud Manager v1.0.3 published on Thursday, Jan 22, 2026 by Pulumi
scm logo
Strata Cloud Manager v1.0.3 published on Thursday, Jan 22, 2026 by Pulumi

    VulnerabilityProtectionSignature resource

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as scm from "@pulumi/scm";
    
    const scmVpSignature1 = new scm.VulnerabilityProtectionSignature("scm_vp_signature_1", {
        folder: "Shared",
        threatId: "41010",
        threatname: "scm_vp_signature_1",
        severity: "informational",
        direction: "client2server",
        affectedHost: {
            client: true,
        },
        signature: {
            standards: [
                {
                    name: "basic-signature",
                },
                {
                    name: "standard-signature-one",
                    scope: "protocol-data-unit",
                    orderFree: false,
                    andCondition: [{
                        name: "condition-A-or",
                        orCondition: [{
                            name: "pattern-A1",
                            operator: {
                                lessThan: {
                                    context: "telnet-req-client-data",
                                    value: "123",
                                },
                            },
                        }],
                    }],
                },
                {
                    name: "standard-signature-two",
                    scope: "session",
                    orderFree: true,
                    andCondition: [
                        {
                            name: "condition-B-or",
                            orCondition: [
                                {
                                    name: "pattern-B1",
                                    operator: {
                                        greaterThan: {
                                            context: "cip-ethernet-ip-req-class-id",
                                            value: "111111",
                                            qualifier: [
                                                {
                                                    name: "Q1",
                                                    value: "123",
                                                },
                                                {
                                                    name: "Q2",
                                                    value: "920",
                                                },
                                            ],
                                        },
                                    },
                                },
                                {
                                    name: "pattern-B2",
                                    operator: {
                                        equalTo: {
                                            context: "icmp-rsp-type",
                                            value: "222222",
                                            qualifier: [{
                                                name: "Q3",
                                                value: "567",
                                            }],
                                        },
                                    },
                                },
                            ],
                        },
                        {
                            name: "condition-C-or",
                            orCondition: [{
                                name: "pattern-C1",
                                operator: {
                                    patternMatch: {
                                        context: "ntlm-req-auth-v1",
                                        value: "1200",
                                    },
                                },
                            }],
                        },
                    ],
                },
            ],
        },
    });
    const scmVpSignature2 = new scm.VulnerabilityProtectionSignature("scm_vp_signature_2", {
        folder: "Shared",
        threatId: "41040",
        threatname: "scm_vp_sig_2",
        affectedHost: {
            server: true,
        },
        comment: "basic-combo-signature",
        severity: "high",
        direction: "both",
        defaultAction: {
            alert: {},
        },
        signature: {
            combination: {
                name: "combo-sig",
                orderFree: true,
                andConditions: [{
                    name: "condition-C-or",
                    orCondition: [{
                        name: "pattern-C1",
                        threatId: 10030,
                    }],
                }],
                timeAttribute: {
                    interval: 3600,
                    threshold: 5,
                    trackBy: "source-and-destination",
                },
            },
        },
    });
    const scmVpSignature3 = new scm.VulnerabilityProtectionSignature("scm_vp_signature_3", {
        folder: "Shared",
        threatId: "41030",
        threatname: "scm_vp_sig_3",
        affectedHost: {
            server: true,
        },
        bugtraqs: ["12345"],
        comment: "combo-signatures",
        cves: ["CVE-2025-9999"],
        references: ["https://example.com/exploit-details"],
        severity: "medium",
        direction: "server2client",
        vendors: ["Custom"],
        defaultAction: {
            drop: {},
        },
        signature: {
            combination: {
                name: "combo-signature-one",
                orderFree: false,
                andConditions: [
                    {
                        name: "condition-A-or",
                        orCondition: [{
                            name: "pattern-A1",
                            threatId: 10001,
                        }],
                    },
                    {
                        name: "condition-B-or",
                        orCondition: [
                            {
                                name: "pattern-B1",
                                threatId: 10043,
                            },
                            {
                                name: "pattern-B2",
                                threatId: 10025,
                            },
                            {
                                name: "pattern-B3",
                                threatId: 10050,
                            },
                        ],
                    },
                    {
                        name: "condition-C-or",
                        orCondition: [{
                            name: "pattern-C1",
                            threatId: 10030,
                        }],
                    },
                ],
                timeAttribute: {
                    interval: 3600,
                    threshold: 20,
                    trackBy: "source",
                },
            },
        },
    });
    
    import pulumi
    import pulumi_scm as scm
    
    scm_vp_signature1 = scm.VulnerabilityProtectionSignature("scm_vp_signature_1",
        folder="Shared",
        threat_id="41010",
        threatname="scm_vp_signature_1",
        severity="informational",
        direction="client2server",
        affected_host={
            "client": True,
        },
        signature={
            "standards": [
                {
                    "name": "basic-signature",
                },
                {
                    "name": "standard-signature-one",
                    "scope": "protocol-data-unit",
                    "order_free": False,
                    "and_condition": [{
                        "name": "condition-A-or",
                        "orCondition": [{
                            "name": "pattern-A1",
                            "operator": {
                                "lessThan": {
                                    "context": "telnet-req-client-data",
                                    "value": "123",
                                },
                            },
                        }],
                    }],
                },
                {
                    "name": "standard-signature-two",
                    "scope": "session",
                    "order_free": True,
                    "and_condition": [
                        {
                            "name": "condition-B-or",
                            "orCondition": [
                                {
                                    "name": "pattern-B1",
                                    "operator": {
                                        "greaterThan": {
                                            "context": "cip-ethernet-ip-req-class-id",
                                            "value": "111111",
                                            "qualifier": [
                                                {
                                                    "name": "Q1",
                                                    "value": "123",
                                                },
                                                {
                                                    "name": "Q2",
                                                    "value": "920",
                                                },
                                            ],
                                        },
                                    },
                                },
                                {
                                    "name": "pattern-B2",
                                    "operator": {
                                        "equalTo": {
                                            "context": "icmp-rsp-type",
                                            "value": "222222",
                                            "qualifier": [{
                                                "name": "Q3",
                                                "value": "567",
                                            }],
                                        },
                                    },
                                },
                            ],
                        },
                        {
                            "name": "condition-C-or",
                            "orCondition": [{
                                "name": "pattern-C1",
                                "operator": {
                                    "patternMatch": {
                                        "context": "ntlm-req-auth-v1",
                                        "value": "1200",
                                    },
                                },
                            }],
                        },
                    ],
                },
            ],
        })
    scm_vp_signature2 = scm.VulnerabilityProtectionSignature("scm_vp_signature_2",
        folder="Shared",
        threat_id="41040",
        threatname="scm_vp_sig_2",
        affected_host={
            "server": True,
        },
        comment="basic-combo-signature",
        severity="high",
        direction="both",
        default_action={
            "alert": {},
        },
        signature={
            "combination": {
                "name": "combo-sig",
                "order_free": True,
                "and_conditions": [{
                    "name": "condition-C-or",
                    "or_condition": [{
                        "name": "pattern-C1",
                        "threatId": 10030,
                    }],
                }],
                "time_attribute": {
                    "interval": 3600,
                    "threshold": 5,
                    "track_by": "source-and-destination",
                },
            },
        })
    scm_vp_signature3 = scm.VulnerabilityProtectionSignature("scm_vp_signature_3",
        folder="Shared",
        threat_id="41030",
        threatname="scm_vp_sig_3",
        affected_host={
            "server": True,
        },
        bugtraqs=["12345"],
        comment="combo-signatures",
        cves=["CVE-2025-9999"],
        references=["https://example.com/exploit-details"],
        severity="medium",
        direction="server2client",
        vendors=["Custom"],
        default_action={
            "drop": {},
        },
        signature={
            "combination": {
                "name": "combo-signature-one",
                "order_free": False,
                "and_conditions": [
                    {
                        "name": "condition-A-or",
                        "or_condition": [{
                            "name": "pattern-A1",
                            "threatId": 10001,
                        }],
                    },
                    {
                        "name": "condition-B-or",
                        "or_condition": [
                            {
                                "name": "pattern-B1",
                                "threatId": 10043,
                            },
                            {
                                "name": "pattern-B2",
                                "threatId": 10025,
                            },
                            {
                                "name": "pattern-B3",
                                "threatId": 10050,
                            },
                        ],
                    },
                    {
                        "name": "condition-C-or",
                        "or_condition": [{
                            "name": "pattern-C1",
                            "threatId": 10030,
                        }],
                    },
                ],
                "time_attribute": {
                    "interval": 3600,
                    "threshold": 20,
                    "track_by": "source",
                },
            },
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-scm/sdk/go/scm"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := scm.NewVulnerabilityProtectionSignature(ctx, "scm_vp_signature_1", &scm.VulnerabilityProtectionSignatureArgs{
    			Folder:     pulumi.String("Shared"),
    			ThreatId:   pulumi.String("41010"),
    			Threatname: pulumi.String("scm_vp_signature_1"),
    			Severity:   pulumi.String("informational"),
    			Direction:  pulumi.String("client2server"),
    			AffectedHost: &scm.VulnerabilityProtectionSignatureAffectedHostArgs{
    				Client: pulumi.Bool(true),
    			},
    			Signature: &scm.VulnerabilityProtectionSignatureSignatureArgs{
    				Standards: scm.VulnerabilityProtectionSignatureSignatureStandardArray{
    					&scm.VulnerabilityProtectionSignatureSignatureStandardArgs{
    						Name: pulumi.String("basic-signature"),
    					},
    					&scm.VulnerabilityProtectionSignatureSignatureStandardArgs{
    						Name:      pulumi.String("standard-signature-one"),
    						Scope:     pulumi.String("protocol-data-unit"),
    						OrderFree: pulumi.Bool(false),
    						AndCondition: []map[string]interface{}{
    							map[string]interface{}{
    								"name": "condition-A-or",
    								"orCondition": []map[string]interface{}{
    									map[string]interface{}{
    										"name": "pattern-A1",
    										"operator": map[string]interface{}{
    											"lessThan": map[string]interface{}{
    												"context": "telnet-req-client-data",
    												"value":   "123",
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    					&scm.VulnerabilityProtectionSignatureSignatureStandardArgs{
    						Name:      pulumi.String("standard-signature-two"),
    						Scope:     pulumi.String("session"),
    						OrderFree: pulumi.Bool(true),
    						AndCondition: []interface{}{
    							map[string]interface{}{
    								"name": "condition-B-or",
    								"orCondition": []interface{}{
    									map[string]interface{}{
    										"name": "pattern-B1",
    										"operator": map[string]interface{}{
    											"greaterThan": map[string]interface{}{
    												"context": "cip-ethernet-ip-req-class-id",
    												"value":   "111111",
    												"qualifier": []map[string]interface{}{
    													map[string]interface{}{
    														"name":  "Q1",
    														"value": "123",
    													},
    													map[string]interface{}{
    														"name":  "Q2",
    														"value": "920",
    													},
    												},
    											},
    										},
    									},
    									map[string]interface{}{
    										"name": "pattern-B2",
    										"operator": map[string]interface{}{
    											"equalTo": map[string]interface{}{
    												"context": "icmp-rsp-type",
    												"value":   "222222",
    												"qualifier": []map[string]interface{}{
    													map[string]interface{}{
    														"name":  "Q3",
    														"value": "567",
    													},
    												},
    											},
    										},
    									},
    								},
    							},
    							map[string]interface{}{
    								"name": "condition-C-or",
    								"orCondition": []map[string]interface{}{
    									map[string]interface{}{
    										"name": "pattern-C1",
    										"operator": map[string]interface{}{
    											"patternMatch": map[string]interface{}{
    												"context": "ntlm-req-auth-v1",
    												"value":   "1200",
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = scm.NewVulnerabilityProtectionSignature(ctx, "scm_vp_signature_2", &scm.VulnerabilityProtectionSignatureArgs{
    			Folder:     pulumi.String("Shared"),
    			ThreatId:   pulumi.String("41040"),
    			Threatname: pulumi.String("scm_vp_sig_2"),
    			AffectedHost: &scm.VulnerabilityProtectionSignatureAffectedHostArgs{
    				Server: pulumi.Bool(true),
    			},
    			Comment:   pulumi.String("basic-combo-signature"),
    			Severity:  pulumi.String("high"),
    			Direction: pulumi.String("both"),
    			DefaultAction: &scm.VulnerabilityProtectionSignatureDefaultActionArgs{
    				Alert: &scm.VulnerabilityProtectionSignatureDefaultActionAlertArgs{},
    			},
    			Signature: &scm.VulnerabilityProtectionSignatureSignatureArgs{
    				Combination: &scm.VulnerabilityProtectionSignatureSignatureCombinationArgs{
    					Name:      "combo-sig",
    					OrderFree: pulumi.Bool(true),
    					AndConditions: scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArray{
    						&scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs{
    							Name: pulumi.String("condition-C-or"),
    							OrCondition: []map[string]interface{}{
    								map[string]interface{}{
    									"name":     "pattern-C1",
    									"threatId": 10030,
    								},
    							},
    						},
    					},
    					TimeAttribute: &scm.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs{
    						Interval:  pulumi.Int(3600),
    						Threshold: pulumi.Int(5),
    						TrackBy:   pulumi.String("source-and-destination"),
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = scm.NewVulnerabilityProtectionSignature(ctx, "scm_vp_signature_3", &scm.VulnerabilityProtectionSignatureArgs{
    			Folder:     pulumi.String("Shared"),
    			ThreatId:   pulumi.String("41030"),
    			Threatname: pulumi.String("scm_vp_sig_3"),
    			AffectedHost: &scm.VulnerabilityProtectionSignatureAffectedHostArgs{
    				Server: pulumi.Bool(true),
    			},
    			Bugtraqs: pulumi.StringArray{
    				pulumi.String("12345"),
    			},
    			Comment: pulumi.String("combo-signatures"),
    			Cves: pulumi.StringArray{
    				pulumi.String("CVE-2025-9999"),
    			},
    			References: pulumi.StringArray{
    				pulumi.String("https://example.com/exploit-details"),
    			},
    			Severity:  pulumi.String("medium"),
    			Direction: pulumi.String("server2client"),
    			Vendors: pulumi.StringArray{
    				pulumi.String("Custom"),
    			},
    			DefaultAction: &scm.VulnerabilityProtectionSignatureDefaultActionArgs{
    				Drop: &scm.VulnerabilityProtectionSignatureDefaultActionDropArgs{},
    			},
    			Signature: &scm.VulnerabilityProtectionSignatureSignatureArgs{
    				Combination: &scm.VulnerabilityProtectionSignatureSignatureCombinationArgs{
    					Name:      "combo-signature-one",
    					OrderFree: pulumi.Bool(false),
    					AndConditions: scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArray{
    						&scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs{
    							Name: pulumi.String("condition-A-or"),
    							OrCondition: []map[string]interface{}{
    								map[string]interface{}{
    									"name":     "pattern-A1",
    									"threatId": 10001,
    								},
    							},
    						},
    						&scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs{
    							Name: pulumi.String("condition-B-or"),
    							OrCondition: []interface{}{
    								map[string]interface{}{
    									"name":     "pattern-B1",
    									"threatId": 10043,
    								},
    								map[string]interface{}{
    									"name":     "pattern-B2",
    									"threatId": 10025,
    								},
    								map[string]interface{}{
    									"name":     "pattern-B3",
    									"threatId": 10050,
    								},
    							},
    						},
    						&scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs{
    							Name: pulumi.String("condition-C-or"),
    							OrCondition: []map[string]interface{}{
    								map[string]interface{}{
    									"name":     "pattern-C1",
    									"threatId": 10030,
    								},
    							},
    						},
    					},
    					TimeAttribute: &scm.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs{
    						Interval:  pulumi.Int(3600),
    						Threshold: pulumi.Int(20),
    						TrackBy:   pulumi.String("source"),
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Scm = Pulumi.Scm;
    
    return await Deployment.RunAsync(() => 
    {
        var scmVpSignature1 = new Scm.VulnerabilityProtectionSignature("scm_vp_signature_1", new()
        {
            Folder = "Shared",
            ThreatId = "41010",
            Threatname = "scm_vp_signature_1",
            Severity = "informational",
            Direction = "client2server",
            AffectedHost = new Scm.Inputs.VulnerabilityProtectionSignatureAffectedHostArgs
            {
                Client = true,
            },
            Signature = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureArgs
            {
                Standards = new[]
                {
                    new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardArgs
                    {
                        Name = "basic-signature",
                    },
                    new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardArgs
                    {
                        Name = "standard-signature-one",
                        Scope = "protocol-data-unit",
                        OrderFree = false,
                        AndCondition = new[]
                        {
                            
                            {
                                { "name", "condition-A-or" },
                                { "orCondition", new[]
                                {
                                    
                                    {
                                        { "name", "pattern-A1" },
                                        { "operator", 
                                        {
                                            { "lessThan", 
                                            {
                                                { "context", "telnet-req-client-data" },
                                                { "value", "123" },
                                            } },
                                        } },
                                    },
                                } },
                            },
                        },
                    },
                    new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardArgs
                    {
                        Name = "standard-signature-two",
                        Scope = "session",
                        OrderFree = true,
                        AndCondition = new[]
                        {
                            
                            {
                                { "name", "condition-B-or" },
                                { "orCondition", new[]
                                {
                                    
                                    {
                                        { "name", "pattern-B1" },
                                        { "operator", 
                                        {
                                            { "greaterThan", 
                                            {
                                                { "context", "cip-ethernet-ip-req-class-id" },
                                                { "value", "111111" },
                                                { "qualifier", new[]
                                                {
                                                    
                                                    {
                                                        { "name", "Q1" },
                                                        { "value", "123" },
                                                    },
                                                    
                                                    {
                                                        { "name", "Q2" },
                                                        { "value", "920" },
                                                    },
                                                } },
                                            } },
                                        } },
                                    },
                                    
                                    {
                                        { "name", "pattern-B2" },
                                        { "operator", 
                                        {
                                            { "equalTo", 
                                            {
                                                { "context", "icmp-rsp-type" },
                                                { "value", "222222" },
                                                { "qualifier", new[]
                                                {
                                                    
                                                    {
                                                        { "name", "Q3" },
                                                        { "value", "567" },
                                                    },
                                                } },
                                            } },
                                        } },
                                    },
                                } },
                            },
                            
                            {
                                { "name", "condition-C-or" },
                                { "orCondition", new[]
                                {
                                    
                                    {
                                        { "name", "pattern-C1" },
                                        { "operator", 
                                        {
                                            { "patternMatch", 
                                            {
                                                { "context", "ntlm-req-auth-v1" },
                                                { "value", "1200" },
                                            } },
                                        } },
                                    },
                                } },
                            },
                        },
                    },
                },
            },
        });
    
        var scmVpSignature2 = new Scm.VulnerabilityProtectionSignature("scm_vp_signature_2", new()
        {
            Folder = "Shared",
            ThreatId = "41040",
            Threatname = "scm_vp_sig_2",
            AffectedHost = new Scm.Inputs.VulnerabilityProtectionSignatureAffectedHostArgs
            {
                Server = true,
            },
            Comment = "basic-combo-signature",
            Severity = "high",
            Direction = "both",
            DefaultAction = new Scm.Inputs.VulnerabilityProtectionSignatureDefaultActionArgs
            {
                Alert = null,
            },
            Signature = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureArgs
            {
                Combination = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationArgs
                {
                    Name = "combo-sig",
                    OrderFree = true,
                    AndConditions = new[]
                    {
                        new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs
                        {
                            Name = "condition-C-or",
                            OrCondition = new[]
                            {
                                
                                {
                                    { "name", "pattern-C1" },
                                    { "threatId", 10030 },
                                },
                            },
                        },
                    },
                    TimeAttribute = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs
                    {
                        Interval = 3600,
                        Threshold = 5,
                        TrackBy = "source-and-destination",
                    },
                },
            },
        });
    
        var scmVpSignature3 = new Scm.VulnerabilityProtectionSignature("scm_vp_signature_3", new()
        {
            Folder = "Shared",
            ThreatId = "41030",
            Threatname = "scm_vp_sig_3",
            AffectedHost = new Scm.Inputs.VulnerabilityProtectionSignatureAffectedHostArgs
            {
                Server = true,
            },
            Bugtraqs = new[]
            {
                "12345",
            },
            Comment = "combo-signatures",
            Cves = new[]
            {
                "CVE-2025-9999",
            },
            References = new[]
            {
                "https://example.com/exploit-details",
            },
            Severity = "medium",
            Direction = "server2client",
            Vendors = new[]
            {
                "Custom",
            },
            DefaultAction = new Scm.Inputs.VulnerabilityProtectionSignatureDefaultActionArgs
            {
                Drop = null,
            },
            Signature = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureArgs
            {
                Combination = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationArgs
                {
                    Name = "combo-signature-one",
                    OrderFree = false,
                    AndConditions = new[]
                    {
                        new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs
                        {
                            Name = "condition-A-or",
                            OrCondition = new[]
                            {
                                
                                {
                                    { "name", "pattern-A1" },
                                    { "threatId", 10001 },
                                },
                            },
                        },
                        new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs
                        {
                            Name = "condition-B-or",
                            OrCondition = new[]
                            {
                                
                                {
                                    { "name", "pattern-B1" },
                                    { "threatId", 10043 },
                                },
                                
                                {
                                    { "name", "pattern-B2" },
                                    { "threatId", 10025 },
                                },
                                
                                {
                                    { "name", "pattern-B3" },
                                    { "threatId", 10050 },
                                },
                            },
                        },
                        new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs
                        {
                            Name = "condition-C-or",
                            OrCondition = new[]
                            {
                                
                                {
                                    { "name", "pattern-C1" },
                                    { "threatId", 10030 },
                                },
                            },
                        },
                    },
                    TimeAttribute = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs
                    {
                        Interval = 3600,
                        Threshold = 20,
                        TrackBy = "source",
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.scm.VulnerabilityProtectionSignature;
    import com.pulumi.scm.VulnerabilityProtectionSignatureArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureAffectedHostArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureSignatureArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureDefaultActionArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureDefaultActionAlertArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureSignatureCombinationArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs;
    import com.pulumi.scm.inputs.VulnerabilityProtectionSignatureDefaultActionDropArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var scmVpSignature1 = new VulnerabilityProtectionSignature("scmVpSignature1", VulnerabilityProtectionSignatureArgs.builder()
                .folder("Shared")
                .threatId("41010")
                .threatname("scm_vp_signature_1")
                .severity("informational")
                .direction("client2server")
                .affectedHost(VulnerabilityProtectionSignatureAffectedHostArgs.builder()
                    .client(true)
                    .build())
                .signature(VulnerabilityProtectionSignatureSignatureArgs.builder()
                    .standards(                
                        VulnerabilityProtectionSignatureSignatureStandardArgs.builder()
                            .name("basic-signature")
                            .build(),
                        VulnerabilityProtectionSignatureSignatureStandardArgs.builder()
                            .name("standard-signature-one")
                            .scope("protocol-data-unit")
                            .orderFree(false)
                            .andCondition(List.of(Map.ofEntries(
                                Map.entry("name", "condition-A-or"),
                                Map.entry("orCondition", List.of(Map.ofEntries(
                                    Map.entry("name", "pattern-A1"),
                                    Map.entry("operator", Map.of("lessThan", Map.ofEntries(
                                        Map.entry("context", "telnet-req-client-data"),
                                        Map.entry("value", "123")
                                    )))
                                )))
                            )))
                            .build(),
                        VulnerabilityProtectionSignatureSignatureStandardArgs.builder()
                            .name("standard-signature-two")
                            .scope("session")
                            .orderFree(true)
                            .andCondition(List.of(                        
                                Map.ofEntries(
                                    Map.entry("name", "condition-B-or"),
                                    Map.entry("orCondition", List.of(                                
                                        Map.ofEntries(
                                            Map.entry("name", "pattern-B1"),
                                            Map.entry("operator", Map.of("greaterThan", Map.ofEntries(
                                                Map.entry("context", "cip-ethernet-ip-req-class-id"),
                                                Map.entry("value", "111111"),
                                                Map.entry("qualifier", List.of(                                            
                                                    Map.ofEntries(
                                                        Map.entry("name", "Q1"),
                                                        Map.entry("value", "123")
                                                    ),
                                                    Map.ofEntries(
                                                        Map.entry("name", "Q2"),
                                                        Map.entry("value", "920")
                                                    )))
                                            )))
                                        ),
                                        Map.ofEntries(
                                            Map.entry("name", "pattern-B2"),
                                            Map.entry("operator", Map.of("equalTo", Map.ofEntries(
                                                Map.entry("context", "icmp-rsp-type"),
                                                Map.entry("value", "222222"),
                                                Map.entry("qualifier", List.of(Map.ofEntries(
                                                    Map.entry("name", "Q3"),
                                                    Map.entry("value", "567")
                                                )))
                                            )))
                                        )))
                                ),
                                Map.ofEntries(
                                    Map.entry("name", "condition-C-or"),
                                    Map.entry("orCondition", List.of(Map.ofEntries(
                                        Map.entry("name", "pattern-C1"),
                                        Map.entry("operator", Map.of("patternMatch", Map.ofEntries(
                                            Map.entry("context", "ntlm-req-auth-v1"),
                                            Map.entry("value", "1200")
                                        )))
                                    )))
                                )))
                            .build())
                    .build())
                .build());
    
            var scmVpSignature2 = new VulnerabilityProtectionSignature("scmVpSignature2", VulnerabilityProtectionSignatureArgs.builder()
                .folder("Shared")
                .threatId("41040")
                .threatname("scm_vp_sig_2")
                .affectedHost(VulnerabilityProtectionSignatureAffectedHostArgs.builder()
                    .server(true)
                    .build())
                .comment("basic-combo-signature")
                .severity("high")
                .direction("both")
                .defaultAction(VulnerabilityProtectionSignatureDefaultActionArgs.builder()
                    .alert(VulnerabilityProtectionSignatureDefaultActionAlertArgs.builder()
                        .build())
                    .build())
                .signature(VulnerabilityProtectionSignatureSignatureArgs.builder()
                    .combination(VulnerabilityProtectionSignatureSignatureCombinationArgs.builder()
                        .name("combo-sig")
                        .orderFree(true)
                        .andConditions(VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs.builder()
                            .name("condition-C-or")
                            .orCondition(List.of(Map.ofEntries(
                                Map.entry("name", "pattern-C1"),
                                Map.entry("threatId", 10030)
                            )))
                            .build())
                        .timeAttribute(VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs.builder()
                            .interval(3600)
                            .threshold(5)
                            .trackBy("source-and-destination")
                            .build())
                        .build())
                    .build())
                .build());
    
            var scmVpSignature3 = new VulnerabilityProtectionSignature("scmVpSignature3", VulnerabilityProtectionSignatureArgs.builder()
                .folder("Shared")
                .threatId("41030")
                .threatname("scm_vp_sig_3")
                .affectedHost(VulnerabilityProtectionSignatureAffectedHostArgs.builder()
                    .server(true)
                    .build())
                .bugtraqs("12345")
                .comment("combo-signatures")
                .cves("CVE-2025-9999")
                .references("https://example.com/exploit-details")
                .severity("medium")
                .direction("server2client")
                .vendors("Custom")
                .defaultAction(VulnerabilityProtectionSignatureDefaultActionArgs.builder()
                    .drop(VulnerabilityProtectionSignatureDefaultActionDropArgs.builder()
                        .build())
                    .build())
                .signature(VulnerabilityProtectionSignatureSignatureArgs.builder()
                    .combination(VulnerabilityProtectionSignatureSignatureCombinationArgs.builder()
                        .name("combo-signature-one")
                        .orderFree(false)
                        .andConditions(                    
                            VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs.builder()
                                .name("condition-A-or")
                                .orCondition(List.of(Map.ofEntries(
                                    Map.entry("name", "pattern-A1"),
                                    Map.entry("threatId", 10001)
                                )))
                                .build(),
                            VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs.builder()
                                .name("condition-B-or")
                                .orCondition(List.of(                            
                                    Map.ofEntries(
                                        Map.entry("name", "pattern-B1"),
                                        Map.entry("threatId", 10043)
                                    ),
                                    Map.ofEntries(
                                        Map.entry("name", "pattern-B2"),
                                        Map.entry("threatId", 10025)
                                    ),
                                    Map.ofEntries(
                                        Map.entry("name", "pattern-B3"),
                                        Map.entry("threatId", 10050)
                                    )))
                                .build(),
                            VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs.builder()
                                .name("condition-C-or")
                                .orCondition(List.of(Map.ofEntries(
                                    Map.entry("name", "pattern-C1"),
                                    Map.entry("threatId", 10030)
                                )))
                                .build())
                        .timeAttribute(VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs.builder()
                            .interval(3600)
                            .threshold(20)
                            .trackBy("source")
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      scmVpSignature1:
        type: scm:VulnerabilityProtectionSignature
        name: scm_vp_signature_1
        properties:
          folder: Shared
          threatId: '41010'
          threatname: scm_vp_signature_1
          severity: informational
          direction: client2server
          affectedHost:
            client: true
          signature:
            standards:
              - name: basic-signature
              - name: standard-signature-one
                scope: protocol-data-unit
                orderFree: false
                andCondition:
                  - name: condition-A-or
                    orCondition:
                      - name: pattern-A1
                        operator:
                          lessThan:
                            context: telnet-req-client-data
                            value: '123'
              - name: standard-signature-two
                scope: session
                orderFree: true
                andCondition:
                  - name: condition-B-or
                    orCondition:
                      - name: pattern-B1
                        operator:
                          greaterThan:
                            context: cip-ethernet-ip-req-class-id
                            value: '111111'
                            qualifier:
                              - name: Q1
                                value: '123'
                              - name: Q2
                                value: '920'
                      - name: pattern-B2
                        operator:
                          equalTo:
                            context: icmp-rsp-type
                            value: '222222'
                            qualifier:
                              - name: Q3
                                value: '567'
                  - name: condition-C-or
                    orCondition:
                      - name: pattern-C1
                        operator:
                          patternMatch:
                            context: ntlm-req-auth-v1
                            value: '1200'
      scmVpSignature2:
        type: scm:VulnerabilityProtectionSignature
        name: scm_vp_signature_2
        properties:
          folder: Shared
          threatId: '41040'
          threatname: scm_vp_sig_2
          affectedHost:
            server: true
          comment: basic-combo-signature
          severity: high
          direction: both
          defaultAction:
            alert: {}
          signature:
            combination:
              name: combo-sig
              orderFree: true
              andConditions:
                - name: condition-C-or
                  orCondition:
                    - name: pattern-C1
                      threatId: 10030
              timeAttribute:
                interval: 3600
                threshold: 5
                trackBy: source-and-destination
      scmVpSignature3:
        type: scm:VulnerabilityProtectionSignature
        name: scm_vp_signature_3
        properties:
          folder: Shared
          threatId: '41030'
          threatname: scm_vp_sig_3
          affectedHost:
            server: true
          bugtraqs:
            - '12345'
          comment: combo-signatures
          cves:
            - CVE-2025-9999
          references:
            - https://example.com/exploit-details
          severity: medium
          direction: server2client
          vendors:
            - Custom
          defaultAction:
            drop: {}
          signature:
            combination:
              name: combo-signature-one
              orderFree: false
              andConditions:
                - name: condition-A-or
                  orCondition:
                    - name: pattern-A1
                      threatId: 10001
                - name: condition-B-or
                  orCondition:
                    - name: pattern-B1
                      threatId: 10043
                    - name: pattern-B2
                      threatId: 10025
                    - name: pattern-B3
                      threatId: 10050
                - name: condition-C-or
                  orCondition:
                    - name: pattern-C1
                      threatId: 10030
              timeAttribute:
                interval: 3600
                threshold: 20
                trackBy: source
    

    Create VulnerabilityProtectionSignature Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new VulnerabilityProtectionSignature(name: string, args: VulnerabilityProtectionSignatureArgs, opts?: CustomResourceOptions);
    @overload
    def VulnerabilityProtectionSignature(resource_name: str,
                                         args: VulnerabilityProtectionSignatureArgs,
                                         opts: Optional[ResourceOptions] = None)
    
    @overload
    def VulnerabilityProtectionSignature(resource_name: str,
                                         opts: Optional[ResourceOptions] = None,
                                         severity: Optional[str] = None,
                                         signature: Optional[VulnerabilityProtectionSignatureSignatureArgs] = None,
                                         threatname: Optional[str] = None,
                                         threat_id: Optional[str] = None,
                                         affected_host: Optional[VulnerabilityProtectionSignatureAffectedHostArgs] = None,
                                         direction: Optional[str] = None,
                                         default_action: Optional[VulnerabilityProtectionSignatureDefaultActionArgs] = None,
                                         bugtraqs: Optional[Sequence[str]] = None,
                                         device: Optional[str] = None,
                                         references: Optional[Sequence[str]] = None,
                                         folder: Optional[str] = None,
                                         snippet: Optional[str] = None,
                                         cves: Optional[Sequence[str]] = None,
                                         comment: Optional[str] = None,
                                         vendors: Optional[Sequence[str]] = None)
    func NewVulnerabilityProtectionSignature(ctx *Context, name string, args VulnerabilityProtectionSignatureArgs, opts ...ResourceOption) (*VulnerabilityProtectionSignature, error)
    public VulnerabilityProtectionSignature(string name, VulnerabilityProtectionSignatureArgs args, CustomResourceOptions? opts = null)
    public VulnerabilityProtectionSignature(String name, VulnerabilityProtectionSignatureArgs args)
    public VulnerabilityProtectionSignature(String name, VulnerabilityProtectionSignatureArgs args, CustomResourceOptions options)
    
    type: scm:VulnerabilityProtectionSignature
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args VulnerabilityProtectionSignatureArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args VulnerabilityProtectionSignatureArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args VulnerabilityProtectionSignatureArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args VulnerabilityProtectionSignatureArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args VulnerabilityProtectionSignatureArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var vulnerabilityProtectionSignatureResource = new Scm.VulnerabilityProtectionSignature("vulnerabilityProtectionSignatureResource", new()
    {
        Severity = "string",
        Signature = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureArgs
        {
            Combination = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationArgs
            {
                AndConditions = new[]
                {
                    new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs
                    {
                        Name = "string",
                        OrConditions = new[]
                        {
                            new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrConditionArgs
                            {
                                Name = "string",
                                ThreatId = "string",
                            },
                        },
                    },
                },
                OrderFree = false,
                TimeAttribute = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs
                {
                    Interval = 0,
                    Threshold = 0,
                    TrackBy = "string",
                },
            },
            Standards = new[]
            {
                new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardArgs
                {
                    Name = "string",
                    AndConditions = new[]
                    {
                        new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionArgs
                        {
                            Name = "string",
                            OrConditions = new[]
                            {
                                new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionArgs
                                {
                                    Name = "string",
                                    Operator = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorArgs
                                    {
                                        EqualTo = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToArgs
                                        {
                                            Context = "string",
                                            Negate = false,
                                            Qualifiers = new[]
                                            {
                                                new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifierArgs
                                                {
                                                    Name = "string",
                                                    Value = "string",
                                                },
                                            },
                                            Value = 0,
                                        },
                                        GreaterThan = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanArgs
                                        {
                                            Context = "string",
                                            Qualifiers = new[]
                                            {
                                                new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifierArgs
                                                {
                                                    Name = "string",
                                                    Value = "string",
                                                },
                                            },
                                            Value = 0,
                                        },
                                        LessThan = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanArgs
                                        {
                                            Context = "string",
                                            Qualifiers = new[]
                                            {
                                                new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifierArgs
                                                {
                                                    Name = "string",
                                                    Value = "string",
                                                },
                                            },
                                            Value = 0,
                                        },
                                        PatternMatch = new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchArgs
                                        {
                                            Context = "string",
                                            Negate = false,
                                            Pattern = "string",
                                            Qualifiers = new[]
                                            {
                                                new Scm.Inputs.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifierArgs
                                                {
                                                    Name = "string",
                                                    Value = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    Comment = "string",
                    OrderFree = false,
                    Scope = "string",
                },
            },
        },
        Threatname = "string",
        ThreatId = "string",
        AffectedHost = new Scm.Inputs.VulnerabilityProtectionSignatureAffectedHostArgs
        {
            Client = false,
            Server = false,
        },
        Direction = "string",
        DefaultAction = new Scm.Inputs.VulnerabilityProtectionSignatureDefaultActionArgs
        {
            Alert = null,
            Allow = null,
            BlockIp = new Scm.Inputs.VulnerabilityProtectionSignatureDefaultActionBlockIpArgs
            {
                Duration = 0,
                TrackBy = "string",
            },
            Drop = null,
            ResetBoth = null,
            ResetClient = null,
            ResetServer = null,
        },
        Bugtraqs = new[]
        {
            "string",
        },
        Device = "string",
        References = new[]
        {
            "string",
        },
        Folder = "string",
        Snippet = "string",
        Cves = new[]
        {
            "string",
        },
        Comment = "string",
        Vendors = new[]
        {
            "string",
        },
    });
    
    example, err := scm.NewVulnerabilityProtectionSignature(ctx, "vulnerabilityProtectionSignatureResource", &scm.VulnerabilityProtectionSignatureArgs{
    	Severity: pulumi.String("string"),
    	Signature: &scm.VulnerabilityProtectionSignatureSignatureArgs{
    		Combination: &scm.VulnerabilityProtectionSignatureSignatureCombinationArgs{
    			AndConditions: scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArray{
    				&scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs{
    					Name: pulumi.String("string"),
    					OrConditions: scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrConditionArray{
    						&scm.VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrConditionArgs{
    							Name:     pulumi.String("string"),
    							ThreatId: pulumi.String("string"),
    						},
    					},
    				},
    			},
    			OrderFree: pulumi.Bool(false),
    			TimeAttribute: &scm.VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs{
    				Interval:  pulumi.Int(0),
    				Threshold: pulumi.Int(0),
    				TrackBy:   pulumi.String("string"),
    			},
    		},
    		Standards: scm.VulnerabilityProtectionSignatureSignatureStandardArray{
    			&scm.VulnerabilityProtectionSignatureSignatureStandardArgs{
    				Name: pulumi.String("string"),
    				AndConditions: scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionArray{
    					&scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionArgs{
    						Name: pulumi.String("string"),
    						OrConditions: scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionArray{
    							&scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionArgs{
    								Name: pulumi.String("string"),
    								Operator: &scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorArgs{
    									EqualTo: &scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToArgs{
    										Context: pulumi.String("string"),
    										Negate:  pulumi.Bool(false),
    										Qualifiers: scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifierArray{
    											&scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifierArgs{
    												Name:  pulumi.String("string"),
    												Value: pulumi.String("string"),
    											},
    										},
    										Value: pulumi.Int(0),
    									},
    									GreaterThan: &scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanArgs{
    										Context: pulumi.String("string"),
    										Qualifiers: scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifierArray{
    											&scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifierArgs{
    												Name:  pulumi.String("string"),
    												Value: pulumi.String("string"),
    											},
    										},
    										Value: pulumi.Int(0),
    									},
    									LessThan: &scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanArgs{
    										Context: pulumi.String("string"),
    										Qualifiers: scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifierArray{
    											&scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifierArgs{
    												Name:  pulumi.String("string"),
    												Value: pulumi.String("string"),
    											},
    										},
    										Value: pulumi.Int(0),
    									},
    									PatternMatch: &scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchArgs{
    										Context: pulumi.String("string"),
    										Negate:  pulumi.Bool(false),
    										Pattern: pulumi.String("string"),
    										Qualifiers: scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifierArray{
    											&scm.VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifierArgs{
    												Name:  pulumi.String("string"),
    												Value: pulumi.String("string"),
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    				Comment:   pulumi.String("string"),
    				OrderFree: pulumi.Bool(false),
    				Scope:     pulumi.String("string"),
    			},
    		},
    	},
    	Threatname: pulumi.String("string"),
    	ThreatId:   pulumi.String("string"),
    	AffectedHost: &scm.VulnerabilityProtectionSignatureAffectedHostArgs{
    		Client: pulumi.Bool(false),
    		Server: pulumi.Bool(false),
    	},
    	Direction: pulumi.String("string"),
    	DefaultAction: &scm.VulnerabilityProtectionSignatureDefaultActionArgs{
    		Alert: &scm.VulnerabilityProtectionSignatureDefaultActionAlertArgs{},
    		Allow: &scm.VulnerabilityProtectionSignatureDefaultActionAllowArgs{},
    		BlockIp: &scm.VulnerabilityProtectionSignatureDefaultActionBlockIpArgs{
    			Duration: pulumi.Int(0),
    			TrackBy:  pulumi.String("string"),
    		},
    		Drop:        &scm.VulnerabilityProtectionSignatureDefaultActionDropArgs{},
    		ResetBoth:   &scm.VulnerabilityProtectionSignatureDefaultActionResetBothArgs{},
    		ResetClient: &scm.VulnerabilityProtectionSignatureDefaultActionResetClientArgs{},
    		ResetServer: &scm.VulnerabilityProtectionSignatureDefaultActionResetServerArgs{},
    	},
    	Bugtraqs: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	Device: pulumi.String("string"),
    	References: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	Folder:  pulumi.String("string"),
    	Snippet: pulumi.String("string"),
    	Cves: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	Comment: pulumi.String("string"),
    	Vendors: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    })
    
    var vulnerabilityProtectionSignatureResource = new VulnerabilityProtectionSignature("vulnerabilityProtectionSignatureResource", VulnerabilityProtectionSignatureArgs.builder()
        .severity("string")
        .signature(VulnerabilityProtectionSignatureSignatureArgs.builder()
            .combination(VulnerabilityProtectionSignatureSignatureCombinationArgs.builder()
                .andConditions(VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs.builder()
                    .name("string")
                    .orConditions(VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrConditionArgs.builder()
                        .name("string")
                        .threatId("string")
                        .build())
                    .build())
                .orderFree(false)
                .timeAttribute(VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs.builder()
                    .interval(0)
                    .threshold(0)
                    .trackBy("string")
                    .build())
                .build())
            .standards(VulnerabilityProtectionSignatureSignatureStandardArgs.builder()
                .name("string")
                .andConditions(VulnerabilityProtectionSignatureSignatureStandardAndConditionArgs.builder()
                    .name("string")
                    .orConditions(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionArgs.builder()
                        .name("string")
                        .operator(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorArgs.builder()
                            .equalTo(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToArgs.builder()
                                .context("string")
                                .negate(false)
                                .qualifiers(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifierArgs.builder()
                                    .name("string")
                                    .value("string")
                                    .build())
                                .value(0)
                                .build())
                            .greaterThan(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanArgs.builder()
                                .context("string")
                                .qualifiers(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifierArgs.builder()
                                    .name("string")
                                    .value("string")
                                    .build())
                                .value(0)
                                .build())
                            .lessThan(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanArgs.builder()
                                .context("string")
                                .qualifiers(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifierArgs.builder()
                                    .name("string")
                                    .value("string")
                                    .build())
                                .value(0)
                                .build())
                            .patternMatch(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchArgs.builder()
                                .context("string")
                                .negate(false)
                                .pattern("string")
                                .qualifiers(VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifierArgs.builder()
                                    .name("string")
                                    .value("string")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .comment("string")
                .orderFree(false)
                .scope("string")
                .build())
            .build())
        .threatname("string")
        .threatId("string")
        .affectedHost(VulnerabilityProtectionSignatureAffectedHostArgs.builder()
            .client(false)
            .server(false)
            .build())
        .direction("string")
        .defaultAction(VulnerabilityProtectionSignatureDefaultActionArgs.builder()
            .alert(VulnerabilityProtectionSignatureDefaultActionAlertArgs.builder()
                .build())
            .allow(VulnerabilityProtectionSignatureDefaultActionAllowArgs.builder()
                .build())
            .blockIp(VulnerabilityProtectionSignatureDefaultActionBlockIpArgs.builder()
                .duration(0)
                .trackBy("string")
                .build())
            .drop(VulnerabilityProtectionSignatureDefaultActionDropArgs.builder()
                .build())
            .resetBoth(VulnerabilityProtectionSignatureDefaultActionResetBothArgs.builder()
                .build())
            .resetClient(VulnerabilityProtectionSignatureDefaultActionResetClientArgs.builder()
                .build())
            .resetServer(VulnerabilityProtectionSignatureDefaultActionResetServerArgs.builder()
                .build())
            .build())
        .bugtraqs("string")
        .device("string")
        .references("string")
        .folder("string")
        .snippet("string")
        .cves("string")
        .comment("string")
        .vendors("string")
        .build());
    
    vulnerability_protection_signature_resource = scm.VulnerabilityProtectionSignature("vulnerabilityProtectionSignatureResource",
        severity="string",
        signature={
            "combination": {
                "and_conditions": [{
                    "name": "string",
                    "or_conditions": [{
                        "name": "string",
                        "threat_id": "string",
                    }],
                }],
                "order_free": False,
                "time_attribute": {
                    "interval": 0,
                    "threshold": 0,
                    "track_by": "string",
                },
            },
            "standards": [{
                "name": "string",
                "and_conditions": [{
                    "name": "string",
                    "or_conditions": [{
                        "name": "string",
                        "operator": {
                            "equal_to": {
                                "context": "string",
                                "negate": False,
                                "qualifiers": [{
                                    "name": "string",
                                    "value": "string",
                                }],
                                "value": 0,
                            },
                            "greater_than": {
                                "context": "string",
                                "qualifiers": [{
                                    "name": "string",
                                    "value": "string",
                                }],
                                "value": 0,
                            },
                            "less_than": {
                                "context": "string",
                                "qualifiers": [{
                                    "name": "string",
                                    "value": "string",
                                }],
                                "value": 0,
                            },
                            "pattern_match": {
                                "context": "string",
                                "negate": False,
                                "pattern": "string",
                                "qualifiers": [{
                                    "name": "string",
                                    "value": "string",
                                }],
                            },
                        },
                    }],
                }],
                "comment": "string",
                "order_free": False,
                "scope": "string",
            }],
        },
        threatname="string",
        threat_id="string",
        affected_host={
            "client": False,
            "server": False,
        },
        direction="string",
        default_action={
            "alert": {},
            "allow": {},
            "block_ip": {
                "duration": 0,
                "track_by": "string",
            },
            "drop": {},
            "reset_both": {},
            "reset_client": {},
            "reset_server": {},
        },
        bugtraqs=["string"],
        device="string",
        references=["string"],
        folder="string",
        snippet="string",
        cves=["string"],
        comment="string",
        vendors=["string"])
    
    const vulnerabilityProtectionSignatureResource = new scm.VulnerabilityProtectionSignature("vulnerabilityProtectionSignatureResource", {
        severity: "string",
        signature: {
            combination: {
                andConditions: [{
                    name: "string",
                    orConditions: [{
                        name: "string",
                        threatId: "string",
                    }],
                }],
                orderFree: false,
                timeAttribute: {
                    interval: 0,
                    threshold: 0,
                    trackBy: "string",
                },
            },
            standards: [{
                name: "string",
                andConditions: [{
                    name: "string",
                    orConditions: [{
                        name: "string",
                        operator: {
                            equalTo: {
                                context: "string",
                                negate: false,
                                qualifiers: [{
                                    name: "string",
                                    value: "string",
                                }],
                                value: 0,
                            },
                            greaterThan: {
                                context: "string",
                                qualifiers: [{
                                    name: "string",
                                    value: "string",
                                }],
                                value: 0,
                            },
                            lessThan: {
                                context: "string",
                                qualifiers: [{
                                    name: "string",
                                    value: "string",
                                }],
                                value: 0,
                            },
                            patternMatch: {
                                context: "string",
                                negate: false,
                                pattern: "string",
                                qualifiers: [{
                                    name: "string",
                                    value: "string",
                                }],
                            },
                        },
                    }],
                }],
                comment: "string",
                orderFree: false,
                scope: "string",
            }],
        },
        threatname: "string",
        threatId: "string",
        affectedHost: {
            client: false,
            server: false,
        },
        direction: "string",
        defaultAction: {
            alert: {},
            allow: {},
            blockIp: {
                duration: 0,
                trackBy: "string",
            },
            drop: {},
            resetBoth: {},
            resetClient: {},
            resetServer: {},
        },
        bugtraqs: ["string"],
        device: "string",
        references: ["string"],
        folder: "string",
        snippet: "string",
        cves: ["string"],
        comment: "string",
        vendors: ["string"],
    });
    
    type: scm:VulnerabilityProtectionSignature
    properties:
        affectedHost:
            client: false
            server: false
        bugtraqs:
            - string
        comment: string
        cves:
            - string
        defaultAction:
            alert: {}
            allow: {}
            blockIp:
                duration: 0
                trackBy: string
            drop: {}
            resetBoth: {}
            resetClient: {}
            resetServer: {}
        device: string
        direction: string
        folder: string
        references:
            - string
        severity: string
        signature:
            combination:
                andConditions:
                    - name: string
                      orConditions:
                        - name: string
                          threatId: string
                orderFree: false
                timeAttribute:
                    interval: 0
                    threshold: 0
                    trackBy: string
            standards:
                - andConditions:
                    - name: string
                      orConditions:
                        - name: string
                          operator:
                            equalTo:
                                context: string
                                negate: false
                                qualifiers:
                                    - name: string
                                      value: string
                                value: 0
                            greaterThan:
                                context: string
                                qualifiers:
                                    - name: string
                                      value: string
                                value: 0
                            lessThan:
                                context: string
                                qualifiers:
                                    - name: string
                                      value: string
                                value: 0
                            patternMatch:
                                context: string
                                negate: false
                                pattern: string
                                qualifiers:
                                    - name: string
                                      value: string
                  comment: string
                  name: string
                  orderFree: false
                  scope: string
        snippet: string
        threatId: string
        threatname: string
        vendors:
            - string
    

    VulnerabilityProtectionSignature Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The VulnerabilityProtectionSignature resource accepts the following input properties:

    AffectedHost VulnerabilityProtectionSignatureAffectedHost
    Affected host
    Direction string
    Direction
    Severity string
    Severity
    Signature VulnerabilityProtectionSignatureSignature
    vulnerability protection signature
    ThreatId string
    threat id range \n\n and \n\n
    Threatname string
    Threatname
    Bugtraqs List<string>
    Bugtraq
    Comment string
    Comment
    Cves List<string>
    Cve
    DefaultAction VulnerabilityProtectionSignatureDefaultAction
    Default action
    Device string
    The device in which the resource is defined
    Folder string

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    References List<string>
    Reference
    Snippet string

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    Vendors List<string>
    Vendor
    AffectedHost VulnerabilityProtectionSignatureAffectedHostArgs
    Affected host
    Direction string
    Direction
    Severity string
    Severity
    Signature VulnerabilityProtectionSignatureSignatureArgs
    vulnerability protection signature
    ThreatId string
    threat id range \n\n and \n\n
    Threatname string
    Threatname
    Bugtraqs []string
    Bugtraq
    Comment string
    Comment
    Cves []string
    Cve
    DefaultAction VulnerabilityProtectionSignatureDefaultActionArgs
    Default action
    Device string
    The device in which the resource is defined
    Folder string

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    References []string
    Reference
    Snippet string

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    Vendors []string
    Vendor
    affectedHost VulnerabilityProtectionSignatureAffectedHost
    Affected host
    direction String
    Direction
    severity String
    Severity
    signature VulnerabilityProtectionSignatureSignature
    vulnerability protection signature
    threatId String
    threat id range \n\n and \n\n
    threatname String
    Threatname
    bugtraqs List<String>
    Bugtraq
    comment String
    Comment
    cves List<String>
    Cve
    defaultAction VulnerabilityProtectionSignatureDefaultAction
    Default action
    device String
    The device in which the resource is defined
    folder String

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references List<String>
    Reference
    snippet String

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    vendors List<String>
    Vendor
    affectedHost VulnerabilityProtectionSignatureAffectedHost
    Affected host
    direction string
    Direction
    severity string
    Severity
    signature VulnerabilityProtectionSignatureSignature
    vulnerability protection signature
    threatId string
    threat id range \n\n and \n\n
    threatname string
    Threatname
    bugtraqs string[]
    Bugtraq
    comment string
    Comment
    cves string[]
    Cve
    defaultAction VulnerabilityProtectionSignatureDefaultAction
    Default action
    device string
    The device in which the resource is defined
    folder string

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references string[]
    Reference
    snippet string

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    vendors string[]
    Vendor
    affected_host VulnerabilityProtectionSignatureAffectedHostArgs
    Affected host
    direction str
    Direction
    severity str
    Severity
    signature VulnerabilityProtectionSignatureSignatureArgs
    vulnerability protection signature
    threat_id str
    threat id range \n\n and \n\n
    threatname str
    Threatname
    bugtraqs Sequence[str]
    Bugtraq
    comment str
    Comment
    cves Sequence[str]
    Cve
    default_action VulnerabilityProtectionSignatureDefaultActionArgs
    Default action
    device str
    The device in which the resource is defined
    folder str

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references Sequence[str]
    Reference
    snippet str

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    vendors Sequence[str]
    Vendor
    affectedHost Property Map
    Affected host
    direction String
    Direction
    severity String
    Severity
    signature Property Map
    vulnerability protection signature
    threatId String
    threat id range \n\n and \n\n
    threatname String
    Threatname
    bugtraqs List<String>
    Bugtraq
    comment String
    Comment
    cves List<String>
    Cve
    defaultAction Property Map
    Default action
    device String
    The device in which the resource is defined
    folder String

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references List<String>
    Reference
    snippet String

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    vendors List<String>
    Vendor

    Outputs

    All input properties are implicitly available as output properties. Additionally, the VulnerabilityProtectionSignature resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Tfid string
    Id string
    The provider-assigned unique ID for this managed resource.
    Tfid string
    id String
    The provider-assigned unique ID for this managed resource.
    tfid String
    id string
    The provider-assigned unique ID for this managed resource.
    tfid string
    id str
    The provider-assigned unique ID for this managed resource.
    tfid str
    id String
    The provider-assigned unique ID for this managed resource.
    tfid String

    Look up Existing VulnerabilityProtectionSignature Resource

    Get an existing VulnerabilityProtectionSignature resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: VulnerabilityProtectionSignatureState, opts?: CustomResourceOptions): VulnerabilityProtectionSignature
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            affected_host: Optional[VulnerabilityProtectionSignatureAffectedHostArgs] = None,
            bugtraqs: Optional[Sequence[str]] = None,
            comment: Optional[str] = None,
            cves: Optional[Sequence[str]] = None,
            default_action: Optional[VulnerabilityProtectionSignatureDefaultActionArgs] = None,
            device: Optional[str] = None,
            direction: Optional[str] = None,
            folder: Optional[str] = None,
            references: Optional[Sequence[str]] = None,
            severity: Optional[str] = None,
            signature: Optional[VulnerabilityProtectionSignatureSignatureArgs] = None,
            snippet: Optional[str] = None,
            tfid: Optional[str] = None,
            threat_id: Optional[str] = None,
            threatname: Optional[str] = None,
            vendors: Optional[Sequence[str]] = None) -> VulnerabilityProtectionSignature
    func GetVulnerabilityProtectionSignature(ctx *Context, name string, id IDInput, state *VulnerabilityProtectionSignatureState, opts ...ResourceOption) (*VulnerabilityProtectionSignature, error)
    public static VulnerabilityProtectionSignature Get(string name, Input<string> id, VulnerabilityProtectionSignatureState? state, CustomResourceOptions? opts = null)
    public static VulnerabilityProtectionSignature get(String name, Output<String> id, VulnerabilityProtectionSignatureState state, CustomResourceOptions options)
    resources:  _:    type: scm:VulnerabilityProtectionSignature    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AffectedHost VulnerabilityProtectionSignatureAffectedHost
    Affected host
    Bugtraqs List<string>
    Bugtraq
    Comment string
    Comment
    Cves List<string>
    Cve
    DefaultAction VulnerabilityProtectionSignatureDefaultAction
    Default action
    Device string
    The device in which the resource is defined
    Direction string
    Direction
    Folder string

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    References List<string>
    Reference
    Severity string
    Severity
    Signature VulnerabilityProtectionSignatureSignature
    vulnerability protection signature
    Snippet string

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    Tfid string
    ThreatId string
    threat id range \n\n and \n\n
    Threatname string
    Threatname
    Vendors List<string>
    Vendor
    AffectedHost VulnerabilityProtectionSignatureAffectedHostArgs
    Affected host
    Bugtraqs []string
    Bugtraq
    Comment string
    Comment
    Cves []string
    Cve
    DefaultAction VulnerabilityProtectionSignatureDefaultActionArgs
    Default action
    Device string
    The device in which the resource is defined
    Direction string
    Direction
    Folder string

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    References []string
    Reference
    Severity string
    Severity
    Signature VulnerabilityProtectionSignatureSignatureArgs
    vulnerability protection signature
    Snippet string

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    Tfid string
    ThreatId string
    threat id range \n\n and \n\n
    Threatname string
    Threatname
    Vendors []string
    Vendor
    affectedHost VulnerabilityProtectionSignatureAffectedHost
    Affected host
    bugtraqs List<String>
    Bugtraq
    comment String
    Comment
    cves List<String>
    Cve
    defaultAction VulnerabilityProtectionSignatureDefaultAction
    Default action
    device String
    The device in which the resource is defined
    direction String
    Direction
    folder String

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references List<String>
    Reference
    severity String
    Severity
    signature VulnerabilityProtectionSignatureSignature
    vulnerability protection signature
    snippet String

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    tfid String
    threatId String
    threat id range \n\n and \n\n
    threatname String
    Threatname
    vendors List<String>
    Vendor
    affectedHost VulnerabilityProtectionSignatureAffectedHost
    Affected host
    bugtraqs string[]
    Bugtraq
    comment string
    Comment
    cves string[]
    Cve
    defaultAction VulnerabilityProtectionSignatureDefaultAction
    Default action
    device string
    The device in which the resource is defined
    direction string
    Direction
    folder string

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references string[]
    Reference
    severity string
    Severity
    signature VulnerabilityProtectionSignatureSignature
    vulnerability protection signature
    snippet string

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    tfid string
    threatId string
    threat id range \n\n and \n\n
    threatname string
    Threatname
    vendors string[]
    Vendor
    affected_host VulnerabilityProtectionSignatureAffectedHostArgs
    Affected host
    bugtraqs Sequence[str]
    Bugtraq
    comment str
    Comment
    cves Sequence[str]
    Cve
    default_action VulnerabilityProtectionSignatureDefaultActionArgs
    Default action
    device str
    The device in which the resource is defined
    direction str
    Direction
    folder str

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references Sequence[str]
    Reference
    severity str
    Severity
    signature VulnerabilityProtectionSignatureSignatureArgs
    vulnerability protection signature
    snippet str

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    tfid str
    threat_id str
    threat id range \n\n and \n\n
    threatname str
    Threatname
    vendors Sequence[str]
    Vendor
    affectedHost Property Map
    Affected host
    bugtraqs List<String>
    Bugtraq
    comment String
    Comment
    cves List<String>
    Cve
    defaultAction Property Map
    Default action
    device String
    The device in which the resource is defined
    direction String
    Direction
    folder String

    The folder in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    references List<String>
    Reference
    severity String
    Severity
    signature Property Map
    vulnerability protection signature
    snippet String

    The snippet in which the resource is defined

    ℹ️ Note: You must specify exactly one of device, folder, and snippet.

    tfid String
    threatId String
    threat id range \n\n and \n\n
    threatname String
    Threatname
    vendors List<String>
    Vendor

    Supporting Types

    VulnerabilityProtectionSignatureAffectedHost, VulnerabilityProtectionSignatureAffectedHostArgs

    Client bool
    Client
    Server bool

    Server

    ℹ️ Note: You must specify exactly one of client and server.

    Client bool
    Client
    Server bool

    Server

    ℹ️ Note: You must specify exactly one of client and server.

    client Boolean
    Client
    server Boolean

    Server

    ℹ️ Note: You must specify exactly one of client and server.

    client boolean
    Client
    server boolean

    Server

    ℹ️ Note: You must specify exactly one of client and server.

    client bool
    Client
    server bool

    Server

    ℹ️ Note: You must specify exactly one of client and server.

    client Boolean
    Client
    server Boolean

    Server

    ℹ️ Note: You must specify exactly one of client and server.

    VulnerabilityProtectionSignatureDefaultAction, VulnerabilityProtectionSignatureDefaultActionArgs

    Alert VulnerabilityProtectionSignatureDefaultActionAlert
    Alert
    Allow VulnerabilityProtectionSignatureDefaultActionAllow

    Allow

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    BlockIp VulnerabilityProtectionSignatureDefaultActionBlockIp

    vulnerability protection bugtraq block ip

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    Drop VulnerabilityProtectionSignatureDefaultActionDrop

    Drop

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    ResetBoth VulnerabilityProtectionSignatureDefaultActionResetBoth

    Reset both

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    ResetClient VulnerabilityProtectionSignatureDefaultActionResetClient

    Reset client

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    ResetServer VulnerabilityProtectionSignatureDefaultActionResetServer

    Reset server

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    Alert VulnerabilityProtectionSignatureDefaultActionAlert
    Alert
    Allow VulnerabilityProtectionSignatureDefaultActionAllow

    Allow

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    BlockIp VulnerabilityProtectionSignatureDefaultActionBlockIp

    vulnerability protection bugtraq block ip

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    Drop VulnerabilityProtectionSignatureDefaultActionDrop

    Drop

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    ResetBoth VulnerabilityProtectionSignatureDefaultActionResetBoth

    Reset both

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    ResetClient VulnerabilityProtectionSignatureDefaultActionResetClient

    Reset client

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    ResetServer VulnerabilityProtectionSignatureDefaultActionResetServer

    Reset server

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    alert VulnerabilityProtectionSignatureDefaultActionAlert
    Alert
    allow VulnerabilityProtectionSignatureDefaultActionAllow

    Allow

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    blockIp VulnerabilityProtectionSignatureDefaultActionBlockIp

    vulnerability protection bugtraq block ip

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    drop VulnerabilityProtectionSignatureDefaultActionDrop

    Drop

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetBoth VulnerabilityProtectionSignatureDefaultActionResetBoth

    Reset both

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetClient VulnerabilityProtectionSignatureDefaultActionResetClient

    Reset client

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetServer VulnerabilityProtectionSignatureDefaultActionResetServer

    Reset server

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    alert VulnerabilityProtectionSignatureDefaultActionAlert
    Alert
    allow VulnerabilityProtectionSignatureDefaultActionAllow

    Allow

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    blockIp VulnerabilityProtectionSignatureDefaultActionBlockIp

    vulnerability protection bugtraq block ip

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    drop VulnerabilityProtectionSignatureDefaultActionDrop

    Drop

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetBoth VulnerabilityProtectionSignatureDefaultActionResetBoth

    Reset both

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetClient VulnerabilityProtectionSignatureDefaultActionResetClient

    Reset client

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetServer VulnerabilityProtectionSignatureDefaultActionResetServer

    Reset server

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    alert VulnerabilityProtectionSignatureDefaultActionAlert
    Alert
    allow VulnerabilityProtectionSignatureDefaultActionAllow

    Allow

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    block_ip VulnerabilityProtectionSignatureDefaultActionBlockIp

    vulnerability protection bugtraq block ip

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    drop VulnerabilityProtectionSignatureDefaultActionDrop

    Drop

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    reset_both VulnerabilityProtectionSignatureDefaultActionResetBoth

    Reset both

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    reset_client VulnerabilityProtectionSignatureDefaultActionResetClient

    Reset client

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    reset_server VulnerabilityProtectionSignatureDefaultActionResetServer

    Reset server

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    alert Property Map
    Alert
    allow Property Map

    Allow

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    blockIp Property Map

    vulnerability protection bugtraq block ip

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    drop Property Map

    Drop

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetBoth Property Map

    Reset both

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetClient Property Map

    Reset client

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    resetServer Property Map

    Reset server

    ℹ️ Note: You must specify exactly one of alert, allow, block_ip, drop, reset_both, reset_client, and reset_server.

    VulnerabilityProtectionSignatureDefaultActionBlockIp, VulnerabilityProtectionSignatureDefaultActionBlockIpArgs

    Duration int
    Duration
    TrackBy string
    Track by
    Duration int
    Duration
    TrackBy string
    Track by
    duration Integer
    Duration
    trackBy String
    Track by
    duration number
    Duration
    trackBy string
    Track by
    duration int
    Duration
    track_by str
    Track by
    duration Number
    Duration
    trackBy String
    Track by

    VulnerabilityProtectionSignatureSignature, VulnerabilityProtectionSignatureSignatureArgs

    Combination VulnerabilityProtectionSignatureSignatureCombination
    vulnerability protection signature combination object
    Standards List<VulnerabilityProtectionSignatureSignatureStandard>

    vulnerability protection signature standard array

    ℹ️ Note: You must specify exactly one of combination and standard.

    Combination VulnerabilityProtectionSignatureSignatureCombination
    vulnerability protection signature combination object
    Standards []VulnerabilityProtectionSignatureSignatureStandard

    vulnerability protection signature standard array

    ℹ️ Note: You must specify exactly one of combination and standard.

    combination VulnerabilityProtectionSignatureSignatureCombination
    vulnerability protection signature combination object
    standards List<VulnerabilityProtectionSignatureSignatureStandard>

    vulnerability protection signature standard array

    ℹ️ Note: You must specify exactly one of combination and standard.

    combination VulnerabilityProtectionSignatureSignatureCombination
    vulnerability protection signature combination object
    standards VulnerabilityProtectionSignatureSignatureStandard[]

    vulnerability protection signature standard array

    ℹ️ Note: You must specify exactly one of combination and standard.

    combination VulnerabilityProtectionSignatureSignatureCombination
    vulnerability protection signature combination object
    standards Sequence[VulnerabilityProtectionSignatureSignatureStandard]

    vulnerability protection signature standard array

    ℹ️ Note: You must specify exactly one of combination and standard.

    combination Property Map
    vulnerability protection signature combination object
    standards List<Property Map>

    vulnerability protection signature standard array

    ℹ️ Note: You must specify exactly one of combination and standard.

    VulnerabilityProtectionSignatureSignatureCombination, VulnerabilityProtectionSignatureSignatureCombinationArgs

    andConditions List<Property Map>
    vulnerability protection signature combination object and condition
    orderFree Boolean
    Order free
    timeAttribute Property Map
    Time attribute

    VulnerabilityProtectionSignatureSignatureCombinationAndCondition, VulnerabilityProtectionSignatureSignatureCombinationAndConditionArgs

    Name string
    Name
    OrConditions List<VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrCondition>
    vulnerability protection signature combination object and condition object or condition
    Name string
    Name
    OrConditions []VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrCondition
    vulnerability protection signature combination object and condition object or condition
    name String
    Name
    orConditions List<VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrCondition>
    vulnerability protection signature combination object and condition object or condition
    name string
    Name
    orConditions VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrCondition[]
    vulnerability protection signature combination object and condition object or condition
    name str
    Name
    or_conditions Sequence[VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrCondition]
    vulnerability protection signature combination object and condition object or condition
    name String
    Name
    orConditions List<Property Map>
    vulnerability protection signature combination object and condition object or condition

    VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrCondition, VulnerabilityProtectionSignatureSignatureCombinationAndConditionOrConditionArgs

    Name string
    Name
    ThreatId string
    Threat id
    Name string
    Name
    ThreatId string
    Threat id
    name String
    Name
    threatId String
    Threat id
    name string
    Name
    threatId string
    Threat id
    name str
    Name
    threat_id str
    Threat id
    name String
    Name
    threatId String
    Threat id

    VulnerabilityProtectionSignatureSignatureCombinationTimeAttribute, VulnerabilityProtectionSignatureSignatureCombinationTimeAttributeArgs

    Interval int
    Interval
    Threshold int
    Threshold
    TrackBy string
    Track by
    Interval int
    Interval
    Threshold int
    Threshold
    TrackBy string
    Track by
    interval Integer
    Interval
    threshold Integer
    Threshold
    trackBy String
    Track by
    interval number
    Interval
    threshold number
    Threshold
    trackBy string
    Track by
    interval int
    Interval
    threshold int
    Threshold
    track_by str
    Track by
    interval Number
    Interval
    threshold Number
    Threshold
    trackBy String
    Track by

    VulnerabilityProtectionSignatureSignatureStandard, VulnerabilityProtectionSignatureSignatureStandardArgs

    Name string
    Name
    AndConditions List<VulnerabilityProtectionSignatureSignatureStandardAndCondition>
    vulnerability protection signature standard object and condition
    Comment string
    Comment
    OrderFree bool
    Order free
    Scope string
    Scope
    Name string
    Name
    AndConditions []VulnerabilityProtectionSignatureSignatureStandardAndCondition
    vulnerability protection signature standard object and condition
    Comment string
    Comment
    OrderFree bool
    Order free
    Scope string
    Scope
    name String
    Name
    andConditions List<VulnerabilityProtectionSignatureSignatureStandardAndCondition>
    vulnerability protection signature standard object and condition
    comment String
    Comment
    orderFree Boolean
    Order free
    scope String
    Scope
    name string
    Name
    andConditions VulnerabilityProtectionSignatureSignatureStandardAndCondition[]
    vulnerability protection signature standard object and condition
    comment string
    Comment
    orderFree boolean
    Order free
    scope string
    Scope
    name str
    Name
    and_conditions Sequence[VulnerabilityProtectionSignatureSignatureStandardAndCondition]
    vulnerability protection signature standard object and condition
    comment str
    Comment
    order_free bool
    Order free
    scope str
    Scope
    name String
    Name
    andConditions List<Property Map>
    vulnerability protection signature standard object and condition
    comment String
    Comment
    orderFree Boolean
    Order free
    scope String
    Scope

    VulnerabilityProtectionSignatureSignatureStandardAndCondition, VulnerabilityProtectionSignatureSignatureStandardAndConditionArgs

    Name string
    Name
    OrConditions List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrCondition>
    vulnerability protection signature standard object and condition object or condition
    Name string
    Name
    OrConditions []VulnerabilityProtectionSignatureSignatureStandardAndConditionOrCondition
    vulnerability protection signature standard object and condition object or condition
    name String
    Name
    orConditions List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrCondition>
    vulnerability protection signature standard object and condition object or condition
    name string
    Name
    orConditions VulnerabilityProtectionSignatureSignatureStandardAndConditionOrCondition[]
    vulnerability protection signature standard object and condition object or condition
    name str
    Name
    or_conditions Sequence[VulnerabilityProtectionSignatureSignatureStandardAndConditionOrCondition]
    vulnerability protection signature standard object and condition object or condition
    name String
    Name
    orConditions List<Property Map>
    vulnerability protection signature standard object and condition object or condition

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrCondition, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionArgs

    Name string
    Name
    Operator VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperator
    vulnerability protection signature standard object and condition object or condition object operators
    Name string
    Name
    Operator VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperator
    vulnerability protection signature standard object and condition object or condition object operators
    name String
    Name
    operator VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperator
    vulnerability protection signature standard object and condition object or condition object operators
    name string
    Name
    operator VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperator
    vulnerability protection signature standard object and condition object or condition object operators
    name str
    Name
    operator VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperator
    vulnerability protection signature standard object and condition object or condition object operators
    name String
    Name
    operator Property Map
    vulnerability protection signature standard object and condition object or condition object operators

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperator, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorArgs

    EqualTo VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualTo
    vulnerability protection signature standard object and condition object or condition object operators equal*to
    GreaterThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThan
    vulnerability protection signature standard object and condition object or condition object operators greater*than
    LessThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThan
    vulnerability protection signature standard object and condition object or condition object operators less*than
    PatternMatch VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatch
    vulnerability protection signature standard object and condition object or condition object operators pattern match
    EqualTo VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualTo
    vulnerability protection signature standard object and condition object or condition object operators equal*to
    GreaterThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThan
    vulnerability protection signature standard object and condition object or condition object operators greater*than
    LessThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThan
    vulnerability protection signature standard object and condition object or condition object operators less*than
    PatternMatch VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatch
    vulnerability protection signature standard object and condition object or condition object operators pattern match
    equalTo VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualTo
    vulnerability protection signature standard object and condition object or condition object operators equal*to
    greaterThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThan
    vulnerability protection signature standard object and condition object or condition object operators greater*than
    lessThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThan
    vulnerability protection signature standard object and condition object or condition object operators less*than
    patternMatch VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatch
    vulnerability protection signature standard object and condition object or condition object operators pattern match
    equalTo VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualTo
    vulnerability protection signature standard object and condition object or condition object operators equal*to
    greaterThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThan
    vulnerability protection signature standard object and condition object or condition object operators greater*than
    lessThan VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThan
    vulnerability protection signature standard object and condition object or condition object operators less*than
    patternMatch VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatch
    vulnerability protection signature standard object and condition object or condition object operators pattern match
    equal_to VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualTo
    vulnerability protection signature standard object and condition object or condition object operators equal*to
    greater_than VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThan
    vulnerability protection signature standard object and condition object or condition object operators greater*than
    less_than VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThan
    vulnerability protection signature standard object and condition object or condition object operators less*than
    pattern_match VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatch
    vulnerability protection signature standard object and condition object or condition object operators pattern match
    equalTo Property Map
    vulnerability protection signature standard object and condition object or condition object operators equal*to
    greaterThan Property Map
    vulnerability protection signature standard object and condition object or condition object operators greater*than
    lessThan Property Map
    vulnerability protection signature standard object and condition object or condition object operators less*than
    patternMatch Property Map
    vulnerability protection signature standard object and condition object or condition object operators pattern match

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualTo, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToArgs

    Context string
    Context
    Negate bool
    Negate
    Qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifier>
    vulnerability protection signature standard object and condition object or condition object operators equal*to qualifier array
    Value int
    Value
    Context string
    Context
    Negate bool
    Negate
    Qualifiers []VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifier
    vulnerability protection signature standard object and condition object or condition object operators equal*to qualifier array
    Value int
    Value
    context String
    Context
    negate Boolean
    Negate
    qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifier>
    vulnerability protection signature standard object and condition object or condition object operators equal*to qualifier array
    value Integer
    Value
    context string
    Context
    negate boolean
    Negate
    qualifiers VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifier[]
    vulnerability protection signature standard object and condition object or condition object operators equal*to qualifier array
    value number
    Value
    context str
    Context
    negate bool
    Negate
    qualifiers Sequence[VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifier]
    vulnerability protection signature standard object and condition object or condition object operators equal*to qualifier array
    value int
    Value
    context String
    Context
    negate Boolean
    Negate
    qualifiers List<Property Map>
    vulnerability protection signature standard object and condition object or condition object operators equal*to qualifier array
    value Number
    Value

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifier, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorEqualToQualifierArgs

    Name string
    Name
    Value string
    Value
    Name string
    Name
    Value string
    Value
    name String
    Name
    value String
    Value
    name string
    Name
    value string
    Value
    name str
    Name
    value str
    Value
    name String
    Name
    value String
    Value

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThan, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanArgs

    Context string
    Context
    Qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifier>
    vulnerability protection signature standard object and condition object or condition object operators greater*than qualifier
    Value int
    Value
    Context string
    Context
    Qualifiers []VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifier
    vulnerability protection signature standard object and condition object or condition object operators greater*than qualifier
    Value int
    Value
    context String
    Context
    qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifier>
    vulnerability protection signature standard object and condition object or condition object operators greater*than qualifier
    value Integer
    Value
    context string
    Context
    qualifiers VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifier[]
    vulnerability protection signature standard object and condition object or condition object operators greater*than qualifier
    value number
    Value
    context str
    Context
    qualifiers Sequence[VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifier]
    vulnerability protection signature standard object and condition object or condition object operators greater*than qualifier
    value int
    Value
    context String
    Context
    qualifiers List<Property Map>
    vulnerability protection signature standard object and condition object or condition object operators greater*than qualifier
    value Number
    Value

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifier, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorGreaterThanQualifierArgs

    Name string
    Name
    Value string
    Value
    Name string
    Name
    Value string
    Value
    name String
    Name
    value String
    Value
    name string
    Name
    value string
    Value
    name str
    Name
    value str
    Value
    name String
    Name
    value String
    Value

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThan, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanArgs

    Context string
    Context
    Qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifier>
    vulnerability protection signature standard object and condition object or condition object operators less*than array
    Value int
    Value
    Context string
    Context
    Qualifiers []VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifier
    vulnerability protection signature standard object and condition object or condition object operators less*than array
    Value int
    Value
    context String
    Context
    qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifier>
    vulnerability protection signature standard object and condition object or condition object operators less*than array
    value Integer
    Value
    context string
    Context
    qualifiers VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifier[]
    vulnerability protection signature standard object and condition object or condition object operators less*than array
    value number
    Value
    context str
    Context
    qualifiers Sequence[VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifier]
    vulnerability protection signature standard object and condition object or condition object operators less*than array
    value int
    Value
    context String
    Context
    qualifiers List<Property Map>
    vulnerability protection signature standard object and condition object or condition object operators less*than array
    value Number
    Value

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifier, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorLessThanQualifierArgs

    Name string
    Name
    Value string
    Value
    Name string
    Name
    Value string
    Value
    name String
    Name
    value String
    Value
    name string
    Name
    value string
    Value
    name str
    Name
    value str
    Value
    name String
    Name
    value String
    Value

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatch, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchArgs

    Context string
    Context
    Negate bool
    Negate
    Pattern string
    Pattern
    Qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifier>
    vulnerability protection signature standard object and condition object or condition object operators pattern match qualifier
    Context string
    Context
    Negate bool
    Negate
    Pattern string
    Pattern
    Qualifiers []VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifier
    vulnerability protection signature standard object and condition object or condition object operators pattern match qualifier
    context String
    Context
    negate Boolean
    Negate
    pattern String
    Pattern
    qualifiers List<VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifier>
    vulnerability protection signature standard object and condition object or condition object operators pattern match qualifier
    context string
    Context
    negate boolean
    Negate
    pattern string
    Pattern
    qualifiers VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifier[]
    vulnerability protection signature standard object and condition object or condition object operators pattern match qualifier
    context str
    Context
    negate bool
    Negate
    pattern str
    Pattern
    qualifiers Sequence[VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifier]
    vulnerability protection signature standard object and condition object or condition object operators pattern match qualifier
    context String
    Context
    negate Boolean
    Negate
    pattern String
    Pattern
    qualifiers List<Property Map>
    vulnerability protection signature standard object and condition object or condition object operators pattern match qualifier

    VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifier, VulnerabilityProtectionSignatureSignatureStandardAndConditionOrConditionOperatorPatternMatchQualifierArgs

    Name string
    Name
    Value string
    Value
    Name string
    Name
    Value string
    Value
    name String
    Name
    value String
    Value
    name string
    Name
    value string
    Value
    name str
    Name
    value str
    Value
    name String
    Name
    value String
    Value

    Import

    The following command can be used to import a resource not managed by Terraform:

    bash

    $ pulumi import scm:index/vulnerabilityProtectionSignature:VulnerabilityProtectionSignature example folder:::id
    

    or

    bash

    $ pulumi import scm:index/vulnerabilityProtectionSignature:VulnerabilityProtectionSignature example :snippet::id
    

    or

    bash

    $ pulumi import scm:index/vulnerabilityProtectionSignature:VulnerabilityProtectionSignature example ::device:id
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    scm pulumi/pulumi-scm
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the scm Terraform Provider.
    scm logo
    Strata Cloud Manager v1.0.3 published on Thursday, Jan 22, 2026 by Pulumi
      Meet Neo: Your AI Platform Teammate