zpa.PolicyAccessForwardingRuleV2

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Retrieve Identity Provider ID
const _this = zpa.getIdPController({
    name: "Idp_Name",
});
// Retrieve SAML Attribute ID
const emailUserSso = zpa.getSAMLAttribute({
    name: "Email_Users",
    idpName: "Idp_Name",
});
// Retrieve SAML Attribute ID
const groupUser = zpa.getSAMLAttribute({
    name: "GroupName_Users",
    idpName: "Idp_Name",
});
// Retrieve SCIM Group ID
const a000 = zpa.getSCIMGroups({
    name: "A000",
    idpName: "Idp_Name",
});
// Retrieve SCIM Group ID
const b000 = zpa.getSCIMGroups({
    name: "B000",
    idpName: "Idp_Name",
});
// Create Segment Group
const thisSegmentGroup = new zpa.SegmentGroup("this", {
    name: "Example",
    description: "Example",
    enabled: true,
});
// Create Policy Access Rule V2
const thisPolicyAccessForwardingRuleV2 = new zpa.PolicyAccessForwardingRuleV2("this", {
    name: "Example",
    description: "Example",
    action: "BYPASS",
    conditions: [
        {
            operator: "OR",
            operands: [{
                objectType: "APP_GROUP",
                values: [thisSegmentGroup.id],
            }],
        },
        {
            operator: "OR",
            operands: [
                {
                    objectType: "SAML",
                    entryValues: [
                        {
                            rhs: "user1@acme.com",
                            lhs: emailUserSso.then(emailUserSso => emailUserSso.id),
                        },
                        {
                            rhs: "A000",
                            lhs: groupUser.then(groupUser => groupUser.id),
                        },
                    ],
                },
                {
                    objectType: "SCIM_GROUP",
                    entryValues: [
                        {
                            rhs: a000.then(a000 => a000.id),
                            lhs: _this.then(_this => _this.id),
                        },
                        {
                            rhs: b000.then(b000 => b000.id),
                            lhs: _this.then(_this => _this.id),
                        },
                    ],
                },
            ],
        },
        {
            operator: "OR",
            operands: [{
                objectType: "PLATFORM",
                entryValues: [
                    {
                        rhs: "true",
                        lhs: "linux",
                    },
                    {
                        rhs: "true",
                        lhs: "android",
                    },
                ],
            }],
        },
    ],
});

import pulumi
import pulumi_zpa as zpa
import zscaler_pulumi_zpa as zpa

# Retrieve Identity Provider ID
this = zpa.get_id_p_controller(name="Idp_Name")
# Retrieve SAML Attribute ID
email_user_sso = zpa.get_saml_attribute(name="Email_Users",
    idp_name="Idp_Name")
# Retrieve SAML Attribute ID
group_user = zpa.get_saml_attribute(name="GroupName_Users",
    idp_name="Idp_Name")
# Retrieve SCIM Group ID
a000 = zpa.get_scim_groups(name="A000",
    idp_name="Idp_Name")
# Retrieve SCIM Group ID
b000 = zpa.get_scim_groups(name="B000",
    idp_name="Idp_Name")
# Create Segment Group
this_segment_group = zpa.SegmentGroup("this",
    name="Example",
    description="Example",
    enabled=True)
