scm.DecryptionRule

import * as pulumi from "@pulumi/pulumi";
import * as scm from "@pulumi/scm";

// --- 1. TAG Resource ---
const decryptionPositionTag = new scm.Tag("decryption_position_tag", {
    name: "decryption-position-tag",
    folder: "All",
    color: "Purple",
});
// --- 2. ANCHOR DECRYPTION RULE (Used for relative positioning) ---
const anchorDecryptionRule = new scm.DecryptionRule("anchor_decryption_rule", {
    name: "anchor-decryption-rule",
    description: "Base rule for testing 'before' and 'after' positioning.",
    folder: "All",
    position: "pre",
    action: "decrypt",
    froms: ["trust"],
    tos: ["untrust"],
    sources: ["any"],
    destinations: ["any"],
    services: ["service-https"],
    categories: ["high-risk"],
    sourceUsers: ["any"],
    type: {
        sslForwardProxy: {},
    },
    destinationHips: ["any"],
    tags: [decryptionPositionTag.name],
    logSuccess: true,
    logFail: true,
    disabled: false,
    negateSource: false,
    negateDestination: false,
});
// --- 3. ABSOLUTE POSITIONING Examples ("top" and "bottom") ---
const ruleTopDecryptionRule = new scm.DecryptionRule("rule_top_decryption_rule", {
    name: "top-absolute-decryption-rule",
    description: "Placed at the very TOP of the Decryption rulebase.",
    folder: "All",
    position: "pre",
    action: "no-decrypt",
    relativePosition: "top",
    froms: ["any"],
    tos: ["any"],
    sources: ["any"],
    destinations: ["any"],
    services: ["service-https"],
    categories: ["high-risk"],
    sourceUsers: ["any"],
    type: {
        sslForwardProxy: {},
    },
});
const ruleBottomDecryptionRule = new scm.DecryptionRule("rule_bottom_decryption_rule", {
    name: "bottom-absolute-decryption-rule",
    description: "Placed at the very BOTTOM of the Decryption rulebase.",
    folder: "All",
    position: "pre",
    action: "decrypt",
    relativePosition: "bottom",
    froms: ["any"],
    tos: ["any"],
    sources: ["any"],
    destinations: ["any"],
    services: ["service-https"],
    categories: ["high-risk"],
    sourceUsers: ["any"],
    type: {
        sslForwardProxy: {},
    },
});
// --- 4. RELATIVE POSITIONING Examples ("before" and "after") ---
const ruleBeforeAnchorDecryption = new scm.DecryptionRule("rule_before_anchor_decryption", {
    name: "before-anchor-decryption-rule",
    description: "Positioned immediately BEFORE the anchor-decryption-rule. Updating",
    folder: "All",
    position: "pre",
    action: "decrypt",
    relativePosition: "before",
    targetRule: anchorDecryptionRule.id,
    froms: ["trust"],
    tos: ["untrust"],
    sources: ["10.1.1.0/24"],
    destinations: ["any"],
    services: ["service-https"],
    categories: ["high-risk"],
    sourceUsers: ["any"],
    type: {
        sslForwardProxy: {},
    },
});
const ruleAfterAnchorDecryption = new scm.DecryptionRule("rule_after_anchor_decryption", {
    name: "after-anchor-decryption-rule_123",
    description: "Positioned immediately AFTER the anchor-decryption-rule.",
    folder: "All",
    position: "pre",
    action: "decrypt",
    relativePosition: "after",
    targetRule: anchorDecryptionRule.id,
    froms: ["any"],
    tos: ["untrust"],
    sources: ["any"],
    destinations: ["192.168.1.10"],
    services: ["service-https"],
    categories: ["any"],
    sourceUsers: ["any"],
    type: {
        sslForwardProxy: {},
    },
});

import pulumi
import pulumi_scm as scm

# --- 1. TAG Resource ---
decryption_position_tag = scm.Tag("decryption_position_tag",
    name="decryption-position-tag",
    folder="All",
    color="Purple")
