gitlab.ComplianceRequirement

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

// Example: Create a compliance requirement with an internal control
const internalControl = new gitlab.ComplianceRequirement("internal_control", {
    frameworkId: example.frameworkId,
    namespacePath: example.namespacePath,
    name: "Dependency Scanning Required",
    description: "Ensures dependency scanning is enabled and running",
    internalControls: [{
        name: "scanner_dep_scanning_running",
        expression: {
            field: "scanner_dep_scanning_running",
            operator: "=",
            value: "true",
        },
    }],
});
// Example: Create a compliance requirement with an external control
const externalControl = new gitlab.ComplianceRequirement("external_control", {
    frameworkId: example.frameworkId,
    namespacePath: example.namespacePath,
    name: "External Security Check",
    description: "Verifies compliance via an external security service",
    externalControls: [{
        externalUrl: "https://example.com/compliance-check",
        secretToken: "my-secret-token",
        pingEnabled: true,
    }],
});
// Example: Create a compliance requirement with an external control with all options
const externalControlAllOptions = new gitlab.ComplianceRequirement("external_control_all_options", {
    frameworkId: example.frameworkId,
    namespacePath: example.namespacePath,
    name: "External Security Check with All Options",
    description: "Verifies compliance via an external security service with all options configured",
    externalControls: [{
        externalUrl: "https://example.com/compliance-check",
        secretToken: "my-secret-token",
        externalControlName: "My External Control",
        pingEnabled: false,
    }],
});
// Example: Create a compliance requriement with both internal and external controls
const internalAndExternalControls = new gitlab.ComplianceRequirement("internal_and_external_controls", {
    frameworkId: example.frameworkId,
    namespacePath: example.namespacePath,
    name: "Combined Security Check",
    description: "Verifies compliance via both internal and external controls",
    internalControls: [{
        name: "scanner_dep_scanning_running",
        expression: {
            field: "scanner_dep_scanning_running",
            operator: "=",
            value: "true",
        },
    }],
    externalControls: [{
        externalUrl: "https://example.com/compliance-check",
        secretToken: "my-secret-token",
        pingEnabled: true,
    }],
});

import pulumi
import pulumi_gitlab as gitlab

# Example: Create a compliance requirement with an internal control
internal_control = gitlab.ComplianceRequirement("internal_control",
    framework_id=example["frameworkId"],
    namespace_path=example["namespacePath"],
    name="Dependency Scanning Required",
    description="Ensures dependency scanning is enabled and running",
    internal_controls=[{
        "name": "scanner_dep_scanning_running",
        "expression": {
            "field": "scanner_dep_scanning_running",
            "operator": "=",
            "value": "true",
        },
    }])
# Example: Create a compliance requirement with an external control
external_control = gitlab.ComplianceRequirement("external_control",
    framework_id=example["frameworkId"],
    namespace_path=example["namespacePath"],
    name="External Security Check",
    description="Verifies compliance via an external security service",
    external_controls=[{
        "external_url": "https://example.com/compliance-check",
        "secret_token": "my-secret-token",
        "ping_enabled": True,
    }])
# Example: Create a compliance requirement with an external control with all options
external_control_all_options = gitlab.ComplianceRequirement("external_control_all_options",
    framework_id=example["frameworkId"],
    namespace_path=example["namespacePath"],
    name="External Security Check with All Options",
    description="Verifies compliance via an external security service with all options configured",
    external_controls=[{
        "external_url": "https://example.com/compliance-check",
        "secret_token": "my-secret-token",
        "external_control_name": "My External Control",
        "ping_enabled": False,
    }])
# Example: Create a compliance requriement with both internal and external controls
internal_and_external_controls = gitlab.ComplianceRequirement("internal_and_external_controls",
    framework_id=example["frameworkId"],
    namespace_path=example["namespacePath"],
    name="Combined Security Check",
    description="Verifies compliance via both internal and external controls",
    internal_controls=[{
        "name": "scanner_dep_scanning_running",
        "expression": {
            "field": "scanner_dep_scanning_running",
            "operator": "=",
            "value": "true",
        },
    }],
    external_controls=[{
        "external_url": "https://example.com/compliance-check",
        "secret_token": "my-secret-token",
        "ping_enabled": True,
    }])

package main