# Create Policy Access Rule V2
this_policy_access_forwarding_rule_v2 = zpa.PolicyAccessForwardingRuleV2("this",
    name="Example",
    description="Example",
    action="BYPASS",
    conditions=[
        {
            "operator": "OR",
            "operands": [{
                "object_type": "APP_GROUP",
                "values": [this_segment_group.id],
            }],
        },
        {
            "operator": "OR",
            "operands": [
                {
                    "object_type": "SAML",
                    "entry_values": [
                        {
                            "rhs": "user1@acme.com",
                            "lhs": email_user_sso.id,
                        },
                        {
                            "rhs": "A000",
                            "lhs": group_user.id,
                        },
                    ],
                },
                {
                    "object_type": "SCIM_GROUP",
                    "entry_values": [
                        {
                            "rhs": a000.id,
                            "lhs": this.id,
                        },
                        {
                            "rhs": b000.id,
                            "lhs": this.id,
                        },
                    ],
                },
            ],
        },
        {
            "operator": "OR",
            "operands": [{
                "object_type": "PLATFORM",
                "entry_values": [
                    {
                        "rhs": "true",
                        "lhs": "linux",
                    },
                    {
                        "rhs": "true",
                        "lhs": "android",
                    },
                ],
            }],
        },
    ])

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/zscaler/pulumi-zpa/sdk/go/zpa"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Retrieve Identity Provider ID
		this, err := zpa.GetIdPController(ctx, &zpa.GetIdPControllerArgs{
			Name: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		// Retrieve SAML Attribute ID
		emailUserSso, err := zpa.GetSAMLAttribute(ctx, &zpa.GetSAMLAttributeArgs{
			Name:    pulumi.StringRef("Email_Users"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		// Retrieve SAML Attribute ID
		groupUser, err := zpa.GetSAMLAttribute(ctx, &zpa.GetSAMLAttributeArgs{
			Name:    pulumi.StringRef("GroupName_Users"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		// Retrieve SCIM Group ID
		a000, err := zpa.GetSCIMGroups(ctx, &zpa.GetSCIMGroupsArgs{
			Name:    pulumi.StringRef("A000"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		// Retrieve SCIM Group ID
		b000, err := zpa.GetSCIMGroups(ctx, &zpa.GetSCIMGroupsArgs{
			Name:    pulumi.StringRef("B000"),
			IdpName: pulumi.StringRef("Idp_Name"),
		}, nil)
		if err != nil {
			return err
		}
		// Create Segment Group
		thisSegmentGroup, err := zpa.NewSegmentGroup(ctx, "this", &zpa.SegmentGroupArgs{
			Name:        pulumi.String("Example"),
			Description: pulumi.String("Example"),
			Enabled:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create Policy Access Rule V2
		_, err = zpa.NewPolicyAccessForwardingRuleV2(ctx, "this", &zpa.PolicyAccessForwardingRuleV2Args{
			Name:        pulumi.String("Example"),
			Description: pulumi.String("Example"),
			Action:      pulumi.String("BYPASS"),
			Conditions: zpa.PolicyAccessForwardingRuleV2ConditionArray{
				&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
					Operator: pulumi.String("OR"),
					Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("APP_GROUP"),
							Values: pulumi.StringArray{
								thisSegmentGroup.ID(),
							},
						},
					},
				},
				&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
					Operator: pulumi.String("OR"),
					Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("SAML"),
							EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("user1@acme.com"),
									Lhs: pulumi.String(emailUserSso.Id),
								},
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("A000"),
									Lhs: pulumi.String(groupUser.Id),
								},
							},
						},
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("SCIM_GROUP"),
							EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String(a000.Id),
									Lhs: pulumi.String(this.Id),
								},
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String(b000.Id),
									Lhs: pulumi.String(this.Id),
								},
							},
						},
					},
				},
				&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
					Operator: pulumi.String("OR"),
					Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
							ObjectType: pulumi.String("PLATFORM"),
							EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("true"),
									Lhs: pulumi.String("linux"),
								},
								&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
									Rhs: pulumi.String("true"),
									Lhs: pulumi.String("android"),
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = Pulumi.Zpa;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Retrieve Identity Provider ID
    var @this = Zpa.GetIdPController.Invoke(new()
    {
        Name = "Idp_Name",
    });

    // Retrieve SAML Attribute ID
    var emailUserSso = Zpa.GetSAMLAttribute.Invoke(new()
    {
        Name = "Email_Users",
        IdpName = "Idp_Name",
    });

    // Retrieve SAML Attribute ID
    var groupUser = Zpa.GetSAMLAttribute.Invoke(new()
    {
        Name = "GroupName_Users",
        IdpName = "Idp_Name",
    });

    // Retrieve SCIM Group ID
    var a000 = Zpa.GetSCIMGroups.Invoke(new()
    {
        Name = "A000",
        IdpName = "Idp_Name",
    });

    // Retrieve SCIM Group ID
    var b000 = Zpa.GetSCIMGroups.Invoke(new()
    {
        Name = "B000",
        IdpName = "Idp_Name",
    });

    // Create Segment Group
    var thisSegmentGroup = new Zpa.SegmentGroup("this", new()
    {
        Name = "Example",
        Description = "Example",
        Enabled = true,
    });

    // Create Policy Access Rule V2
    var thisPolicyAccessForwardingRuleV2 = new Zpa.PolicyAccessForwardingRuleV2("this", new()
    {
        Name = "Example",
        Description = "Example",
        Action = "BYPASS",
        Conditions = new[]
        {
            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
            {
                Operator = "OR",
                Operands = new[]
                {
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "APP_GROUP",
                        Values = new[]
                        {
                            thisSegmentGroup.Id,
                        },
                    },
                },
            },
            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
            {
                Operator = "OR",
                Operands = new[]
                {
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "SAML",
                        EntryValues = new[]
                        {
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "user1@acme.com",
                                Lhs = emailUserSso.Apply(getSAMLAttributeResult => getSAMLAttributeResult.Id),
                            },
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "A000",
                                Lhs = groupUser.Apply(getSAMLAttributeResult => getSAMLAttributeResult.Id),
                            },
                        },
                    },
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "SCIM_GROUP",
                        EntryValues = new[]
                        {
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = a000.Apply(getSCIMGroupsResult => getSCIMGroupsResult.Id),
                                Lhs = @this.Apply(@this => @this.Apply(getIdPControllerResult => getIdPControllerResult.Id)),
                            },
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = b000.Apply(getSCIMGroupsResult => getSCIMGroupsResult.Id),
                                Lhs = @this.Apply(@this => @this.Apply(getIdPControllerResult => getIdPControllerResult.Id)),
                            },
                        },
                    },
                },
            },
            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
            {
                Operator = "OR",
                Operands = new[]
                {
                    new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                    {
                        ObjectType = "PLATFORM",
                        EntryValues = new[]
                        {
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "true",
                                Lhs = "linux",
                            },
                            new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                            {
                                Rhs = "true",
                                Lhs = "android",
                            },
                        },
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetIdPControllerArgs;
import com.pulumi.zpa.inputs.GetSAMLAttributeArgs;
import com.pulumi.zpa.inputs.GetSCIMGroupsArgs;
import com.pulumi.zpa.SegmentGroup;
import com.pulumi.zpa.SegmentGroupArgs;
import com.pulumi.zpa.PolicyAccessForwardingRuleV2;
import com.pulumi.zpa.PolicyAccessForwardingRuleV2Args;
import com.pulumi.zpa.inputs.PolicyAccessForwardingRuleV2ConditionArgs;
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) {
        // Retrieve Identity Provider ID
        final var this = ZpaFunctions.getIdPController(GetIdPControllerArgs.builder()
            .name("Idp_Name")
            .build());

        // Retrieve SAML Attribute ID
        final var emailUserSso = ZpaFunctions.getSAMLAttribute(GetSAMLAttributeArgs.builder()
            .name("Email_Users")
            .idpName("Idp_Name")
            .build());

        // Retrieve SAML Attribute ID
        final var groupUser = ZpaFunctions.getSAMLAttribute(GetSAMLAttributeArgs.builder()
            .name("GroupName_Users")
            .idpName("Idp_Name")
            .build());

        // Retrieve SCIM Group ID
        final var a000 = ZpaFunctions.getSCIMGroups(GetSCIMGroupsArgs.builder()
            .name("A000")
            .idpName("Idp_Name")
            .build());

        // Retrieve SCIM Group ID
        final var b000 = ZpaFunctions.getSCIMGroups(GetSCIMGroupsArgs.builder()
            .name("B000")
            .idpName("Idp_Name")
            .build());

        // Create Segment Group
        var thisSegmentGroup = new SegmentGroup("thisSegmentGroup", SegmentGroupArgs.builder()
            .name("Example")
            .description("Example")
            .enabled(true)
            .build());

        // Create Policy Access Rule V2
        var thisPolicyAccessForwardingRuleV2 = new PolicyAccessForwardingRuleV2("thisPolicyAccessForwardingRuleV2", PolicyAccessForwardingRuleV2Args.builder()
            .name("Example")
            .description("Example")
            .action("BYPASS")
            .conditions(            
                PolicyAccessForwardingRuleV2ConditionArgs.builder()
                    .operator("OR")
                    .operands(PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                        .objectType("APP_GROUP")
                        .values(thisSegmentGroup.id())
                        .build())
                    .build(),
                PolicyAccessForwardingRuleV2ConditionArgs.builder()
                    .operator("OR")
                    .operands(                    
                        PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                            .objectType("SAML")
                            .entryValues(                            
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs("user1@acme.com")
                                    .lhs(emailUserSso.id())
                                    .build(),
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs("A000")
                                    .lhs(groupUser.id())
                                    .build())
                            .build(),
                        PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                            .objectType("SCIM_GROUP")
                            .entryValues(                            
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs(a000.id())
                                    .lhs(this_.id())
                                    .build(),
                                PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                    .rhs(b000.id())
                                    .lhs(this_.id())
                                    .build())
                            .build())
                    .build(),
                PolicyAccessForwardingRuleV2ConditionArgs.builder()
                    .operator("OR")
                    .operands(PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
                        .objectType("PLATFORM")
                        .entryValues(                        
                            PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                .rhs("true")
                                .lhs("linux")
                                .build(),
                            PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                                .rhs("true")
                                .lhs("android")
                                .build())
                        .build())
                    .build())
            .build());

    }
}