# --- 2. ANCHOR DECRYPTION RULE (Used for relative positioning) ---
anchor_decryption_rule = scm.DecryptionRule("anchor_decryption_rule",
    name="anchor-decryption-rule",
    description="Base rule for testing 'before' and 'after' positioning.",
    folder="All",
    position="pre",
    action="decrypt",
    froms=["trust"],
    tos=["untrust"],
    sources=["any"],
    destinations=["any"],
    services=["service-https"],
    categories=["high-risk"],
    source_users=["any"],
    type={
        "ssl_forward_proxy": {},
    },
    destination_hips=["any"],
    tags=[decryption_position_tag.name],
    log_success=True,
    log_fail=True,
    disabled=False,
    negate_source=False,
    negate_destination=False)
# --- 3. ABSOLUTE POSITIONING Examples ("top" and "bottom") ---
rule_top_decryption_rule = scm.DecryptionRule("rule_top_decryption_rule",
    name="top-absolute-decryption-rule",
    description="Placed at the very TOP of the Decryption rulebase.",
    folder="All",
    position="pre",
    action="no-decrypt",
    relative_position="top",
    froms=["any"],
    tos=["any"],
    sources=["any"],
    destinations=["any"],
    services=["service-https"],
    categories=["high-risk"],
    source_users=["any"],
    type={
        "ssl_forward_proxy": {},
    })
rule_bottom_decryption_rule = scm.DecryptionRule("rule_bottom_decryption_rule",
    name="bottom-absolute-decryption-rule",
    description="Placed at the very BOTTOM of the Decryption rulebase.",
    folder="All",
    position="pre",
    action="decrypt",
    relative_position="bottom",
    froms=["any"],
    tos=["any"],
    sources=["any"],
    destinations=["any"],
    services=["service-https"],
    categories=["high-risk"],
    source_users=["any"],
    type={
        "ssl_forward_proxy": {},
    })
# --- 4. RELATIVE POSITIONING Examples ("before" and "after") ---
rule_before_anchor_decryption = scm.DecryptionRule("rule_before_anchor_decryption",
    name="before-anchor-decryption-rule",
    description="Positioned immediately BEFORE the anchor-decryption-rule. Updating",
    folder="All",
    position="pre",
    action="decrypt",
    relative_position="before",
    target_rule=anchor_decryption_rule.id,
    froms=["trust"],
    tos=["untrust"],
    sources=["10.1.1.0/24"],
    destinations=["any"],
    services=["service-https"],
    categories=["high-risk"],
    source_users=["any"],
    type={
        "ssl_forward_proxy": {},
    })
