azuredevops.BuildDefinition

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

return await Deployment.RunAsync(() => 
{
    var exampleProject = new AzureDevOps.Project("exampleProject", new()
    {
        Visibility = "private",
        VersionControl = "Git",
        WorkItemTemplate = "Agile",
    });

    var exampleGit = new AzureDevOps.Git("exampleGit", new()
    {
        ProjectId = exampleProject.Id,
        Initialization = new AzureDevOps.Inputs.GitInitializationArgs
        {
            InitType = "Clean",
        },
    });

    var exampleVariableGroup = new AzureDevOps.VariableGroup("exampleVariableGroup", new()
    {
        ProjectId = exampleProject.Id,
        Description = "Managed by Terraform",
        AllowAccess = true,
        Variables = new[]
        {
            new AzureDevOps.Inputs.VariableGroupVariableArgs
            {
                Name = "FOO",
                Value = "BAR",
            },
        },
    });

    var exampleBuildDefinition = new AzureDevOps.BuildDefinition("exampleBuildDefinition", new()
    {
        ProjectId = exampleProject.Id,
        Path = "\\ExampleFolder",
        CiTrigger = new AzureDevOps.Inputs.BuildDefinitionCiTriggerArgs
        {
            UseYaml = false,
        },
        Schedules = new[]
        {
            new AzureDevOps.Inputs.BuildDefinitionScheduleArgs
            {
                BranchFilters = new[]
                {
                    new AzureDevOps.Inputs.BuildDefinitionScheduleBranchFilterArgs
                    {
                        Includes = new[]
                        {
                            "master",
                        },
                        Excludes = new[]
                        {
                            "test",
                            "regression",
                        },
                    },
                },
                DaysToBuilds = new[]
                {
                    "Wed",
                    "Sun",
                },
                ScheduleOnlyWithChanges = true,
                StartHours = 10,
                StartMinutes = 59,
                TimeZone = "(UTC) Coordinated Universal Time",
            },
        },
        Repository = new AzureDevOps.Inputs.BuildDefinitionRepositoryArgs
        {
            RepoType = "TfsGit",
            RepoId = exampleGit.Id,
            BranchName = exampleGit.DefaultBranch,
            YmlPath = "azure-pipelines.yml",
        },
        VariableGroups = new[]
        {
            exampleVariableGroup.Id,
        },
        Variables = new[]
        {
            new AzureDevOps.Inputs.BuildDefinitionVariableArgs
            {
                Name = "PipelineVariable",
                Value = "Go Microsoft!",
            },
            new AzureDevOps.Inputs.BuildDefinitionVariableArgs
            {
                Name = "PipelineSecret",
                SecretValue = "ZGV2cw",
                IsSecret = true,
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-azuredevops/sdk/v2/go/azuredevops"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleProject, err := azuredevops.NewProject(ctx, "exampleProject", &azuredevops.ProjectArgs{
			Visibility:       pulumi.String("private"),
			VersionControl:   pulumi.String("Git"),
			WorkItemTemplate: pulumi.String("Agile"),
		})
		if err != nil {
			return err
		}
		exampleGit, err := azuredevops.NewGit(ctx, "exampleGit", &azuredevops.GitArgs{
			ProjectId: exampleProject.ID(),
			Initialization: &azuredevops.GitInitializationArgs{
				InitType: pulumi.String("Clean"),
			},
		})
		if err != nil {
			return err
		}
		exampleVariableGroup, err := azuredevops.NewVariableGroup(ctx, "exampleVariableGroup", &azuredevops.VariableGroupArgs{
			ProjectId:   exampleProject.ID(),
			Description: pulumi.String("Managed by Terraform"),
			AllowAccess: pulumi.Bool(true),
			Variables: azuredevops.VariableGroupVariableArray{
				&azuredevops.VariableGroupVariableArgs{
					Name:  pulumi.String("FOO"),
					Value: pulumi.String("BAR"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = azuredevops.NewBuildDefinition(ctx, "exampleBuildDefinition", &azuredevops.BuildDefinitionArgs{
			ProjectId: exampleProject.ID(),
			Path:      pulumi.String("\\ExampleFolder"),
			CiTrigger: &azuredevops.BuildDefinitionCiTriggerArgs{
				UseYaml: pulumi.Bool(false),
			},
			Schedules: azuredevops.BuildDefinitionScheduleArray{
				&azuredevops.BuildDefinitionScheduleArgs{
					BranchFilters: azuredevops.BuildDefinitionScheduleBranchFilterArray{
						&azuredevops.BuildDefinitionScheduleBranchFilterArgs{
							Includes: pulumi.StringArray{
								pulumi.String("master"),
							},
							Excludes: pulumi.StringArray{
								pulumi.String("test"),
								pulumi.String("regression"),
							},
						},
					},
					DaysToBuilds: pulumi.StringArray{
						pulumi.String("Wed"),
						pulumi.String("Sun"),
					},
					ScheduleOnlyWithChanges: pulumi.Bool(true),
					StartHours:              pulumi.Int(10),
					StartMinutes:            pulumi.Int(59),
					TimeZone:                pulumi.String("(UTC) Coordinated Universal Time"),
				},
			},
			Repository: &azuredevops.BuildDefinitionRepositoryArgs{
				RepoType:   pulumi.String("TfsGit"),
				RepoId:     exampleGit.ID(),
				BranchName: exampleGit.DefaultBranch,
				YmlPath:    pulumi.String("azure-pipelines.yml"),
			},
			VariableGroups: pulumi.IntArray{
				exampleVariableGroup.ID(),
			},
			Variables: azuredevops.BuildDefinitionVariableArray{
				&azuredevops.BuildDefinitionVariableArgs{
					Name:  pulumi.String("PipelineVariable"),
					Value: pulumi.String("Go Microsoft!"),
				},
				&azuredevops.BuildDefinitionVariableArgs{
					Name:        pulumi.String("PipelineSecret"),
					SecretValue: pulumi.String("ZGV2cw"),
					IsSecret:    pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuredevops.Project;
import com.pulumi.azuredevops.ProjectArgs;
import com.pulumi.azuredevops.Git;
import com.pulumi.azuredevops.GitArgs;
import com.pulumi.azuredevops.inputs.GitInitializationArgs;
import com.pulumi.azuredevops.VariableGroup;
import com.pulumi.azuredevops.VariableGroupArgs;
import com.pulumi.azuredevops.inputs.VariableGroupVariableArgs;
import com.pulumi.azuredevops.BuildDefinition;
import com.pulumi.azuredevops.BuildDefinitionArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionCiTriggerArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionScheduleArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionRepositoryArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionVariableArgs;
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 exampleProject = new Project("exampleProject", ProjectArgs.builder()        
            .visibility("private")
            .versionControl("Git")
            .workItemTemplate("Agile")
            .build());

        var exampleGit = new Git("exampleGit", GitArgs.builder()        
            .projectId(exampleProject.id())
            .initialization(GitInitializationArgs.builder()
                .initType("Clean")
                .build())
            .build());

        var exampleVariableGroup = new VariableGroup("exampleVariableGroup", VariableGroupArgs.builder()        
            .projectId(exampleProject.id())
            .description("Managed by Terraform")
            .allowAccess(true)
            .variables(VariableGroupVariableArgs.builder()
                .name("FOO")
                .value("BAR")
                .build())
            .build());

        var exampleBuildDefinition = new BuildDefinition("exampleBuildDefinition", BuildDefinitionArgs.builder()        
            .projectId(exampleProject.id())
            .path("\\ExampleFolder")
            .ciTrigger(BuildDefinitionCiTriggerArgs.builder()
                .useYaml(false)
                .build())
            .schedules(BuildDefinitionScheduleArgs.builder()
                .branchFilters(BuildDefinitionScheduleBranchFilterArgs.builder()
                    .includes("master")
                    .excludes(                    
                        "test",
                        "regression")
                    .build())
                .daysToBuilds(                
                    "Wed",
                    "Sun")
                .scheduleOnlyWithChanges(true)
                .startHours(10)
                .startMinutes(59)
                .timeZone("(UTC) Coordinated Universal Time")
                .build())
            .repository(BuildDefinitionRepositoryArgs.builder()
                .repoType("TfsGit")
                .repoId(exampleGit.id())
                .branchName(exampleGit.defaultBranch())
                .ymlPath("azure-pipelines.yml")
                .build())
            .variableGroups(exampleVariableGroup.id())
            .variables(            
                BuildDefinitionVariableArgs.builder()
                    .name("PipelineVariable")
                    .value("Go Microsoft!")
                    .build(),
                BuildDefinitionVariableArgs.builder()
                    .name("PipelineSecret")
                    .secretValue("ZGV2cw")
                    .isSecret(true)
                    .build())
            .build());

    }
}

import pulumi
import pulumi_azuredevops as azuredevops

example_project = azuredevops.Project("exampleProject",
    visibility="private",
    version_control="Git",
    work_item_template="Agile")
example_git = azuredevops.Git("exampleGit",
    project_id=example_project.id,
    initialization=azuredevops.GitInitializationArgs(
        init_type="Clean",
    ))
example_variable_group = azuredevops.VariableGroup("exampleVariableGroup",
    project_id=example_project.id,
    description="Managed by Terraform",
    allow_access=True,
    variables=[azuredevops.VariableGroupVariableArgs(
        name="FOO",
        value="BAR",
    )])
example_build_definition = azuredevops.BuildDefinition("exampleBuildDefinition",
    project_id=example_project.id,
    path="\\ExampleFolder",
    ci_trigger=azuredevops.BuildDefinitionCiTriggerArgs(
        use_yaml=False,
    ),
    schedules=[azuredevops.BuildDefinitionScheduleArgs(
        branch_filters=[azuredevops.BuildDefinitionScheduleBranchFilterArgs(
            includes=["master"],
            excludes=[
                "test",
                "regression",
            ],
        )],
        days_to_builds=[
            "Wed",
            "Sun",
        ],
        schedule_only_with_changes=True,
        start_hours=10,
        start_minutes=59,
        time_zone="(UTC) Coordinated Universal Time",
    )],
    repository=azuredevops.BuildDefinitionRepositoryArgs(
        repo_type="TfsGit",
        repo_id=example_git.id,
        branch_name=example_git.default_branch,
        yml_path="azure-pipelines.yml",
    ),
    variable_groups=[example_variable_group.id],
    variables=[
        azuredevops.BuildDefinitionVariableArgs(
            name="PipelineVariable",
            value="Go Microsoft!",
        ),
        azuredevops.BuildDefinitionVariableArgs(
            name="PipelineSecret",
            secret_value="ZGV2cw",
            is_secret=True,
        ),
    ])

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

const exampleProject = new azuredevops.Project("exampleProject", {
    visibility: "private",
    versionControl: "Git",
    workItemTemplate: "Agile",
});
const exampleGit = new azuredevops.Git("exampleGit", {
    projectId: exampleProject.id,
    initialization: {
        initType: "Clean",
    },
});
const exampleVariableGroup = new azuredevops.VariableGroup("exampleVariableGroup", {
    projectId: exampleProject.id,
    description: "Managed by Terraform",
    allowAccess: true,
    variables: [{
        name: "FOO",
        value: "BAR",
    }],
});
const exampleBuildDefinition = new azuredevops.BuildDefinition("exampleBuildDefinition", {
    projectId: exampleProject.id,
    path: "\\ExampleFolder",
    ciTrigger: {
        useYaml: false,
    },
    schedules: [{
        branchFilters: [{
            includes: ["master"],
            excludes: [
                "test",
                "regression",
            ],
        }],
        daysToBuilds: [
            "Wed",
            "Sun",
        ],
        scheduleOnlyWithChanges: true,
        startHours: 10,
        startMinutes: 59,
        timeZone: "(UTC) Coordinated Universal Time",
    }],
    repository: {
        repoType: "TfsGit",
        repoId: exampleGit.id,
        branchName: exampleGit.defaultBranch,
        ymlPath: "azure-pipelines.yml",
    },
    variableGroups: [exampleVariableGroup.id],
    variables: [
        {
            name: "PipelineVariable",
            value: "Go Microsoft!",
        },
        {
            name: "PipelineSecret",
            secretValue: "ZGV2cw",
            isSecret: true,
        },
    ],
});

resources:
  exampleProject:
    type: azuredevops:Project
    properties:
      visibility: private
      versionControl: Git
      workItemTemplate: Agile
  exampleGit:
    type: azuredevops:Git
    properties:
      projectId: ${exampleProject.id}
      initialization:
        initType: Clean
  exampleVariableGroup:
    type: azuredevops:VariableGroup
    properties:
      projectId: ${exampleProject.id}
      description: Managed by Terraform
      allowAccess: true
      variables:
        - name: FOO
          value: BAR
  exampleBuildDefinition:
    type: azuredevops:BuildDefinition
    properties:
      projectId: ${exampleProject.id}
      path: \ExampleFolder
      ciTrigger:
        useYaml: false
      schedules:
        - branchFilters:
            - includes:
                - master
              excludes:
                - test
                - regression
          daysToBuilds:
            - Wed
            - Sun
          scheduleOnlyWithChanges: true
          startHours: 10
          startMinutes: 59
          timeZone: (UTC) Coordinated Universal Time
      repository:
        repoType: TfsGit
        repoId: ${exampleGit.id}
        branchName: ${exampleGit.defaultBranch}
        ymlPath: azure-pipelines.yml
      variableGroups:
        - ${exampleVariableGroup.id}
      variables:
        - name: PipelineVariable
          value: Go Microsoft!
        - name: PipelineSecret
          secretValue: ZGV2cw
          isSecret: true

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

return await Deployment.RunAsync(() => 
{
    var exampleProject = new AzureDevOps.Project("exampleProject", new()
    {
        Visibility = "private",
        VersionControl = "Git",
        WorkItemTemplate = "Agile",
    });

    var exampleServiceEndpointGitHubEnterprise = new AzureDevOps.ServiceEndpointGitHubEnterprise("exampleServiceEndpointGitHubEnterprise", new()
    {
        ProjectId = exampleProject.Id,
        ServiceEndpointName = "Example GitHub Enterprise",
        Url = "https://github.contoso.com",
        Description = "Managed by Terraform",
        AuthPersonal = new AzureDevOps.Inputs.ServiceEndpointGitHubEnterpriseAuthPersonalArgs
        {
            PersonalAccessToken = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        },
    });

    var exampleBuildDefinition = new AzureDevOps.BuildDefinition("exampleBuildDefinition", new()
    {
        ProjectId = exampleProject.Id,
        Path = "\\ExampleFolder",
        CiTrigger = new AzureDevOps.Inputs.BuildDefinitionCiTriggerArgs
        {
            UseYaml = false,
        },
        Repository = new AzureDevOps.Inputs.BuildDefinitionRepositoryArgs
        {
            RepoType = "GitHubEnterprise",
            RepoId = "<GitHub Org>/<Repo Name>",
            GithubEnterpriseUrl = "https://github.company.com",
            BranchName = "master",
            YmlPath = "azure-pipelines.yml",
            ServiceConnectionId = exampleServiceEndpointGitHubEnterprise.Id,
        },
        Schedules = new[]
        {
            new AzureDevOps.Inputs.BuildDefinitionScheduleArgs
            {
                BranchFilters = new[]
                {
                    new AzureDevOps.Inputs.BuildDefinitionScheduleBranchFilterArgs
                    {
                        Includes = new[]
                        {
                            "main",
                        },
                        Excludes = new[]
                        {
                            "test",
                            "regression",
                        },
                    },
                },
                DaysToBuilds = new[]
                {
                    "Wed",
                    "Sun",
                },
                ScheduleOnlyWithChanges = true,
                StartHours = 10,
                StartMinutes = 59,
                TimeZone = "(UTC) Coordinated Universal Time",
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-azuredevops/sdk/v2/go/azuredevops"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleProject, err := azuredevops.NewProject(ctx, "exampleProject", &azuredevops.ProjectArgs{
			Visibility:       pulumi.String("private"),
			VersionControl:   pulumi.String("Git"),
			WorkItemTemplate: pulumi.String("Agile"),
		})
		if err != nil {
			return err
		}
		exampleServiceEndpointGitHubEnterprise, err := azuredevops.NewServiceEndpointGitHubEnterprise(ctx, "exampleServiceEndpointGitHubEnterprise", &azuredevops.ServiceEndpointGitHubEnterpriseArgs{
			ProjectId:           exampleProject.ID(),
			ServiceEndpointName: pulumi.String("Example GitHub Enterprise"),
			Url:                 pulumi.String("https://github.contoso.com"),
			Description:         pulumi.String("Managed by Terraform"),
			AuthPersonal: &azuredevops.ServiceEndpointGitHubEnterpriseAuthPersonalArgs{
				PersonalAccessToken: pulumi.String("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
			},
		})
		if err != nil {
			return err
		}
		_, err = azuredevops.NewBuildDefinition(ctx, "exampleBuildDefinition", &azuredevops.BuildDefinitionArgs{
			ProjectId: exampleProject.ID(),
			Path:      pulumi.String("\\ExampleFolder"),
			CiTrigger: &azuredevops.BuildDefinitionCiTriggerArgs{
				UseYaml: pulumi.Bool(false),
			},
			Repository: &azuredevops.BuildDefinitionRepositoryArgs{
				RepoType:            pulumi.String("GitHubEnterprise"),
				RepoId:              pulumi.String("<GitHub Org>/<Repo Name>"),
				GithubEnterpriseUrl: pulumi.String("https://github.company.com"),
				BranchName:          pulumi.String("master"),
				YmlPath:             pulumi.String("azure-pipelines.yml"),
				ServiceConnectionId: exampleServiceEndpointGitHubEnterprise.ID(),
			},
			Schedules: azuredevops.BuildDefinitionScheduleArray{
				&azuredevops.BuildDefinitionScheduleArgs{
					BranchFilters: azuredevops.BuildDefinitionScheduleBranchFilterArray{
						&azuredevops.BuildDefinitionScheduleBranchFilterArgs{
							Includes: pulumi.StringArray{
								pulumi.String("main"),
							},
							Excludes: pulumi.StringArray{
								pulumi.String("test"),
								pulumi.String("regression"),
							},
						},
					},
					DaysToBuilds: pulumi.StringArray{
						pulumi.String("Wed"),
						pulumi.String("Sun"),
					},
					ScheduleOnlyWithChanges: pulumi.Bool(true),
					StartHours:              pulumi.Int(10),
					StartMinutes:            pulumi.Int(59),
					TimeZone:                pulumi.String("(UTC) Coordinated Universal Time"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuredevops.Project;
import com.pulumi.azuredevops.ProjectArgs;
import com.pulumi.azuredevops.ServiceEndpointGitHubEnterprise;
import com.pulumi.azuredevops.ServiceEndpointGitHubEnterpriseArgs;
import com.pulumi.azuredevops.inputs.ServiceEndpointGitHubEnterpriseAuthPersonalArgs;
import com.pulumi.azuredevops.BuildDefinition;
import com.pulumi.azuredevops.BuildDefinitionArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionCiTriggerArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionRepositoryArgs;
import com.pulumi.azuredevops.inputs.BuildDefinitionScheduleArgs;
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 exampleProject = new Project("exampleProject", ProjectArgs.builder()        
            .visibility("private")
            .versionControl("Git")
            .workItemTemplate("Agile")
            .build());

        var exampleServiceEndpointGitHubEnterprise = new ServiceEndpointGitHubEnterprise("exampleServiceEndpointGitHubEnterprise", ServiceEndpointGitHubEnterpriseArgs.builder()        
            .projectId(exampleProject.id())
            .serviceEndpointName("Example GitHub Enterprise")
            .url("https://github.contoso.com")
            .description("Managed by Terraform")
            .authPersonal(ServiceEndpointGitHubEnterpriseAuthPersonalArgs.builder()
                .personalAccessToken("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
                .build())
            .build());

        var exampleBuildDefinition = new BuildDefinition("exampleBuildDefinition", BuildDefinitionArgs.builder()        
            .projectId(exampleProject.id())
            .path("\\ExampleFolder")
            .ciTrigger(BuildDefinitionCiTriggerArgs.builder()
                .useYaml(false)
                .build())
            .repository(BuildDefinitionRepositoryArgs.builder()
                .repoType("GitHubEnterprise")
                .repoId("<GitHub Org>/<Repo Name>")
                .githubEnterpriseUrl("https://github.company.com")
                .branchName("master")
                .ymlPath("azure-pipelines.yml")
                .serviceConnectionId(exampleServiceEndpointGitHubEnterprise.id())
                .build())
            .schedules(BuildDefinitionScheduleArgs.builder()
                .branchFilters(BuildDefinitionScheduleBranchFilterArgs.builder()
                    .includes("main")
                    .excludes(                    
                        "test",
                        "regression")
                    .build())
                .daysToBuilds(                
                    "Wed",
                    "Sun")
                .scheduleOnlyWithChanges(true)
                .startHours(10)
                .startMinutes(59)
                .timeZone("(UTC) Coordinated Universal Time")
                .build())
            .build());

    }
}

import pulumi
import pulumi_azuredevops as azuredevops

example_project = azuredevops.Project("exampleProject",
    visibility="private",
    version_control="Git",
    work_item_template="Agile")
example_service_endpoint_git_hub_enterprise = azuredevops.ServiceEndpointGitHubEnterprise("exampleServiceEndpointGitHubEnterprise",
    project_id=example_project.id,
    service_endpoint_name="Example GitHub Enterprise",
    url="https://github.contoso.com",
    description="Managed by Terraform",
    auth_personal=azuredevops.ServiceEndpointGitHubEnterpriseAuthPersonalArgs(
        personal_access_token="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    ))
example_build_definition = azuredevops.BuildDefinition("exampleBuildDefinition",
    project_id=example_project.id,
    path="\\ExampleFolder",
    ci_trigger=azuredevops.BuildDefinitionCiTriggerArgs(
        use_yaml=False,
    ),
    repository=azuredevops.BuildDefinitionRepositoryArgs(
        repo_type="GitHubEnterprise",
        repo_id="<GitHub Org>/<Repo Name>",
        github_enterprise_url="https://github.company.com",
        branch_name="master",
        yml_path="azure-pipelines.yml",
        service_connection_id=example_service_endpoint_git_hub_enterprise.id,
    ),
    schedules=[azuredevops.BuildDefinitionScheduleArgs(
        branch_filters=[azuredevops.BuildDefinitionScheduleBranchFilterArgs(
            includes=["main"],
            excludes=[
                "test",
                "regression",
            ],
        )],
        days_to_builds=[
            "Wed",
            "Sun",
        ],
        schedule_only_with_changes=True,
        start_hours=10,
        start_minutes=59,
        time_zone="(UTC) Coordinated Universal Time",
    )])

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

const exampleProject = new azuredevops.Project("exampleProject", {
    visibility: "private",
    versionControl: "Git",
    workItemTemplate: "Agile",
});
const exampleServiceEndpointGitHubEnterprise = new azuredevops.ServiceEndpointGitHubEnterprise("exampleServiceEndpointGitHubEnterprise", {
    projectId: exampleProject.id,
    serviceEndpointName: "Example GitHub Enterprise",
    url: "https://github.contoso.com",
    description: "Managed by Terraform",
    authPersonal: {
        personalAccessToken: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    },
});
const exampleBuildDefinition = new azuredevops.BuildDefinition("exampleBuildDefinition", {
    projectId: exampleProject.id,
    path: "\\ExampleFolder",
    ciTrigger: {
        useYaml: false,
    },
    repository: {
        repoType: "GitHubEnterprise",
        repoId: "<GitHub Org>/<Repo Name>",
        githubEnterpriseUrl: "https://github.company.com",
        branchName: "master",
        ymlPath: "azure-pipelines.yml",
        serviceConnectionId: exampleServiceEndpointGitHubEnterprise.id,
    },
    schedules: [{
        branchFilters: [{
            includes: ["main"],
            excludes: [
                "test",
                "regression",
            ],
        }],
        daysToBuilds: [
            "Wed",
            "Sun",
        ],
        scheduleOnlyWithChanges: true,
        startHours: 10,
        startMinutes: 59,
        timeZone: "(UTC) Coordinated Universal Time",
    }],
});

resources:
  exampleProject:
    type: azuredevops:Project
    properties:
      visibility: private
      versionControl: Git
      workItemTemplate: Agile
  exampleServiceEndpointGitHubEnterprise:
    type: azuredevops:ServiceEndpointGitHubEnterprise
    properties:
      projectId: ${exampleProject.id}
      serviceEndpointName: Example GitHub Enterprise
      url: https://github.contoso.com
      description: Managed by Terraform
      authPersonal:
        personalAccessToken: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  exampleBuildDefinition:
    type: azuredevops:BuildDefinition
    properties:
      projectId: ${exampleProject.id}
      path: \ExampleFolder
      ciTrigger:
        useYaml: false
      repository:
        repoType: GitHubEnterprise
        repoId: <GitHub Org>/<Repo Name>
        githubEnterpriseUrl: https://github.company.com
        branchName: master
        ymlPath: azure-pipelines.yml
        serviceConnectionId: ${exampleServiceEndpointGitHubEnterprise.id}
      schedules:
        - branchFilters:
            - includes:
                - main
              excludes:
                - test
                - regression
          daysToBuilds:
            - Wed
            - Sun
          scheduleOnlyWithChanges: true
          startHours: 10
          startMinutes: 59
          timeZone: (UTC) Coordinated Universal Time