resources:
  # Create Segment Group
  thisSegmentGroup:
    type: zpa:SegmentGroup
    name: this
    properties:
      name: Example
      description: Example
      enabled: true
  # Create Policy Access Rule V2
  thisPolicyAccessForwardingRuleV2:
    type: zpa:PolicyAccessForwardingRuleV2
    name: this
    properties:
      name: Example
      description: Example
      action: BYPASS
      conditions:
        - operator: OR
          operands:
            - objectType: APP_GROUP
              values:
                - ${thisSegmentGroup.id}
        - operator: OR
          operands:
            - objectType: SAML
              entryValues:
                - rhs: user1@acme.com
                  lhs: ${emailUserSso.id}
                - rhs: A000
                  lhs: ${groupUser.id}
            - objectType: SCIM_GROUP
              entryValues:
                - rhs: ${a000.id}
                  lhs: ${this.id}
                - rhs: ${b000.id}
                  lhs: ${this.id}
        - operator: OR
          operands:
            - objectType: PLATFORM
              entryValues:
                - rhs: 'true'
                  lhs: linux
                - rhs: 'true'
                  lhs: android
variables:
  # Retrieve Identity Provider ID
  this:
    fn::invoke:
      function: zpa:getIdPController
      arguments:
        name: Idp_Name
  # Retrieve SAML Attribute ID
  emailUserSso:
    fn::invoke:
      function: zpa:getSAMLAttribute
      arguments:
        name: Email_Users
        idpName: Idp_Name
  # Retrieve SAML Attribute ID
  groupUser:
    fn::invoke:
      function: zpa:getSAMLAttribute
      arguments:
        name: GroupName_Users
        idpName: Idp_Name
  # Retrieve SCIM Group ID
  a000:
    fn::invoke:
      function: zpa:getSCIMGroups
      arguments:
        name: A000
        idpName: Idp_Name
  # Retrieve SCIM Group ID
  b000:
    fn::invoke:
      function: zpa:getSCIMGroups
      arguments:
        name: B000
        idpName: Idp_Name