rule_after_anchor_decryption = scm.DecryptionRule("rule_after_anchor_decryption",
    name="after-anchor-decryption-rule_123",
    description="Positioned immediately AFTER the anchor-decryption-rule.",
    folder="All",
    position="pre",
    action="decrypt",
    relative_position="after",
    target_rule=anchor_decryption_rule.id,
    froms=["any"],
    tos=["untrust"],
    sources=["any"],
    destinations=["192.168.1.10"],
    services=["service-https"],
    categories=["any"],
    source_users=["any"],
    type={
        "ssl_forward_proxy": {},
    })

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 {
		// --- 1. TAG Resource ---
		decryptionPositionTag, err := scm.NewTag(ctx, "decryption_position_tag", &scm.TagArgs{
			Name:   pulumi.String("decryption-position-tag"),
			Folder: pulumi.String("All"),
			Color:  pulumi.String("Purple"),
		})
		if err != nil {
			return err
		}
		// --- 2. ANCHOR DECRYPTION RULE (Used for relative positioning) ---
		anchorDecryptionRule, err := scm.NewDecryptionRule(ctx, "anchor_decryption_rule", &scm.DecryptionRuleArgs{
			Name:        pulumi.String("anchor-decryption-rule"),
			Description: pulumi.String("Base rule for testing 'before' and 'after' positioning."),
			Folder:      pulumi.String("All"),
			Position:    pulumi.String("pre"),
			Action:      pulumi.String("decrypt"),
			Froms: pulumi.StringArray{
				pulumi.String("trust"),
			},
			Tos: pulumi.StringArray{
				pulumi.String("untrust"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("service-https"),
			},
			Categories: pulumi.StringArray{
				pulumi.String("high-risk"),
			},
			SourceUsers: pulumi.StringArray{
				pulumi.String("any"),
			},
			Type: &scm.DecryptionRuleTypeArgs{
				SslForwardProxy: &scm.DecryptionRuleTypeSslForwardProxyArgs{},
			},
			DestinationHips: pulumi.StringArray{
				pulumi.String("any"),
			},
			Tags: pulumi.StringArray{
				decryptionPositionTag.Name,
			},
			LogSuccess:        pulumi.Bool(true),
			LogFail:           pulumi.Bool(true),
			Disabled:          pulumi.Bool(false),
			NegateSource:      pulumi.Bool(false),
			NegateDestination: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// --- 3. ABSOLUTE POSITIONING Examples ("top" and "bottom") ---
		_, err = scm.NewDecryptionRule(ctx, "rule_top_decryption_rule", &scm.DecryptionRuleArgs{
			Name:             pulumi.String("top-absolute-decryption-rule"),
			Description:      pulumi.String("Placed at the very TOP of the Decryption rulebase."),
			Folder:           pulumi.String("All"),
			Position:         pulumi.String("pre"),
			Action:           pulumi.String("no-decrypt"),
			RelativePosition: pulumi.String("top"),
			Froms: pulumi.StringArray{
				pulumi.String("any"),
			},
			Tos: pulumi.StringArray{
				pulumi.String("any"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("service-https"),
			},
			Categories: pulumi.StringArray{
				pulumi.String("high-risk"),
			},
			SourceUsers: pulumi.StringArray{
				pulumi.String("any"),
			},
			Type: &scm.DecryptionRuleTypeArgs{
				SslForwardProxy: &scm.DecryptionRuleTypeSslForwardProxyArgs{},
			},
		})
		if err != nil {
			return err
		}
		_, err = scm.NewDecryptionRule(ctx, "rule_bottom_decryption_rule", &scm.DecryptionRuleArgs{
			Name:             pulumi.String("bottom-absolute-decryption-rule"),
			Description:      pulumi.String("Placed at the very BOTTOM of the Decryption rulebase."),
			Folder:           pulumi.String("All"),
			Position:         pulumi.String("pre"),
			Action:           pulumi.String("decrypt"),
			RelativePosition: pulumi.String("bottom"),
			Froms: pulumi.StringArray{
				pulumi.String("any"),
			},
			Tos: pulumi.StringArray{
				pulumi.String("any"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("service-https"),
			},
			Categories: pulumi.StringArray{
				pulumi.String("high-risk"),
			},
			SourceUsers: pulumi.StringArray{
				pulumi.String("any"),
			},
			Type: &scm.DecryptionRuleTypeArgs{
				SslForwardProxy: &scm.DecryptionRuleTypeSslForwardProxyArgs{},
			},
		})
		if err != nil {
			return err
		}
		// --- 4. RELATIVE POSITIONING Examples ("before" and "after") ---
		_, err = scm.NewDecryptionRule(ctx, "rule_before_anchor_decryption", &scm.DecryptionRuleArgs{
			Name:             pulumi.String("before-anchor-decryption-rule"),
			Description:      pulumi.String("Positioned immediately BEFORE the anchor-decryption-rule. Updating"),
			Folder:           pulumi.String("All"),
			Position:         pulumi.String("pre"),
			Action:           pulumi.String("decrypt"),
			RelativePosition: pulumi.String("before"),
			TargetRule:       anchorDecryptionRule.ID(),
			Froms: pulumi.StringArray{
				pulumi.String("trust"),
			},
			Tos: pulumi.StringArray{
				pulumi.String("untrust"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("10.1.1.0/24"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("service-https"),
			},
			Categories: pulumi.StringArray{
				pulumi.String("high-risk"),
			},
			SourceUsers: pulumi.StringArray{
				pulumi.String("any"),
			},
			Type: &scm.DecryptionRuleTypeArgs{
				SslForwardProxy: &scm.DecryptionRuleTypeSslForwardProxyArgs{},
			},
		})
		if err != nil {
			return err
		}
		_, err = scm.NewDecryptionRule(ctx, "rule_after_anchor_decryption", &scm.DecryptionRuleArgs{
			Name:             pulumi.String("after-anchor-decryption-rule_123"),
			Description:      pulumi.String("Positioned immediately AFTER the anchor-decryption-rule."),
			Folder:           pulumi.String("All"),
			Position:         pulumi.String("pre"),
			Action:           pulumi.String("decrypt"),
			RelativePosition: pulumi.String("after"),
			TargetRule:       anchorDecryptionRule.ID(),
			Froms: pulumi.StringArray{
				pulumi.String("any"),
			},
			Tos: pulumi.StringArray{
				pulumi.String("untrust"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("192.168.1.10"),
			},
			Services: pulumi.StringArray{
				pulumi.String("service-https"),
			},
			Categories: pulumi.StringArray{
				pulumi.String("any"),
			},
			SourceUsers: pulumi.StringArray{
				pulumi.String("any"),
			},
			Type: &scm.DecryptionRuleTypeArgs{
				SslForwardProxy: &scm.DecryptionRuleTypeSslForwardProxyArgs{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scm = Pulumi.Scm;

return await Deployment.RunAsync(() => 
{
    // --- 1. TAG Resource ---
    var decryptionPositionTag = new Scm.Tag("decryption_position_tag", new()
    {
        Name = "decryption-position-tag",
        Folder = "All",
        Color = "Purple",
    });

    // --- 2. ANCHOR DECRYPTION RULE (Used for relative positioning) ---
    var anchorDecryptionRule = new Scm.DecryptionRule("anchor_decryption_rule", new()
    {
        Name = "anchor-decryption-rule",
        Description = "Base rule for testing 'before' and 'after' positioning.",
        Folder = "All",
        Position = "pre",
        Action = "decrypt",
        Froms = new[]
        {
            "trust",
        },
        Tos = new[]
        {
            "untrust",
        },
        Sources = new[]
        {
            "any",
        },
        Destinations = new[]
        {
            "any",
        },
        Services = new[]
        {
            "service-https",
        },
        Categories = new[]
        {
            "high-risk",
        },
        SourceUsers = new[]
        {
            "any",
        },
        Type = new Scm.Inputs.DecryptionRuleTypeArgs
        {
            SslForwardProxy = null,
        },
        DestinationHips = new[]
        {
            "any",
        },
        Tags = new[]
        {
            decryptionPositionTag.Name,
        },
        LogSuccess = true,
        LogFail = true,
        Disabled = false,
        NegateSource = false,
        NegateDestination = false,
    });

    // --- 3. ABSOLUTE POSITIONING Examples ("top" and "bottom") ---
    var ruleTopDecryptionRule = new Scm.DecryptionRule("rule_top_decryption_rule", new()
    {
        Name = "top-absolute-decryption-rule",
        Description = "Placed at the very TOP of the Decryption rulebase.",
        Folder = "All",
        Position = "pre",
        Action = "no-decrypt",
        RelativePosition = "top",
        Froms = new[]
        {
            "any",
        },
        Tos = new[]
        {
            "any",
        },
        Sources = new[]
        {
            "any",
        },
        Destinations = new[]
        {
            "any",
        },
        Services = new[]
        {
            "service-https",
        },
        Categories = new[]
        {
            "high-risk",
        },
        SourceUsers = new[]
        {
            "any",
        },
        Type = new Scm.Inputs.DecryptionRuleTypeArgs
        {
            SslForwardProxy = null,
        },
    });

    var ruleBottomDecryptionRule = new Scm.DecryptionRule("rule_bottom_decryption_rule", new()
    {
        Name = "bottom-absolute-decryption-rule",
        Description = "Placed at the very BOTTOM of the Decryption rulebase.",
        Folder = "All",
        Position = "pre",
        Action = "decrypt",
        RelativePosition = "bottom",
        Froms = new[]
        {
            "any",
        },
        Tos = new[]
        {
            "any",
        },
        Sources = new[]
        {
            "any",
        },
        Destinations = new[]
        {
            "any",
        },
        Services = new[]
        {
            "service-https",
        },
        Categories = new[]
        {
            "high-risk",
        },
        SourceUsers = new[]
        {
            "any",
        },
        Type = new Scm.Inputs.DecryptionRuleTypeArgs
        {
            SslForwardProxy = null,
        },
    });

    // --- 4. RELATIVE POSITIONING Examples ("before" and "after") ---
    var ruleBeforeAnchorDecryption = new Scm.DecryptionRule("rule_before_anchor_decryption", new()
    {
        Name = "before-anchor-decryption-rule",
        Description = "Positioned immediately BEFORE the anchor-decryption-rule. Updating",
        Folder = "All",
        Position = "pre",
        Action = "decrypt",
        RelativePosition = "before",
        TargetRule = anchorDecryptionRule.Id,
        Froms = new[]
        {
            "trust",
        },
        Tos = new[]
        {
            "untrust",
        },
        Sources = new[]
        {
            "10.1.1.0/24",
        },
        Destinations = new[]
        {
            "any",
        },
        Services = new[]
        {
            "service-https",
        },
        Categories = new[]
        {
            "high-risk",
        },
        SourceUsers = new[]
        {
            "any",
        },
        Type = new Scm.Inputs.DecryptionRuleTypeArgs
        {
            SslForwardProxy = null,
        },
    });

    var ruleAfterAnchorDecryption = new Scm.DecryptionRule("rule_after_anchor_decryption", new()
    {
        Name = "after-anchor-decryption-rule_123",
        Description = "Positioned immediately AFTER the anchor-decryption-rule.",
        Folder = "All",
        Position = "pre",
        Action = "decrypt",
        RelativePosition = "after",
        TargetRule = anchorDecryptionRule.Id,
        Froms = new[]
        {
            "any",
        },
        Tos = new[]
        {
            "untrust",
        },
        Sources = new[]
        {
            "any",
        },
        Destinations = new[]
        {
            "192.168.1.10",
        },
        Services = new[]
        {
            "service-https",
        },
        Categories = new[]
        {
            "any",
        },
        SourceUsers = new[]
        {
            "any",
        },
        Type = new Scm.Inputs.DecryptionRuleTypeArgs
        {
            SslForwardProxy = null,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.Tag;
import com.pulumi.scm.TagArgs;
import com.pulumi.scm.DecryptionRule;
import com.pulumi.scm.DecryptionRuleArgs;
import com.pulumi.scm.inputs.DecryptionRuleTypeArgs;
import com.pulumi.scm.inputs.DecryptionRuleTypeSslForwardProxyArgs;
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) {
        // --- 1. TAG Resource ---
        var decryptionPositionTag = new Tag("decryptionPositionTag", TagArgs.builder()
            .name("decryption-position-tag")
            .folder("All")
            .color("Purple")
            .build());

        // --- 2. ANCHOR DECRYPTION RULE (Used for relative positioning) ---
        var anchorDecryptionRule = new DecryptionRule("anchorDecryptionRule", DecryptionRuleArgs.builder()
            .name("anchor-decryption-rule")
            .description("Base rule for testing 'before' and 'after' positioning.")
            .folder("All")
            .position("pre")
            .action("decrypt")
            .froms("trust")
            .tos("untrust")
            .sources("any")
            .destinations("any")
            .services("service-https")
            .categories("high-risk")
            .sourceUsers("any")
            .type(DecryptionRuleTypeArgs.builder()
                .sslForwardProxy(DecryptionRuleTypeSslForwardProxyArgs.builder()
                    .build())
                .build())
            .destinationHips("any")
            .tags(decryptionPositionTag.name())
            .logSuccess(true)
            .logFail(true)
            .disabled(false)
            .negateSource(false)
            .negateDestination(false)
            .build());

        // --- 3. ABSOLUTE POSITIONING Examples ("top" and "bottom") ---
        var ruleTopDecryptionRule = new DecryptionRule("ruleTopDecryptionRule", DecryptionRuleArgs.builder()
            .name("top-absolute-decryption-rule")
            .description("Placed at the very TOP of the Decryption rulebase.")
            .folder("All")
            .position("pre")
            .action("no-decrypt")
            .relativePosition("top")
            .froms("any")
            .tos("any")
            .sources("any")
            .destinations("any")
            .services("service-https")
            .categories("high-risk")
            .sourceUsers("any")
            .type(DecryptionRuleTypeArgs.builder()
                .sslForwardProxy(DecryptionRuleTypeSslForwardProxyArgs.builder()
                    .build())
                .build())
            .build());

        var ruleBottomDecryptionRule = new DecryptionRule("ruleBottomDecryptionRule", DecryptionRuleArgs.builder()
            .name("bottom-absolute-decryption-rule")
            .description("Placed at the very BOTTOM of the Decryption rulebase.")
            .folder("All")
            .position("pre")
            .action("decrypt")
            .relativePosition("bottom")
            .froms("any")
            .tos("any")
            .sources("any")
            .destinations("any")
            .services("service-https")
            .categories("high-risk")
            .sourceUsers("any")
            .type(DecryptionRuleTypeArgs.builder()
                .sslForwardProxy(DecryptionRuleTypeSslForwardProxyArgs.builder()
                    .build())
                .build())
            .build());

        // --- 4. RELATIVE POSITIONING Examples ("before" and "after") ---
        var ruleBeforeAnchorDecryption = new DecryptionRule("ruleBeforeAnchorDecryption", DecryptionRuleArgs.builder()
            .name("before-anchor-decryption-rule")
            .description("Positioned immediately BEFORE the anchor-decryption-rule. Updating")
            .folder("All")
            .position("pre")
            .action("decrypt")
            .relativePosition("before")
            .targetRule(anchorDecryptionRule.id())
            .froms("trust")
            .tos("untrust")
            .sources("10.1.1.0/24")
            .destinations("any")
            .services("service-https")
            .categories("high-risk")
            .sourceUsers("any")
            .type(DecryptionRuleTypeArgs.builder()
                .sslForwardProxy(DecryptionRuleTypeSslForwardProxyArgs.builder()
                    .build())
                .build())
            .build());

        var ruleAfterAnchorDecryption = new DecryptionRule("ruleAfterAnchorDecryption", DecryptionRuleArgs.builder()
            .name("after-anchor-decryption-rule_123")
            .description("Positioned immediately AFTER the anchor-decryption-rule.")
            .folder("All")
            .position("pre")
            .action("decrypt")
            .relativePosition("after")
            .targetRule(anchorDecryptionRule.id())
            .froms("any")
            .tos("untrust")
            .sources("any")
            .destinations("192.168.1.10")
            .services("service-https")
            .categories("any")
            .sourceUsers("any")
            .type(DecryptionRuleTypeArgs.builder()
                .sslForwardProxy(DecryptionRuleTypeSslForwardProxyArgs.builder()
                    .build())
                .build())
            .build());

    }
}

resources:
  # --- 1. TAG Resource ---
  decryptionPositionTag:
    type: scm:Tag
    name: decryption_position_tag
    properties:
      name: decryption-position-tag
      folder: All
      color: Purple
  # --- 2. ANCHOR DECRYPTION RULE (Used for relative positioning) ---
  anchorDecryptionRule:
    type: scm:DecryptionRule
    name: anchor_decryption_rule
    properties:
      name: anchor-decryption-rule
      description: Base rule for testing 'before' and 'after' positioning.
      folder: All
      position: pre
      action: decrypt
      froms: # Source security zone
        - trust
      tos: # Destination security zone
        - untrust
      sources: # Source addresses
        - any
      destinations: # Destination addresses
        - any
      services: # Services (e.g., standard HTTPS port)
        - service-https
      categories: # Destination URL Category
        - high-risk
      sourceUsers: # Source user/group
        - any
      type:
        sslForwardProxy: {}
      destinationHips:
        - any
      tags:
        - ${decryptionPositionTag.name}
      logSuccess: true
      logFail: true
      disabled: false
      negateSource: false
      negateDestination: false
  # --- 3. ABSOLUTE POSITIONING Examples ("top" and "bottom") ---
  ruleTopDecryptionRule:
    type: scm:DecryptionRule
    name: rule_top_decryption_rule
    properties:
      name: top-absolute-decryption-rule
      description: Placed at the very TOP of the Decryption rulebase.
      folder: All
      position: pre
      action: no-decrypt
      relativePosition: top
      froms:
        - any
      tos:
        - any
      sources:
        - any
      destinations:
        - any
      services:
        - service-https
      categories:
        - high-risk
      sourceUsers:
        - any
      type:
        sslForwardProxy: {}
  ruleBottomDecryptionRule:
    type: scm:DecryptionRule
    name: rule_bottom_decryption_rule
    properties:
      name: bottom-absolute-decryption-rule
      description: Placed at the very BOTTOM of the Decryption rulebase.
      folder: All
      position: pre
      action: decrypt
      relativePosition: bottom
      froms:
        - any
      tos:
        - any
      sources:
        - any
      destinations:
        - any
      services:
        - service-https
      categories:
        - high-risk
      sourceUsers:
        - any
      type:
        sslForwardProxy: {}
  # --- 4. RELATIVE POSITIONING Examples ("before" and "after") ---
  ruleBeforeAnchorDecryption:
    type: scm:DecryptionRule
    name: rule_before_anchor_decryption
    properties:
      name: before-anchor-decryption-rule
      description: Positioned immediately BEFORE the anchor-decryption-rule. Updating
      folder: All
      position: pre
      action: decrypt
      relativePosition: before
      targetRule: ${anchorDecryptionRule.id}
      froms:
        - trust
      tos:
        - untrust
      sources: # Specific source subnet
        - 10.1.1.0/24
      destinations:
        - any
      services:
        - service-https
      categories:
        - high-risk
      sourceUsers:
        - any
      type:
        sslForwardProxy: {}
  ruleAfterAnchorDecryption:
    type: scm:DecryptionRule
    name: rule_after_anchor_decryption
    properties:
      name: after-anchor-decryption-rule_123
      description: Positioned immediately AFTER the anchor-decryption-rule.
      folder: All
      position: pre
      action: decrypt
      relativePosition: after
      targetRule: ${anchorDecryptionRule.id}
      froms:
        - any
      tos:
        - untrust
      sources:
        - any
      destinations: # Specific destination host
        - 192.168.1.10
      services:
        - service-https
      categories:
        - any
      sourceUsers:
        - any
      type:
        sslForwardProxy: {}

var decryptionRuleResource = new Scm.DecryptionRule("decryptionRuleResource", new()
{
    Froms = new[]
    {
        "string",
    },
    Categories = new[]
    {
        "string",
    },
    Tos = new[]
    {
        "string",
    },
    Sources = new[]
    {
        "string",
    },
    Destinations = new[]
    {
        "string",
    },
    SourceUsers = new[]
    {
        "string",
    },
    Action = "string",
    Services = new[]
    {
        "string",
    },
    Disabled = false,
    RelativePosition = "string",
    LogSetting = "string",
    LogSuccess = false,
    Name = "string",
    NegateDestination = false,
    NegateSource = false,
    Position = "string",
    Profile = "string",
    LogFail = false,
    Folder = "string",
    Snippet = "string",
    SourceHips = new[]
    {
        "string",
    },
    Device = "string",
    DestinationHips = new[]
    {
        "string",
    },
    Tags = new[]
    {
        "string",
    },
    TargetRule = "string",
    Description = "string",
    Type = new Scm.Inputs.DecryptionRuleTypeArgs
    {
        SslForwardProxy = null,
        SslInboundInspection = "string",
    },
});

example, err := scm.NewDecryptionRule(ctx, "decryptionRuleResource", &scm.DecryptionRuleArgs{
	Froms: pulumi.StringArray{
		pulumi.String("string"),
	},
	Categories: pulumi.StringArray{
		pulumi.String("string"),
	},
	Tos: pulumi.StringArray{
		pulumi.String("string"),
	},
	Sources: pulumi.StringArray{
		pulumi.String("string"),
	},
	Destinations: pulumi.StringArray{
		pulumi.String("string"),
	},
	SourceUsers: pulumi.StringArray{
		pulumi.String("string"),
	},
	Action: pulumi.String("string"),
	Services: pulumi.StringArray{
		pulumi.String("string"),
	},
	Disabled:          pulumi.Bool(false),
	RelativePosition:  pulumi.String("string"),
	LogSetting:        pulumi.String("string"),
	LogSuccess:        pulumi.Bool(false),
	Name:              pulumi.String("string"),
	NegateDestination: pulumi.Bool(false),
	NegateSource:      pulumi.Bool(false),
	Position:          pulumi.String("string"),
	Profile:           pulumi.String("string"),
	LogFail:           pulumi.Bool(false),
	Folder:            pulumi.String("string"),
	Snippet:           pulumi.String("string"),
	SourceHips: pulumi.StringArray{
		pulumi.String("string"),
	},
	Device: pulumi.String("string"),
	DestinationHips: pulumi.StringArray{
		pulumi.String("string"),
	},
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	TargetRule:  pulumi.String("string"),
	Description: pulumi.String("string"),
	Type: &scm.DecryptionRuleTypeArgs{
		SslForwardProxy:      &scm.DecryptionRuleTypeSslForwardProxyArgs{},
		SslInboundInspection: pulumi.String("string"),
	},
})

var decryptionRuleResource = new DecryptionRule("decryptionRuleResource", DecryptionRuleArgs.builder()
    .froms("string")
    .categories("string")
    .tos("string")
    .sources("string")
    .destinations("string")
    .sourceUsers("string")
    .action("string")
    .services("string")
    .disabled(false)
    .relativePosition("string")
    .logSetting("string")
    .logSuccess(false)
    .name("string")
    .negateDestination(false)
    .negateSource(false)
    .position("string")
    .profile("string")
    .logFail(false)
    .folder("string")
    .snippet("string")
    .sourceHips("string")
    .device("string")
    .destinationHips("string")
    .tags("string")
    .targetRule("string")
    .description("string")
    .type(DecryptionRuleTypeArgs.builder()
        .sslForwardProxy(DecryptionRuleTypeSslForwardProxyArgs.builder()
            .build())
        .sslInboundInspection("string")
        .build())
    .build());

decryption_rule_resource = scm.DecryptionRule("decryptionRuleResource",
    froms=["string"],
    categories=["string"],
    tos=["string"],
    sources=["string"],
    destinations=["string"],
    source_users=["string"],
    action="string",
    services=["string"],
    disabled=False,
    relative_position="string",
    log_setting="string",
    log_success=False,
    name="string",
    negate_destination=False,
    negate_source=False,
    position="string",
    profile="string",
    log_fail=False,
    folder="string",
    snippet="string",
    source_hips=["string"],
    device="string",
    destination_hips=["string"],
    tags=["string"],
    target_rule="string",
    description="string",
    type={
        "ssl_forward_proxy": {},
        "ssl_inbound_inspection": "string",
    })

const decryptionRuleResource = new scm.DecryptionRule("decryptionRuleResource", {
    froms: ["string"],
    categories: ["string"],
    tos: ["string"],
    sources: ["string"],
    destinations: ["string"],
    sourceUsers: ["string"],
    action: "string",
    services: ["string"],
    disabled: false,
    relativePosition: "string",
    logSetting: "string",
    logSuccess: false,
    name: "string",
    negateDestination: false,
    negateSource: false,
    position: "string",
    profile: "string",
    logFail: false,
    folder: "string",
    snippet: "string",
    sourceHips: ["string"],
    device: "string",
    destinationHips: ["string"],
    tags: ["string"],
    targetRule: "string",
    description: "string",
    type: {
        sslForwardProxy: {},
        sslInboundInspection: "string",
    },
});