gitlab.ProjectJobTokenScopes

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

const allowedSingleProject = new gitlab.ProjectJobTokenScopes("allowed_single_project", {
    projectId: 111,
    targetProjectIds: [123],
});
const allowedMultipleProject = new gitlab.ProjectJobTokenScopes("allowed_multiple_project", {
    projectId: 111,
    targetProjectIds: [
        123,
        456,
        789,
    ],
});
// This will remove all job token scopes, even if added outside of TF.
const explicitDeny = new gitlab.ProjectJobTokenScopes("explicit_deny", {
    projectId: 111,
    targetProjectIds: [],
});

import pulumi
import pulumi_gitlab as gitlab

allowed_single_project = gitlab.ProjectJobTokenScopes("allowed_single_project",
    project_id=111,
    target_project_ids=[123])
allowed_multiple_project = gitlab.ProjectJobTokenScopes("allowed_multiple_project",
    project_id=111,
    target_project_ids=[
        123,
        456,
        789,
    ])
# This will remove all job token scopes, even if added outside of TF.
explicit_deny = gitlab.ProjectJobTokenScopes("explicit_deny",
    project_id=111,
    target_project_ids=[])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gitlab.NewProjectJobTokenScopes(ctx, "allowed_single_project", &gitlab.ProjectJobTokenScopesArgs{
			ProjectId: pulumi.Int(111),
			TargetProjectIds: pulumi.IntArray{
				pulumi.Int(123),
			},
		})
		if err != nil {
			return err
		}
		_, err = gitlab.NewProjectJobTokenScopes(ctx, "allowed_multiple_project", &gitlab.ProjectJobTokenScopesArgs{
			ProjectId: pulumi.Int(111),
			TargetProjectIds: pulumi.IntArray{
				pulumi.Int(123),
				pulumi.Int(456),
				pulumi.Int(789),
			},
		})
		if err != nil {
			return err
		}
		// This will remove all job token scopes, even if added outside of TF.
		_, err = gitlab.NewProjectJobTokenScopes(ctx, "explicit_deny", &gitlab.ProjectJobTokenScopesArgs{
			ProjectId:        pulumi.Int(111),
			TargetProjectIds: pulumi.IntArray{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var allowedSingleProject = new GitLab.ProjectJobTokenScopes("allowed_single_project", new()
    {
        ProjectId = 111,
        TargetProjectIds = new[]
        {
            123,
        },
    });

    var allowedMultipleProject = new GitLab.ProjectJobTokenScopes("allowed_multiple_project", new()
    {
        ProjectId = 111,
        TargetProjectIds = new[]
        {
            123,
            456,
            789,
        },
    });

    // This will remove all job token scopes, even if added outside of TF.
    var explicitDeny = new GitLab.ProjectJobTokenScopes("explicit_deny", new()
    {
        ProjectId = 111,
        TargetProjectIds = new[] {},
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gitlab.ProjectJobTokenScopes;
import com.pulumi.gitlab.ProjectJobTokenScopesArgs;
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 allowedSingleProject = new ProjectJobTokenScopes("allowedSingleProject", ProjectJobTokenScopesArgs.builder()
            .projectId(111)
            .targetProjectIds(123)
            .build());

        var allowedMultipleProject = new ProjectJobTokenScopes("allowedMultipleProject", ProjectJobTokenScopesArgs.builder()
            .projectId(111)
            .targetProjectIds(            
                123,
                456,
                789)
            .build());

        // This will remove all job token scopes, even if added outside of TF.
        var explicitDeny = new ProjectJobTokenScopes("explicitDeny", ProjectJobTokenScopesArgs.builder()
            .projectId(111)
            .targetProjectIds()
            .build());

    }
}

resources:
  allowedSingleProject:
    type: gitlab:ProjectJobTokenScopes
    name: allowed_single_project
    properties:
      projectId: 111
      targetProjectIds:
        - 123
  allowedMultipleProject:
    type: gitlab:ProjectJobTokenScopes
    name: allowed_multiple_project
    properties:
      projectId: 111
      targetProjectIds:
        - 123
        - 456
        - 789
  # This will remove all job token scopes, even if added outside of TF.
  explicitDeny:
    type: gitlab:ProjectJobTokenScopes
    name: explicit_deny
    properties:
      projectId: 111
      targetProjectIds: []

var projectJobTokenScopesResource = new GitLab.ProjectJobTokenScopes("projectJobTokenScopesResource", new()
{
    ProjectId = 0,
    TargetProjectIds = new[]
    {
        0,
    },
});

example, err := gitlab.NewProjectJobTokenScopes(ctx, "projectJobTokenScopesResource", &gitlab.ProjectJobTokenScopesArgs{
	ProjectId: pulumi.Int(0),
	TargetProjectIds: pulumi.IntArray{
		pulumi.Int(0),
	},
})

var projectJobTokenScopesResource = new ProjectJobTokenScopes("projectJobTokenScopesResource", ProjectJobTokenScopesArgs.builder()
    .projectId(0)
    .targetProjectIds(0)
    .build());

project_job_token_scopes_resource = gitlab.ProjectJobTokenScopes("projectJobTokenScopesResource",
    project_id=0,
    target_project_ids=[0])

const projectJobTokenScopesResource = new gitlab.ProjectJobTokenScopes("projectJobTokenScopesResource", {
    projectId: 0,
    targetProjectIds: [0],
});

type: gitlab:ProjectJobTokenScopes
properties:
    projectId: 0
    targetProjectIds:
        - 0