var policyAccessForwardingRuleV2Resource = new Zpa.PolicyAccessForwardingRuleV2("policyAccessForwardingRuleV2Resource", new()
{
    Action = "string",
    Conditions = new[]
    {
        new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionArgs
        {
            Id = "string",
            Operands = new[]
            {
                new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandArgs
                {
                    EntryValues = new[]
                    {
                        new Zpa.Inputs.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs
                        {
                            Lhs = "string",
                            Rhs = "string",
                        },
                    },
                    ObjectType = "string",
                    Values = new[]
                    {
                        "string",
                    },
                },
            },
            Operator = "string",
        },
    },
    Description = "string",
    MicrotenantId = "string",
    Name = "string",
});

example, err := zpa.NewPolicyAccessForwardingRuleV2(ctx, "policyAccessForwardingRuleV2Resource", &zpa.PolicyAccessForwardingRuleV2Args{
	Action: pulumi.String("string"),
	Conditions: zpa.PolicyAccessForwardingRuleV2ConditionArray{
		&zpa.PolicyAccessForwardingRuleV2ConditionArgs{
			Id: pulumi.String("string"),
			Operands: zpa.PolicyAccessForwardingRuleV2ConditionOperandArray{
				&zpa.PolicyAccessForwardingRuleV2ConditionOperandArgs{
					EntryValues: zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArray{
						&zpa.PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs{
							Lhs: pulumi.String("string"),
							Rhs: pulumi.String("string"),
						},
					},
					ObjectType: pulumi.String("string"),
					Values: pulumi.StringArray{
						pulumi.String("string"),
					},
				},
			},
			Operator: pulumi.String("string"),
		},
	},
	Description:   pulumi.String("string"),
	MicrotenantId: pulumi.String("string"),
	Name:          pulumi.String("string"),
})

