buildkite.Pipeline.Webhook

import * as pulumi from "@pulumi/pulumi";
import * as buildkite from "@pulumiverse/buildkite";

// create a pipeline
const pipeline = new buildkite.pipeline.Pipeline("pipeline", {
    name: "my pipeline",
    repository: "https://github.com/my-org/my-repo.git",
});
// create a webhook to automatically trigger builds on push
const webhook = new buildkite.pipeline.Webhook("webhook", {
    pipelineId: pipeline.id,
    repository: pipeline.repository,
});

import pulumi
import pulumiverse_buildkite as buildkite

# create a pipeline
pipeline = buildkite.pipeline.Pipeline("pipeline",
    name="my pipeline",
    repository="https://github.com/my-org/my-repo.git")
# create a webhook to automatically trigger builds on push
webhook = buildkite.pipeline.Webhook("webhook",
    pipeline_id=pipeline.id,
    repository=pipeline.repository)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-buildkite/sdk/v3/go/buildkite/pipeline"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// create a pipeline
		pipeline, err := pipeline.NewPipeline(ctx, "pipeline", &pipeline.PipelineArgs{
			Name:       pulumi.String("my pipeline"),
			Repository: pulumi.String("https://github.com/my-org/my-repo.git"),
		})
		if err != nil {
			return err
		}
		// create a webhook to automatically trigger builds on push
		_, err = pipeline.NewWebhook(ctx, "webhook", &pipeline.WebhookArgs{
			PipelineId: pipeline.ID(),
			Repository: pipeline.Repository,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Buildkite = Pulumiverse.Buildkite;

return await Deployment.RunAsync(() => 
{
    // create a pipeline
    var pipeline = new Buildkite.Pipeline.Pipeline("pipeline", new()
    {
        Name = "my pipeline",
        Repository = "https://github.com/my-org/my-repo.git",
    });

    // create a webhook to automatically trigger builds on push
    var webhook = new Buildkite.Pipeline.Webhook("webhook", new()
    {
        PipelineId = pipeline.Id,
        Repository = pipeline.Repository,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.buildkite.Pipeline.Pipeline;
import com.pulumi.buildkite.Pipeline.PipelineArgs;
import com.pulumi.buildkite.Pipeline.Webhook;
import com.pulumi.buildkite.Pipeline.WebhookArgs;
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) {
        // create a pipeline
        var pipeline = new Pipeline("pipeline", PipelineArgs.builder()
            .name("my pipeline")
            .repository("https://github.com/my-org/my-repo.git")
            .build());

        // create a webhook to automatically trigger builds on push
        var webhook = new Webhook("webhook", WebhookArgs.builder()
            .pipelineId(pipeline.id())
            .repository(pipeline.repository())
            .build());

    }
}

resources:
  # create a pipeline
  pipeline:
    type: buildkite:Pipeline:Pipeline
    properties:
      name: my pipeline
      repository: https://github.com/my-org/my-repo.git
  # create a webhook to automatically trigger builds on push
  webhook:
    type: buildkite:Pipeline:Webhook
    properties:
      pipelineId: ${pipeline.id}
      repository: ${pipeline.repository}

var webhookResource = new Buildkite.Pipeline.Webhook("webhookResource", new()
{
    PipelineId = "string",
    Repository = "string",
});

example, err := pipeline.NewWebhook(ctx, "webhookResource", &pipeline.WebhookArgs{
	PipelineId: pulumi.String("string"),
	Repository: pulumi.String("string"),
})

var webhookResource = new Webhook("webhookResource", WebhookArgs.builder()
    .pipelineId("string")
    .repository("string")
    .build());

webhook_resource = buildkite.pipeline.Webhook("webhookResource",
    pipeline_id="string",
    repository="string")

const webhookResource = new buildkite.pipeline.Webhook("webhookResource", {
    pipelineId: "string",
    repository: "string",
});

type: buildkite:Pipeline:Webhook
properties:
    pipelineId: string
    repository: string