import (
	"github.com/pulumi/pulumi-gitlab/sdk/v10/go/gitlab"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Example: Create a compliance requirement with an internal control
		_, err := gitlab.NewComplianceRequirement(ctx, "internal_control", &gitlab.ComplianceRequirementArgs{
			FrameworkId:   pulumi.Any(example.FrameworkId),
			NamespacePath: pulumi.Any(example.NamespacePath),
			Name:          pulumi.String("Dependency Scanning Required"),
			Description:   pulumi.String("Ensures dependency scanning is enabled and running"),
			InternalControls: gitlab.ComplianceRequirementInternalControlArray{
				&gitlab.ComplianceRequirementInternalControlArgs{
					Name: pulumi.String("scanner_dep_scanning_running"),
					Expression: &gitlab.ComplianceRequirementInternalControlExpressionArgs{
						Field:    pulumi.String("scanner_dep_scanning_running"),
						Operator: pulumi.String("="),
						Value:    pulumi.String("true"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Example: Create a compliance requirement with an external control
		_, err = gitlab.NewComplianceRequirement(ctx, "external_control", &gitlab.ComplianceRequirementArgs{
			FrameworkId:   pulumi.Any(example.FrameworkId),
			NamespacePath: pulumi.Any(example.NamespacePath),
			Name:          pulumi.String("External Security Check"),
			Description:   pulumi.String("Verifies compliance via an external security service"),
			ExternalControls: gitlab.ComplianceRequirementExternalControlArray{
				&gitlab.ComplianceRequirementExternalControlArgs{
					ExternalUrl: pulumi.String("https://example.com/compliance-check"),
					SecretToken: pulumi.String("my-secret-token"),
					PingEnabled: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example: Create a compliance requirement with an external control with all options
		_, err = gitlab.NewComplianceRequirement(ctx, "external_control_all_options", &gitlab.ComplianceRequirementArgs{
			FrameworkId:   pulumi.Any(example.FrameworkId),
			NamespacePath: pulumi.Any(example.NamespacePath),
			Name:          pulumi.String("External Security Check with All Options"),
			Description:   pulumi.String("Verifies compliance via an external security service with all options configured"),
			ExternalControls: gitlab.ComplianceRequirementExternalControlArray{
				&gitlab.ComplianceRequirementExternalControlArgs{
					ExternalUrl:         pulumi.String("https://example.com/compliance-check"),
					SecretToken:         pulumi.String("my-secret-token"),
					ExternalControlName: pulumi.String("My External Control"),
					PingEnabled:         pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		// Example: Create a compliance requriement with both internal and external controls
		_, err = gitlab.NewComplianceRequirement(ctx, "internal_and_external_controls", &gitlab.ComplianceRequirementArgs{
			FrameworkId:   pulumi.Any(example.FrameworkId),
			NamespacePath: pulumi.Any(example.NamespacePath),
			Name:          pulumi.String("Combined Security Check"),
			Description:   pulumi.String("Verifies compliance via both internal and external controls"),
			InternalControls: gitlab.ComplianceRequirementInternalControlArray{
				&gitlab.ComplianceRequirementInternalControlArgs{
					Name: pulumi.String("scanner_dep_scanning_running"),
					Expression: &gitlab.ComplianceRequirementInternalControlExpressionArgs{
						Field:    pulumi.String("scanner_dep_scanning_running"),
						Operator: pulumi.String("="),
						Value:    pulumi.String("true"),
					},
				},
			},
			ExternalControls: gitlab.ComplianceRequirementExternalControlArray{
				&gitlab.ComplianceRequirementExternalControlArgs{
					ExternalUrl: pulumi.String("https://example.com/compliance-check"),
					SecretToken: pulumi.String("my-secret-token"),
					PingEnabled: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Example: Create a compliance requirement with an internal control
    var internalControl = new GitLab.ComplianceRequirement("internal_control", new()
    {
        FrameworkId = example.FrameworkId,
        NamespacePath = example.NamespacePath,
        Name = "Dependency Scanning Required",
        Description = "Ensures dependency scanning is enabled and running",
        InternalControls = new[]
        {
            new GitLab.Inputs.ComplianceRequirementInternalControlArgs
            {
                Name = "scanner_dep_scanning_running",
                Expression = new GitLab.Inputs.ComplianceRequirementInternalControlExpressionArgs
                {
                    Field = "scanner_dep_scanning_running",
                    Operator = "=",
                    Value = "true",
                },
            },
        },
    });

    // Example: Create a compliance requirement with an external control
    var externalControl = new GitLab.ComplianceRequirement("external_control", new()
    {
        FrameworkId = example.FrameworkId,
        NamespacePath = example.NamespacePath,
        Name = "External Security Check",
        Description = "Verifies compliance via an external security service",
        ExternalControls = new[]
        {
            new GitLab.Inputs.ComplianceRequirementExternalControlArgs
            {
                ExternalUrl = "https://example.com/compliance-check",
                SecretToken = "my-secret-token",
                PingEnabled = true,
            },
        },
    });

    // Example: Create a compliance requirement with an external control with all options
    var externalControlAllOptions = new GitLab.ComplianceRequirement("external_control_all_options", new()
    {
        FrameworkId = example.FrameworkId,
        NamespacePath = example.NamespacePath,
        Name = "External Security Check with All Options",
        Description = "Verifies compliance via an external security service with all options configured",
        ExternalControls = new[]
        {
            new GitLab.Inputs.ComplianceRequirementExternalControlArgs
            {
                ExternalUrl = "https://example.com/compliance-check",
                SecretToken = "my-secret-token",
                ExternalControlName = "My External Control",
                PingEnabled = false,
            },
        },
    });

    // Example: Create a compliance requriement with both internal and external controls
    var internalAndExternalControls = new GitLab.ComplianceRequirement("internal_and_external_controls", new()
    {
        FrameworkId = example.FrameworkId,
        NamespacePath = example.NamespacePath,
        Name = "Combined Security Check",
        Description = "Verifies compliance via both internal and external controls",
        InternalControls = new[]
        {
            new GitLab.Inputs.ComplianceRequirementInternalControlArgs
            {
                Name = "scanner_dep_scanning_running",
                Expression = new GitLab.Inputs.ComplianceRequirementInternalControlExpressionArgs
                {
                    Field = "scanner_dep_scanning_running",
                    Operator = "=",
                    Value = "true",
                },
            },
        },
        ExternalControls = new[]
        {
            new GitLab.Inputs.ComplianceRequirementExternalControlArgs
            {
                ExternalUrl = "https://example.com/compliance-check",
                SecretToken = "my-secret-token",
                PingEnabled = true,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gitlab.ComplianceRequirement;
import com.pulumi.gitlab.ComplianceRequirementArgs;
import com.pulumi.gitlab.inputs.ComplianceRequirementInternalControlArgs;
import com.pulumi.gitlab.inputs.ComplianceRequirementInternalControlExpressionArgs;
import com.pulumi.gitlab.inputs.ComplianceRequirementExternalControlArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Example: Create a compliance requirement with an internal control
        var internalControl = new ComplianceRequirement("internalControl", ComplianceRequirementArgs.builder()
            .frameworkId(example.frameworkId())
            .namespacePath(example.namespacePath())
            .name("Dependency Scanning Required")
            .description("Ensures dependency scanning is enabled and running")
            .internalControls(ComplianceRequirementInternalControlArgs.builder()
                .name("scanner_dep_scanning_running")
                .expression(ComplianceRequirementInternalControlExpressionArgs.builder()
                    .field("scanner_dep_scanning_running")
                    .operator("=")
                    .value("true")
                    .build())
                .build())
            .build());

        // Example: Create a compliance requirement with an external control
        var externalControl = new ComplianceRequirement("externalControl", ComplianceRequirementArgs.builder()
            .frameworkId(example.frameworkId())
            .namespacePath(example.namespacePath())
            .name("External Security Check")
            .description("Verifies compliance via an external security service")
            .externalControls(ComplianceRequirementExternalControlArgs.builder()
                .externalUrl("https://example.com/compliance-check")
                .secretToken("my-secret-token")
                .pingEnabled(true)
                .build())
            .build());

        // Example: Create a compliance requirement with an external control with all options
        var externalControlAllOptions = new ComplianceRequirement("externalControlAllOptions", ComplianceRequirementArgs.builder()
            .frameworkId(example.frameworkId())
            .namespacePath(example.namespacePath())
            .name("External Security Check with All Options")
            .description("Verifies compliance via an external security service with all options configured")
            .externalControls(ComplianceRequirementExternalControlArgs.builder()
                .externalUrl("https://example.com/compliance-check")
                .secretToken("my-secret-token")
                .externalControlName("My External Control")
                .pingEnabled(false)
                .build())
            .build());

        // Example: Create a compliance requriement with both internal and external controls
        var internalAndExternalControls = new ComplianceRequirement("internalAndExternalControls", ComplianceRequirementArgs.builder()
            .frameworkId(example.frameworkId())
            .namespacePath(example.namespacePath())
            .name("Combined Security Check")
            .description("Verifies compliance via both internal and external controls")
            .internalControls(ComplianceRequirementInternalControlArgs.builder()
                .name("scanner_dep_scanning_running")
                .expression(ComplianceRequirementInternalControlExpressionArgs.builder()
                    .field("scanner_dep_scanning_running")
                    .operator("=")
                    .value("true")
                    .build())
                .build())
            .externalControls(ComplianceRequirementExternalControlArgs.builder()
                .externalUrl("https://example.com/compliance-check")
                .secretToken("my-secret-token")
                .pingEnabled(true)
                .build())
            .build());

    }
}

resources:
  # Example: Create a compliance requirement with an internal control
  internalControl:
    type: gitlab:ComplianceRequirement
    name: internal_control
    properties:
      frameworkId: ${example.frameworkId}
      namespacePath: ${example.namespacePath}
      name: Dependency Scanning Required
      description: Ensures dependency scanning is enabled and running
      internalControls:
        - name: scanner_dep_scanning_running
          expression:
            field: scanner_dep_scanning_running
            operator: =
            value: 'true'
  # Example: Create a compliance requirement with an external control
  externalControl:
    type: gitlab:ComplianceRequirement
    name: external_control
    properties:
      frameworkId: ${example.frameworkId}
      namespacePath: ${example.namespacePath}
      name: External Security Check
      description: Verifies compliance via an external security service
      externalControls:
        - externalUrl: https://example.com/compliance-check
          secretToken: my-secret-token
          pingEnabled: true
  # Example: Create a compliance requirement with an external control with all options
  externalControlAllOptions:
    type: gitlab:ComplianceRequirement
    name: external_control_all_options
    properties:
      frameworkId: ${example.frameworkId}
      namespacePath: ${example.namespacePath}
      name: External Security Check with All Options
      description: Verifies compliance via an external security service with all options configured
      externalControls:
        - externalUrl: https://example.com/compliance-check
          secretToken: my-secret-token
          externalControlName: My External Control
          pingEnabled: false
  # Example: Create a compliance requriement with both internal and external controls
  internalAndExternalControls:
    type: gitlab:ComplianceRequirement
    name: internal_and_external_controls
    properties:
      frameworkId: ${example.frameworkId}
      namespacePath: ${example.namespacePath}
      name: Combined Security Check
      description: Verifies compliance via both internal and external controls
      internalControls:
        - name: scanner_dep_scanning_running
          expression:
            field: scanner_dep_scanning_running
            operator: =
            value: 'true'
      externalControls:
        - externalUrl: https://example.com/compliance-check
          secretToken: my-secret-token
          pingEnabled: true

pulumi {
  required_providers {
    gitlab = {
      source = "pulumi/gitlab"
    }
  }
}

# Example: Create a compliance requirement with an internal control
resource "gitlab_compliancerequirement" "internal_control" {
  framework_id   = example.frameworkId
  namespace_path = example.namespacePath
  name           = "Dependency Scanning Required"
  description    = "Ensures dependency scanning is enabled and running"
  internal_controls {
    name = "scanner_dep_scanning_running"
    expression = {
      field    = "scanner_dep_scanning_running"
      operator = "="
      value    = "true"
    }
  }
}
# Example: Create a compliance requirement with an external control
resource "gitlab_compliancerequirement" "external_control" {
  framework_id   = example.frameworkId
  namespace_path = example.namespacePath
  name           = "External Security Check"
  description    = "Verifies compliance via an external security service"
  external_controls {
    external_url = "https://example.com/compliance-check"
    secret_token = "my-secret-token"
    ping_enabled = true
  }
}
# Example: Create a compliance requirement with an external control with all options
resource "gitlab_compliancerequirement" "external_control_all_options" {
  framework_id   = example.frameworkId
  namespace_path = example.namespacePath
  name           = "External Security Check with All Options"
  description    = "Verifies compliance via an external security service with all options configured"
  external_controls {
    external_url          = "https://example.com/compliance-check"
    secret_token          = "my-secret-token"
    external_control_name = "My External Control"
    ping_enabled          = false
  }
}
# Example: Create a compliance requriement with both internal and external controls
resource "gitlab_compliancerequirement" "internal_and_external_controls" {
  framework_id   = example.frameworkId
  namespace_path = example.namespacePath
  name           = "Combined Security Check"
  description    = "Verifies compliance via both internal and external controls"
  internal_controls {
    name = "scanner_dep_scanning_running"
    expression = {
      field    = "scanner_dep_scanning_running"
      operator = "="
      value    = "true"
    }
  }
  external_controls {
    external_url = "https://example.com/compliance-check"
    secret_token = "my-secret-token"
    ping_enabled = true
  }
}

var complianceRequirementResource = new GitLab.ComplianceRequirement("complianceRequirementResource", new()
{
    Description = "string",
    FrameworkId = "string",
    NamespacePath = "string",
    ExternalControls = new[]
    {
        new GitLab.Inputs.ComplianceRequirementExternalControlArgs
        {
            ExternalUrl = "string",
            PingEnabled = false,
            SecretToken = "string",
            ExternalControlName = "string",
            Id = "string",
            Name = "string",
        },
    },
    InternalControls = new[]
    {
        new GitLab.Inputs.ComplianceRequirementInternalControlArgs
        {
            Expression = new GitLab.Inputs.ComplianceRequirementInternalControlExpressionArgs
            {
                Field = "string",
                Operator = "string",
                Value = "string",
            },
            Name = "string",
            Id = "string",
        },
    },
    Name = "string",
});

example, err := gitlab.NewComplianceRequirement(ctx, "complianceRequirementResource", &gitlab.ComplianceRequirementArgs{
	Description:   pulumi.String("string"),
	FrameworkId:   pulumi.String("string"),
	NamespacePath: pulumi.String("string"),
	ExternalControls: gitlab.ComplianceRequirementExternalControlArray{
		&gitlab.ComplianceRequirementExternalControlArgs{
			ExternalUrl:         pulumi.String("string"),
			PingEnabled:         pulumi.Bool(false),
			SecretToken:         pulumi.String("string"),
			ExternalControlName: pulumi.String("string"),
			Id:                  pulumi.String("string"),
			Name:                pulumi.String("string"),
		},
	},
	InternalControls: gitlab.ComplianceRequirementInternalControlArray{
		&gitlab.ComplianceRequirementInternalControlArgs{
			Expression: &gitlab.ComplianceRequirementInternalControlExpressionArgs{
				Field:    pulumi.String("string"),
				Operator: pulumi.String("string"),
				Value:    pulumi.String("string"),
			},
			Name: pulumi.String("string"),
			Id:   pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
})

resource "gitlab_compliance_requirement" "complianceRequirementResource" {
  lifecycle {
    create_before_destroy = true
  }
  description    = "string"
  framework_id   = "string"
  namespace_path = "string"
  external_controls {
    external_url          = "string"
    ping_enabled          = false
    secret_token          = "string"
    external_control_name = "string"
    id                    = "string"
    name                  = "string"
  }
  internal_controls {
    expression = {
      field    = "string"
      operator = "string"
      value    = "string"
    }
    name = "string"
    id   = "string"
  }
  name = "string"
}

var complianceRequirementResource = new ComplianceRequirement("complianceRequirementResource", ComplianceRequirementArgs.builder()
    .description("string")
    .frameworkId("string")
    .namespacePath("string")
    .externalControls(ComplianceRequirementExternalControlArgs.builder()
        .externalUrl("string")
        .pingEnabled(false)
        .secretToken("string")
        .externalControlName("string")
        .id("string")
        .name("string")
        .build())
    .internalControls(ComplianceRequirementInternalControlArgs.builder()
        .expression(ComplianceRequirementInternalControlExpressionArgs.builder()
            .field("string")
            .operator("string")
            .value("string")
            .build())
        .name("string")
        .id("string")
        .build())
    .name("string")
    .build());

compliance_requirement_resource = gitlab.ComplianceRequirement("complianceRequirementResource",
    description="string",
    framework_id="string",
    namespace_path="string",
    external_controls=[{
        "external_url": "string",
        "ping_enabled": False,
        "secret_token": "string",
        "external_control_name": "string",
        "id": "string",
        "name": "string",
    }],
    internal_controls=[{
        "expression": {
            "field": "string",
            "operator": "string",
            "value": "string",
        },
        "name": "string",
        "id": "string",
    }],
    name="string")

const complianceRequirementResource = new gitlab.ComplianceRequirement("complianceRequirementResource", {
    description: "string",
    frameworkId: "string",
    namespacePath: "string",
    externalControls: [{
        externalUrl: "string",
        pingEnabled: false,
        secretToken: "string",
        externalControlName: "string",
        id: "string",
        name: "string",
    }],
    internalControls: [{
        expression: {
            field: "string",
            operator: "string",
            value: "string",
        },
        name: "string",
        id: "string",
    }],
    name: "string",
});

type: gitlab:ComplianceRequirement
properties:
    description: string
    externalControls:
        - externalControlName: string
          externalUrl: string
          id: string
          name: string
          pingEnabled: false
          secretToken: string
    frameworkId: string
    internalControls:
        - expression:
            field: string
            operator: string
            value: string
          id: string
          name: string
    name: string
    namespacePath: string