var policyAccessForwardingRuleV2Resource = new PolicyAccessForwardingRuleV2("policyAccessForwardingRuleV2Resource", PolicyAccessForwardingRuleV2Args.builder()
    .action("string")
    .conditions(PolicyAccessForwardingRuleV2ConditionArgs.builder()
        .id("string")
        .operands(PolicyAccessForwardingRuleV2ConditionOperandArgs.builder()
            .entryValues(PolicyAccessForwardingRuleV2ConditionOperandEntryValueArgs.builder()
                .lhs("string")
                .rhs("string")
                .build())
            .objectType("string")
            .values("string")
            .build())
        .operator("string")
        .build())
    .description("string")
    .microtenantId("string")
    .name("string")
    .build());

policy_access_forwarding_rule_v2_resource = zpa.PolicyAccessForwardingRuleV2("policyAccessForwardingRuleV2Resource",
    action="string",
    conditions=[{
        "id": "string",
        "operands": [{
            "entry_values": [{
                "lhs": "string",
                "rhs": "string",
            }],
            "object_type": "string",
            "values": ["string"],
        }],
        "operator": "string",
    }],
    description="string",
    microtenant_id="string",
    name="string")

const policyAccessForwardingRuleV2Resource = new zpa.PolicyAccessForwardingRuleV2("policyAccessForwardingRuleV2Resource", {
    action: "string",
    conditions: [{
        id: "string",
        operands: [{
            entryValues: [{
                lhs: "string",
                rhs: "string",
            }],
            objectType: "string",
            values: ["string"],
        }],
        operator: "string",
    }],
    description: "string",
    microtenantId: "string",
    name: "string",
});

type: zpa:PolicyAccessForwardingRuleV2
properties:
    action: string
    conditions:
        - id: string
          operands:
            - entryValues:
                - lhs: string
                  rhs: string
              objectType: string
              values:
                - string
          operator: string
    description: string
    microtenantId: string
    name: string