1. Packages
  2. dbt Cloud Provider
  3. API Docs
  4. Job
dbt Cloud v1.6.0 published on Friday, Feb 20, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-dbtcloud

dbtcloud.Job

dbtcloud logo
dbt Cloud v1.6.0 published on Friday, Feb 20, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-dbtcloud

    In October 2023, CI improvements have been rolled out to dbt Cloud with minor impacts to some jobs: more info.

    Those improvements include modifications to deferral which was historically set at the job level and will now be set at the environment level. Deferral can still be set to “self” by setting self_deferring to true but with the new approach, deferral to other runs need to be done with deferring_environment_id instead of deferring_job_id.

    New with 0.3.1, triggers now accepts a on_merge value to trigger jobs when code is merged in git. If on_merge is true all other triggers need to be false.

    For now, it is not a mandatory field, but it will be in a future version. Please add on_merge in your config or modules.

    For Continuous Integration

    In the case of Continuous Integration, our CI job needs to defer to the Production environment. So, we need to have a successful run in the Production environment before the CI process can execute as expected.

    The example below shows how the Terraform config can be updated to automatically trigger a run of the job in the Production environment, leveraging the local-exec provisioner and curl to trigger the run.

    import * as pulumi from "@pulumi/pulumi";
import * as command from "@pulumi/command";
import * as dbtcloud from "@pulumi/dbtcloud";

// a periodic job, but we trigger it once with `dbt parse` as soon as it is created so we can defer to the environment it is in
// to do so, we use a local-exec provisioner, just make sure that the machine running Terraform has curl installed
const dailyJob = new dbtcloud.Job("daily_job", {
    environmentId: prodEnvironment.environmentId,
    executeSteps: ["dbt build"],
    generateDocs: true,
    name: "Daily job",
    numThreads: 64,
    projectId: dbtProject.id,
    runGenerateSources: true,
    targetName: "default",
    triggers: {
        github_webhook: false,
        git_provider_webhook: false,
        schedule: true,
        on_merge: false,
    },
    scheduleDays: [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    scheduleType: "days_of_week",
    scheduleHours: [0],
});
const dailyJobProvisioner0 = new command.local.Command("dailyJobProvisioner0", {create: `response=$(curl -s -L -o /dev/null -w \"%{http_code}\" -X POST \\
  -H 'Authorization: Bearer ${dbtToken}' \\
  -H 'Content-Type: application/json' \\
  -d '{\"cause\": \"Generate manifest\", \"steps_override\": [\"dbt parse\"]}' \\
  ${dbtHostUrl}/v2/accounts/${dbtAccountId}/jobs/${id}/run/)
      
if [ \"$response\" -ge 200 ] && [ \"$response\" -lt 300 ]; then
  echo \"Success: HTTP status $response\"
  exit 0
else
  echo \"Failure: HTTP status $response\"
  exit 1
fi
`}, {
    dependsOn: [dailyJob],
});

    import pulumi
import pulumi_command as command
import pulumi_dbtcloud as dbtcloud

# a periodic job, but we trigger it once with `dbt parse` as soon as it is created so we can defer to the environment it is in
# to do so, we use a local-exec provisioner, just make sure that the machine running Terraform has curl installed
daily_job = dbtcloud.Job("daily_job",
    environment_id=prod_environment["environmentId"],
    execute_steps=["dbt build"],
    generate_docs=True,
    name="Daily job",
    num_threads=64,
    project_id=dbt_project["id"],
    run_generate_sources=True,
    target_name="default",
    triggers={
        "github_webhook": False,
        "git_provider_webhook": False,
        "schedule": True,
        "on_merge": False,
    },
    schedule_days=[
        0,
        1,
        2,
        3,
        4,
        5,
        6,
    ],
    schedule_type="days_of_week",
    schedule_hours=[0])
daily_job_provisioner0 = command.local.Command("dailyJobProvisioner0", create=fresponse=$(curl -s -L -o /dev/null -w \"%{{http_code}}\" -X POST \\
  -H 'Authorization: Bearer {dbt_token}' \\
  -H 'Content-Type: application/json' \\
  -d '{{\"cause\": \"Generate manifest\", \"steps_override\": [\"dbt parse\"]}}' \\
  {dbt_host_url}/v2/accounts/{dbt_account_id}/jobs/{id}/run/)
      
if [ \"$response\" -ge 200 ] && [ \"$response\" -lt 300 ]; then
  echo \"Success: HTTP status $response\"
  exit 0
else
  echo \"Failure: HTTP status $response\"
  exit 1
fi
,
opts = pulumi.ResourceOptions(depends_on=[daily_job]))

    package main

import (
	"fmt"

	"github.com/pulumi/pulumi-command/sdk/go/command/local"
	"github.com/pulumi/pulumi-dbtcloud/sdk/go/dbtcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// a periodic job, but we trigger it once with `dbt parse` as soon as it is created so we can defer to the environment it is in
		// to do so, we use a local-exec provisioner, just make sure that the machine running Terraform has curl installed
		dailyJob, err := dbtcloud.NewJob(ctx, "daily_job", &dbtcloud.JobArgs{
			EnvironmentId: pulumi.Any(prodEnvironment.EnvironmentId),
			ExecuteSteps: pulumi.StringArray{
				pulumi.String("dbt build"),
			},
			GenerateDocs:       pulumi.Bool(true),
			Name:               pulumi.String("Daily job"),
			NumThreads:         pulumi.Int(64),
			ProjectId:          pulumi.Any(dbtProject.Id),
			RunGenerateSources: pulumi.Bool(true),
			TargetName:         pulumi.String("default"),
			Triggers: &dbtcloud.JobTriggersArgs{
				Github_webhook:       false,
				Git_provider_webhook: false,
				Schedule:             pulumi.Bool(true),
				On_merge:             false,
			},
			ScheduleDays: pulumi.IntArray{
				pulumi.Int(0),
				pulumi.Int(1),
				pulumi.Int(2),
				pulumi.Int(3),
				pulumi.Int(4),
				pulumi.Int(5),
				pulumi.Int(6),
			},
			ScheduleType: pulumi.String("days_of_week"),
			ScheduleHours: pulumi.IntArray{
				pulumi.Int(0),
			},
		})
		if err != nil {
			return err
		}
		_, err = local.NewCommand(ctx, "dailyJobProvisioner0", &local.CommandArgs{
			Create: fmt.Sprintf(`%v%v' \\
  -H 'Content-Type: application/json' \\
  -d '{\"cause\": \"Generate manifest\", \"steps_override\": [\"dbt parse\"]}' \\
  %v/v2/accounts/%v/jobs/%v/run/)
      
if [ \"$response\" -ge 200 ] && [ \"$response\" -lt 300 ]; then
  echo \"Success: HTTP status $response\"
  exit 0
else
  echo \"Failure: HTTP status $response\"
  exit 1
fi
`, "response=$(curl -s -L -o /dev/null -w \\\"%{http_code}\\\" -X POST \\\\\n  -H 'Authorization: Bearer ", dbtToken, dbtHostUrl, dbtAccountId, id),
		}, pulumi.DependsOn([]pulumi.Resource{
			dailyJob,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Command = Pulumi.Command;
using DbtCloud = Pulumi.DbtCloud;

return await Deployment.RunAsync(() => 
{
    // a periodic job, but we trigger it once with `dbt parse` as soon as it is created so we can defer to the environment it is in
    // to do so, we use a local-exec provisioner, just make sure that the machine running Terraform has curl installed
    var dailyJob = new DbtCloud.Job("daily_job", new()
    {
        EnvironmentId = prodEnvironment.EnvironmentId,
        ExecuteSteps = new[]
        {
            "dbt build",
        },
        GenerateDocs = true,
        Name = "Daily job",
        NumThreads = 64,
        ProjectId = dbtProject.Id,
        RunGenerateSources = true,
        TargetName = "default",
        Triggers = new DbtCloud.Inputs.JobTriggersArgs
        {
            Github_webhook = false,
            Git_provider_webhook = false,
            Schedule = true,
            On_merge = false,
        },
        ScheduleDays = new[]
        {
            0,
            1,
            2,
            3,
            4,
            5,
            6,
        },
        ScheduleType = "days_of_week",
        ScheduleHours = new[]
        {
            0,
        },
    });

    var dailyJobProvisioner0 = new Command.Local.Command("dailyJobProvisioner0", new()
    {
        Create = @$"response=$(curl -s -L -o /dev/null -w \""%{{http_code}}\"" -X POST \\
  -H 'Authorization: Bearer {dbtToken}' \\
  -H 'Content-Type: application/json' \\
  -d '{{\""cause\"": \""Generate manifest\"", \""steps_override\"": [\""dbt parse\""]}}' \\
  {dbtHostUrl}/v2/accounts/{dbtAccountId}/jobs/{id}/run/)
      
if [ \""$response\"" -ge 200 ] && [ \""$response\"" -lt 300 ]; then
  echo \""Success: HTTP status $response\""
  exit 0
else
  echo \""Failure: HTTP status $response\""
  exit 1
fi
",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            dailyJob,
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dbtcloud.Job;
import com.pulumi.dbtcloud.JobArgs;
import com.pulumi.dbtcloud.inputs.JobTriggersArgs;
import com.pulumi.command.local.Command;
import com.pulumi.command.local.CommandArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        // a periodic job, but we trigger it once with `dbt parse` as soon as it is created so we can defer to the environment it is in
        // to do so, we use a local-exec provisioner, just make sure that the machine running Terraform has curl installed
        var dailyJob = new Job("dailyJob", JobArgs.builder()
            .environmentId(prodEnvironment.environmentId())
            .executeSteps("dbt build")
            .generateDocs(true)
            .name("Daily job")
            .numThreads(64)
            .projectId(dbtProject.id())
            .runGenerateSources(true)
            .targetName("default")
            .triggers(JobTriggersArgs.builder()
%!v(PANIC=Format method: interface conversion: model.Expression is *model.TemplateExpression, not *model.LiteralValueExpression))
                .scheduleDays(                
                    0,
                    1,
                    2,
                    3,
                    4,
                    5,
                    6)
                .scheduleType("days_of_week")
                .scheduleHours(0)
                .build());

            var dailyJobProvisioner0 = new Command("dailyJobProvisioner0", CommandArgs.builder()
                .create("""
response=$(curl -s -L -o /dev/null -w \"%{http_code}\" -X POST \\
  -H 'Authorization: Bearer %s' \\
  -H 'Content-Type: application/json' \\
  -d '{\"cause\": \"Generate manifest\", \"steps_override\": [\"dbt parse\"]}' \\
  %s/v2/accounts/%s/jobs/%s/run/)
      
if [ \"$response\" -ge 200 ] && [ \"$response\" -lt 300 ]; then
  echo \"Success: HTTP status $response\"
  exit 0
else
  echo \"Failure: HTTP status $response\"
  exit 1
fi
", dbtToken,dbtHostUrl,dbtAccountId,id))
                .build(), CustomResourceOptions.builder()
                    .dependsOn(List.of(dailyJob))
                    .build());

        }
}

    resources:
  # a periodic job, but we trigger it once with `dbt parse` as soon as it is created so we can defer to the environment it is in
  # to do so, we use a local-exec provisioner, just make sure that the machine running Terraform has curl installed
  dailyJob:
    type: dbtcloud:Job
    name: daily_job
    properties:
      environmentId: ${prodEnvironment.environmentId}
      executeSteps:
        - dbt build
      generateDocs: true
      name: Daily job
      numThreads: 64
      projectId: ${dbtProject.id}
      runGenerateSources: true
      targetName: default
      triggers:
        github_webhook: false
        git_provider_webhook: false
        schedule: true
        on_merge: false
      scheduleDays:
        - 0
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
      scheduleType: days_of_week
      scheduleHours:
        - 0
  dailyJobProvisioner0:
    type: command:local:Command
    properties:
      create: "response=$(curl -s -L -o /dev/null -w \\\"%{http_code}\\\" -X POST \\\\\n  -H 'Authorization: Bearer ${dbtToken}' \\\\\n  -H 'Content-Type: application/json' \\\\\n  -d '{\\\"cause\\\": \\\"Generate manifest\\\", \\\"steps_override\\\": [\\\"dbt parse\\\"]}' \\\\\n  ${dbtHostUrl}/v2/accounts/${dbtAccountId}/jobs/${id}/run/)\n      \nif [ \\\"$response\\\" -ge 200 ] && [ \\\"$response\\\" -lt 300 ]; then\n  echo \\\"Success: HTTP status $response\\\"\n  exit 0\nelse\n  echo \\\"Failure: HTTP status $response\\\"\n  exit 1\nfi\n"
    options:
      dependsOn:
        - ${dailyJob}

    For allowing source freshness deferral

    In the case that deferral is required so that we can use the source_status:fresher+ selector, the process is more complicated as the job will be self deferring.

    An example can be found in this GitHub issue.

    Create Job Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Job(name: string, args: JobArgs, opts?: CustomResourceOptions);
    @overload
def Job(resource_name: str,
        args: JobArgs,
        opts: Optional[ResourceOptions] = None)

@overload
def Job(resource_name: str,
        opts: Optional[ResourceOptions] = None,
        environment_id: Optional[int] = None,
        triggers: Optional[JobTriggersArgs] = None,
        project_id: Optional[int] = None,
        execute_steps: Optional[Sequence[str]] = None,
        name: Optional[str] = None,
        run_compare_changes: Optional[bool] = None,
        errors_on_lint_failure: Optional[bool] = None,
        deferring_job_id: Optional[int] = None,
        execution: Optional[JobExecutionArgs] = None,
        force_node_selection: Optional[bool] = None,
        generate_docs: Optional[bool] = None,
        is_active: Optional[bool] = None,
        job_completion_trigger_conditions: Optional[Sequence[JobJobCompletionTriggerConditionArgs]] = None,
        job_type: Optional[str] = None,
        compare_changes_flags: Optional[str] = None,
        num_threads: Optional[int] = None,
        deferring_environment_id: Optional[int] = None,
        description: Optional[str] = None,
        run_generate_sources: Optional[bool] = None,
        run_lint: Optional[bool] = None,
        schedule_cron: Optional[str] = None,
        schedule_days: Optional[Sequence[int]] = None,
        schedule_hours: Optional[Sequence[int]] = None,
        schedule_interval: Optional[int] = None,
        schedule_type: Optional[str] = None,
        self_deferring: Optional[bool] = None,
        target_name: Optional[str] = None,
        timeout_seconds: Optional[int] = None,
        dbt_version: Optional[str] = None,
        triggers_on_draft_pr: Optional[bool] = None,
        validate_execute_steps: Optional[bool] = None)
    func NewJob(ctx *Context, name string, args JobArgs, opts ...ResourceOption) (*Job, error)
    public Job(string name, JobArgs args, CustomResourceOptions? opts = null)
    public Job(String name, JobArgs args)
public Job(String name, JobArgs args, CustomResourceOptions options)

    type: dbtcloud:Job
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args JobArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args JobArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args JobArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args JobArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args JobArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var jobResource = new DbtCloud.Job("jobResource", new()
{
    EnvironmentId = 0,
    Triggers = new DbtCloud.Inputs.JobTriggersArgs
    {
        GitProviderWebhook = false,
        GithubWebhook = false,
        OnMerge = false,
        Schedule = false,
    },
    ProjectId = 0,
    ExecuteSteps = new[]
    {
        "string",
    },
    Name = "string",
    RunCompareChanges = false,
    ErrorsOnLintFailure = false,
    DeferringJobId = 0,
    Execution = new DbtCloud.Inputs.JobExecutionArgs
    {
        TimeoutSeconds = 0,
    },
    ForceNodeSelection = false,
    GenerateDocs = false,
    IsActive = false,
    CompletionTriggerCondition = new[]
    {
        new DbtCloud.Inputs.JobJobCompletionTriggerConditionArgs
        {
            JobId = 0,
            ProjectId = 0,
            Statuses = new[]
            {
                "string",
            },
        },
    },
    JobType = "string",
    CompareChangesFlags = "string",
    NumThreads = 0,
    DeferringEnvironmentId = 0,
    Description = "string",
    RunGenerateSources = false,
    RunLint = false,
    ScheduleCron = "string",
    ScheduleDays = new[]
    {
        0,
    },
    ScheduleHours = new[]
    {
        0,
    },
    ScheduleInterval = 0,
    ScheduleType = "string",
    SelfDeferring = false,
    TargetName = "string",
    DbtVersion = "string",
    TriggersOnDraftPr = false,
    ValidateExecuteSteps = false,
});

    example, err := dbtcloud.NewJob(ctx, "jobResource", &dbtcloud.JobArgs{
	EnvironmentId: pulumi.Int(0),
	Triggers: &dbtcloud.JobTriggersArgs{
		GitProviderWebhook: pulumi.Bool(false),
		GithubWebhook:      pulumi.Bool(false),
		OnMerge:            pulumi.Bool(false),
		Schedule:           pulumi.Bool(false),
	},
	ProjectId: pulumi.Int(0),
	ExecuteSteps: pulumi.StringArray{
		pulumi.String("string"),
	},
	Name:                pulumi.String("string"),
	RunCompareChanges:   pulumi.Bool(false),
	ErrorsOnLintFailure: pulumi.Bool(false),
	DeferringJobId:      pulumi.Int(0),
	Execution: &dbtcloud.JobExecutionArgs{
		TimeoutSeconds: pulumi.Int(0),
	},
	ForceNodeSelection: pulumi.Bool(false),
	GenerateDocs:       pulumi.Bool(false),
	IsActive:           pulumi.Bool(false),
	JobCompletionTriggerConditions: dbtcloud.JobJobCompletionTriggerConditionArray{
		&dbtcloud.JobJobCompletionTriggerConditionArgs{
			JobId:     pulumi.Int(0),
			ProjectId: pulumi.Int(0),
			Statuses: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
	JobType:                pulumi.String("string"),
	CompareChangesFlags:    pulumi.String("string"),
	NumThreads:             pulumi.Int(0),
	DeferringEnvironmentId: pulumi.Int(0),
	Description:            pulumi.String("string"),
	RunGenerateSources:     pulumi.Bool(false),
	RunLint:                pulumi.Bool(false),
	ScheduleCron:           pulumi.String("string"),
	ScheduleDays: pulumi.IntArray{
		pulumi.Int(0),
	},
	ScheduleHours: pulumi.IntArray{
		pulumi.Int(0),
	},
	ScheduleInterval:     pulumi.Int(0),
	ScheduleType:         pulumi.String("string"),
	SelfDeferring:        pulumi.Bool(false),
	TargetName:           pulumi.String("string"),
	DbtVersion:           pulumi.String("string"),
	TriggersOnDraftPr:    pulumi.Bool(false),
	ValidateExecuteSteps: pulumi.Bool(false),
})

    var jobResource = new Job("jobResource", JobArgs.builder()
    .environmentId(0)
    .triggers(JobTriggersArgs.builder()
        .gitProviderWebhook(false)
        .githubWebhook(false)
        .onMerge(false)
        .schedule(false)
        .build())
    .projectId(0)
    .executeSteps("string")
    .name("string")
    .runCompareChanges(false)
    .errorsOnLintFailure(false)
    .deferringJobId(0)
    .execution(JobExecutionArgs.builder()
        .timeoutSeconds(0)
        .build())
    .forceNodeSelection(false)
    .generateDocs(false)
    .isActive(false)
    .jobCompletionTriggerConditions(JobJobCompletionTriggerConditionArgs.builder()
        .jobId(0)
        .projectId(0)
        .statuses("string")
        .build())
    .jobType("string")
    .compareChangesFlags("string")
    .numThreads(0)
    .deferringEnvironmentId(0)
    .description("string")
    .runGenerateSources(false)
    .runLint(false)
    .scheduleCron("string")
    .scheduleDays(0)
    .scheduleHours(0)
    .scheduleInterval(0)
    .scheduleType("string")
    .selfDeferring(false)
    .targetName("string")
    .dbtVersion("string")
    .triggersOnDraftPr(false)
    .validateExecuteSteps(false)
    .build());

    job_resource = dbtcloud.Job("jobResource",
    environment_id=0,
    triggers={
        "git_provider_webhook": False,
        "github_webhook": False,
        "on_merge": False,
        "schedule": False,
    },
    project_id=0,
    execute_steps=["string"],
    name="string",
    run_compare_changes=False,
    errors_on_lint_failure=False,
    deferring_job_id=0,
    execution={
        "timeout_seconds": 0,
    },
    force_node_selection=False,
    generate_docs=False,
    is_active=False,
    job_completion_trigger_conditions=[{
        "job_id": 0,
        "project_id": 0,
        "statuses": ["string"],
    }],
    job_type="string",
    compare_changes_flags="string",
    num_threads=0,
    deferring_environment_id=0,
    description="string",
    run_generate_sources=False,
    run_lint=False,
    schedule_cron="string",
    schedule_days=[0],
    schedule_hours=[0],
    schedule_interval=0,
    schedule_type="string",
    self_deferring=False,
    target_name="string",
    dbt_version="string",
    triggers_on_draft_pr=False,
    validate_execute_steps=False)

    const jobResource = new dbtcloud.Job("jobResource", {
    environmentId: 0,
    triggers: {
        gitProviderWebhook: false,
        githubWebhook: false,
        onMerge: false,
        schedule: false,
    },
    projectId: 0,
    executeSteps: ["string"],
    name: "string",
    runCompareChanges: false,
    errorsOnLintFailure: false,
    deferringJobId: 0,
    execution: {
        timeoutSeconds: 0,
    },
    forceNodeSelection: false,
    generateDocs: false,
    isActive: false,
    jobCompletionTriggerConditions: [{
        jobId: 0,
        projectId: 0,
        statuses: ["string"],
    }],
    jobType: "string",
    compareChangesFlags: "string",
    numThreads: 0,
    deferringEnvironmentId: 0,
    description: "string",
    runGenerateSources: false,
    runLint: false,
    scheduleCron: "string",
    scheduleDays: [0],
    scheduleHours: [0],
    scheduleInterval: 0,
    scheduleType: "string",
    selfDeferring: false,
    targetName: "string",
    dbtVersion: "string",
    triggersOnDraftPr: false,
    validateExecuteSteps: false,
});

    type: dbtcloud:Job
properties:
    compareChangesFlags: string
    dbtVersion: string
    deferringEnvironmentId: 0
    deferringJobId: 0
    description: string
    environmentId: 0
    errorsOnLintFailure: false
    executeSteps:
        - string
    execution:
        timeoutSeconds: 0
    forceNodeSelection: false
    generateDocs: false
    isActive: false
    jobCompletionTriggerConditions:
        - jobId: 0
          projectId: 0
          statuses:
            - string
    jobType: string
    name: string
    numThreads: 0
    projectId: 0
    runCompareChanges: false
    runGenerateSources: false
    runLint: false
    scheduleCron: string
    scheduleDays:
        - 0
    scheduleHours:
        - 0
    scheduleInterval: 0
    scheduleType: string
    selfDeferring: false
    targetName: string
    triggers:
        gitProviderWebhook: false
        githubWebhook: false
        onMerge: false
        schedule: false
    triggersOnDraftPr: false
    validateExecuteSteps: false

    Job Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Job resource accepts the following input properties:

    EnvironmentId int
    Environment ID to create the job in
    ExecuteSteps List<string>
    List of commands to execute for the job
    ProjectId int
    Project ID to create the job in
    Triggers Pulumi.DbtCloud.Inputs.JobTriggers
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    CompareChangesFlags string
    The model selector for checking changes in the compare changes Advanced CI feature
    CompletionTriggerCondition List<Pulumi.DbtCloud.Inputs.JobJobCompletionTriggerCondition>
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    DbtVersion string
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    DeferringEnvironmentId int
    Environment identifier that this job defers to (new deferring approach)
    DeferringJobId int
    Job identifier that this job defers to (legacy deferring approach)
    Description string
    Description for the job
    ErrorsOnLintFailure bool
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    Execution Pulumi.DbtCloud.Inputs.JobExecution
    Execution settings for the job
    ForceNodeSelection bool
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    GenerateDocs bool
    Flag for whether the job should generate documentation
    IsActive bool
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    JobType string
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    Name string
    Job name
    NumThreads int
    Number of threads to use in the job
    RunCompareChanges bool
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    RunGenerateSources bool
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    RunLint bool
    Whether the CI job should lint SQL changes. Defaults to false.
    ScheduleCron string
    Custom cron expression for schedule
    ScheduleDays List<int>
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    ScheduleHours List<int>
    List of hours to execute the job at if running on a schedule
    ScheduleInterval int
    Number of hours between job executions if running on a schedule
    ScheduleType string
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    SelfDeferring bool
    Whether this job defers on a previous run of itself
    TargetName string
    Target name for the dbt profile
    TimeoutSeconds int
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    TriggersOnDraftPr bool
    Whether the CI job should be automatically triggered on draft PRs
    ValidateExecuteSteps bool
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    EnvironmentId int
    Environment ID to create the job in
    ExecuteSteps []string
    List of commands to execute for the job
    ProjectId int
    Project ID to create the job in
    Triggers JobTriggersArgs
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    CompareChangesFlags string
    The model selector for checking changes in the compare changes Advanced CI feature
    DbtVersion string
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    DeferringEnvironmentId int
    Environment identifier that this job defers to (new deferring approach)
    DeferringJobId int
    Job identifier that this job defers to (legacy deferring approach)
    Description string
    Description for the job
    ErrorsOnLintFailure bool
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    Execution JobExecutionArgs
    Execution settings for the job
    ForceNodeSelection bool
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    GenerateDocs bool
    Flag for whether the job should generate documentation
    IsActive bool
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    JobCompletionTriggerConditions []JobJobCompletionTriggerConditionArgs
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    JobType string
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    Name string
    Job name
    NumThreads int
    Number of threads to use in the job
    RunCompareChanges bool
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    RunGenerateSources bool
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    RunLint bool
    Whether the CI job should lint SQL changes. Defaults to false.
    ScheduleCron string
    Custom cron expression for schedule
    ScheduleDays []int
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    ScheduleHours []int
    List of hours to execute the job at if running on a schedule
    ScheduleInterval int
    Number of hours between job executions if running on a schedule
    ScheduleType string
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    SelfDeferring bool
    Whether this job defers on a previous run of itself
    TargetName string
    Target name for the dbt profile
    TimeoutSeconds int
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    TriggersOnDraftPr bool
    Whether the CI job should be automatically triggered on draft PRs
    ValidateExecuteSteps bool
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    environmentId Integer
    Environment ID to create the job in
    executeSteps List<String>
    List of commands to execute for the job
    projectId Integer
    Project ID to create the job in
    triggers JobTriggers
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    compareChangesFlags String
    The model selector for checking changes in the compare changes Advanced CI feature
    dbtVersion String
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferringEnvironmentId Integer
    Environment identifier that this job defers to (new deferring approach)
    deferringJobId Integer
    Job identifier that this job defers to (legacy deferring approach)
    description String
    Description for the job
    errorsOnLintFailure Boolean
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    execution JobExecution
    Execution settings for the job
    forceNodeSelection Boolean
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generateDocs Boolean
    Flag for whether the job should generate documentation
    isActive Boolean
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    jobCompletionTriggerConditions List<JobJobCompletionTriggerCondition>
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    jobType String
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name String
    Job name
    numThreads Integer
    Number of threads to use in the job
    runCompareChanges Boolean
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    runGenerateSources Boolean
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    runLint Boolean
    Whether the CI job should lint SQL changes. Defaults to false.
    scheduleCron String
    Custom cron expression for schedule
    scheduleDays List<Integer>
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    scheduleHours List<Integer>
    List of hours to execute the job at if running on a schedule
    scheduleInterval Integer
    Number of hours between job executions if running on a schedule
    scheduleType String
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    selfDeferring Boolean
    Whether this job defers on a previous run of itself
    targetName String
    Target name for the dbt profile
    timeoutSeconds Integer
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggersOnDraftPr Boolean
    Whether the CI job should be automatically triggered on draft PRs
    validateExecuteSteps Boolean
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    environmentId number
    Environment ID to create the job in
    executeSteps string[]
    List of commands to execute for the job
    projectId number
    Project ID to create the job in
    triggers JobTriggers
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    compareChangesFlags string
    The model selector for checking changes in the compare changes Advanced CI feature
    dbtVersion string
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferringEnvironmentId number
    Environment identifier that this job defers to (new deferring approach)
    deferringJobId number
    Job identifier that this job defers to (legacy deferring approach)
    description string
    Description for the job
    errorsOnLintFailure boolean
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    execution JobExecution
    Execution settings for the job
    forceNodeSelection boolean
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generateDocs boolean
    Flag for whether the job should generate documentation
    isActive boolean
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    jobCompletionTriggerConditions JobJobCompletionTriggerCondition[]
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    jobType string
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name string
    Job name
    numThreads number
    Number of threads to use in the job
    runCompareChanges boolean
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    runGenerateSources boolean
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    runLint boolean
    Whether the CI job should lint SQL changes. Defaults to false.
    scheduleCron string
    Custom cron expression for schedule
    scheduleDays number[]
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    scheduleHours number[]
    List of hours to execute the job at if running on a schedule
    scheduleInterval number
    Number of hours between job executions if running on a schedule
    scheduleType string
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    selfDeferring boolean
    Whether this job defers on a previous run of itself
    targetName string
    Target name for the dbt profile
    timeoutSeconds number
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggersOnDraftPr boolean
    Whether the CI job should be automatically triggered on draft PRs
    validateExecuteSteps boolean
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    environment_id int
    Environment ID to create the job in
    execute_steps Sequence[str]
    List of commands to execute for the job
    project_id int
    Project ID to create the job in
    triggers JobTriggersArgs
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    compare_changes_flags str
    The model selector for checking changes in the compare changes Advanced CI feature
    dbt_version str
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferring_environment_id int
    Environment identifier that this job defers to (new deferring approach)
    deferring_job_id int
    Job identifier that this job defers to (legacy deferring approach)
    description str
    Description for the job
    errors_on_lint_failure bool
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    execution JobExecutionArgs
    Execution settings for the job
    force_node_selection bool
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generate_docs bool
    Flag for whether the job should generate documentation
    is_active bool
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    job_completion_trigger_conditions Sequence[JobJobCompletionTriggerConditionArgs]
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    job_type str
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name str
    Job name
    num_threads int
    Number of threads to use in the job
    run_compare_changes bool
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    run_generate_sources bool
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    run_lint bool
    Whether the CI job should lint SQL changes. Defaults to false.
    schedule_cron str
    Custom cron expression for schedule
    schedule_days Sequence[int]
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    schedule_hours Sequence[int]
    List of hours to execute the job at if running on a schedule
    schedule_interval int
    Number of hours between job executions if running on a schedule
    schedule_type str
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    self_deferring bool
    Whether this job defers on a previous run of itself
    target_name str
    Target name for the dbt profile
    timeout_seconds int
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggers_on_draft_pr bool
    Whether the CI job should be automatically triggered on draft PRs
    validate_execute_steps bool
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    environmentId Number
    Environment ID to create the job in
    executeSteps List<String>
    List of commands to execute for the job
    projectId Number
    Project ID to create the job in
    triggers Property Map
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    compareChangesFlags String
    The model selector for checking changes in the compare changes Advanced CI feature
    dbtVersion String
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferringEnvironmentId Number
    Environment identifier that this job defers to (new deferring approach)
    deferringJobId Number
    Job identifier that this job defers to (legacy deferring approach)
    description String
    Description for the job
    errorsOnLintFailure Boolean
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    execution Property Map
    Execution settings for the job
    forceNodeSelection Boolean
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generateDocs Boolean
    Flag for whether the job should generate documentation
    isActive Boolean
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    jobCompletionTriggerConditions List<Property Map>
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    jobType String
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name String
    Job name
    numThreads Number
    Number of threads to use in the job
    runCompareChanges Boolean
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    runGenerateSources Boolean
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    runLint Boolean
    Whether the CI job should lint SQL changes. Defaults to false.
    scheduleCron String
    Custom cron expression for schedule
    scheduleDays List<Number>
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    scheduleHours List<Number>
    List of hours to execute the job at if running on a schedule
    scheduleInterval Number
    Number of hours between job executions if running on a schedule
    scheduleType String
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    selfDeferring Boolean
    Whether this job defers on a previous run of itself
    targetName String
    Target name for the dbt profile
    timeoutSeconds Number
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggersOnDraftPr Boolean
    Whether the CI job should be automatically triggered on draft PRs
    validateExecuteSteps Boolean
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Job resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    JobId int
    Job identifier
    Id string
    The provider-assigned unique ID for this managed resource.
    JobId int
    Job identifier
    id String
    The provider-assigned unique ID for this managed resource.
    jobId Integer
    Job identifier
    id string
    The provider-assigned unique ID for this managed resource.
    jobId number
    Job identifier
    id str
    The provider-assigned unique ID for this managed resource.
    job_id int
    Job identifier
    id String
    The provider-assigned unique ID for this managed resource.
    jobId Number
    Job identifier

    Look up Existing Job Resource

    Get an existing Job resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: JobState, opts?: CustomResourceOptions): Job
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        compare_changes_flags: Optional[str] = None,
        dbt_version: Optional[str] = None,
        deferring_environment_id: Optional[int] = None,
        deferring_job_id: Optional[int] = None,
        description: Optional[str] = None,
        environment_id: Optional[int] = None,
        errors_on_lint_failure: Optional[bool] = None,
        execute_steps: Optional[Sequence[str]] = None,
        execution: Optional[JobExecutionArgs] = None,
        force_node_selection: Optional[bool] = None,
        generate_docs: Optional[bool] = None,
        is_active: Optional[bool] = None,
        job_completion_trigger_conditions: Optional[Sequence[JobJobCompletionTriggerConditionArgs]] = None,
        job_id: Optional[int] = None,
        job_type: Optional[str] = None,
        name: Optional[str] = None,
        num_threads: Optional[int] = None,
        project_id: Optional[int] = None,
        run_compare_changes: Optional[bool] = None,
        run_generate_sources: Optional[bool] = None,
        run_lint: Optional[bool] = None,
        schedule_cron: Optional[str] = None,
        schedule_days: Optional[Sequence[int]] = None,
        schedule_hours: Optional[Sequence[int]] = None,
        schedule_interval: Optional[int] = None,
        schedule_type: Optional[str] = None,
        self_deferring: Optional[bool] = None,
        target_name: Optional[str] = None,
        timeout_seconds: Optional[int] = None,
        triggers: Optional[JobTriggersArgs] = None,
        triggers_on_draft_pr: Optional[bool] = None,
        validate_execute_steps: Optional[bool] = None) -> Job
    func GetJob(ctx *Context, name string, id IDInput, state *JobState, opts ...ResourceOption) (*Job, error)
    public static Job Get(string name, Input<string> id, JobState? state, CustomResourceOptions? opts = null)
    public static Job get(String name, Output<String> id, JobState state, CustomResourceOptions options)
    resources:  _:    type: dbtcloud:Job    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CompareChangesFlags string
    The model selector for checking changes in the compare changes Advanced CI feature
    CompletionTriggerCondition List<Pulumi.DbtCloud.Inputs.JobJobCompletionTriggerCondition>
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    DbtVersion string
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    DeferringEnvironmentId int
    Environment identifier that this job defers to (new deferring approach)
    DeferringJobId int
    Job identifier that this job defers to (legacy deferring approach)
    Description string
    Description for the job
    EnvironmentId int
    Environment ID to create the job in
    ErrorsOnLintFailure bool
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    ExecuteSteps List<string>
    List of commands to execute for the job
    Execution Pulumi.DbtCloud.Inputs.JobExecution
    Execution settings for the job
    ForceNodeSelection bool
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    GenerateDocs bool
    Flag for whether the job should generate documentation
    IsActive bool
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    JobId int
    Job identifier
    JobType string
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    Name string
    Job name
    NumThreads int
    Number of threads to use in the job
    ProjectId int
    Project ID to create the job in
    RunCompareChanges bool
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    RunGenerateSources bool
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    RunLint bool
    Whether the CI job should lint SQL changes. Defaults to false.
    ScheduleCron string
    Custom cron expression for schedule
    ScheduleDays List<int>
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    ScheduleHours List<int>
    List of hours to execute the job at if running on a schedule
    ScheduleInterval int
    Number of hours between job executions if running on a schedule
    ScheduleType string
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    SelfDeferring bool
    Whether this job defers on a previous run of itself
    TargetName string
    Target name for the dbt profile
    TimeoutSeconds int
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    Triggers Pulumi.DbtCloud.Inputs.JobTriggers
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    TriggersOnDraftPr bool
    Whether the CI job should be automatically triggered on draft PRs
    ValidateExecuteSteps bool
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    CompareChangesFlags string
    The model selector for checking changes in the compare changes Advanced CI feature
    DbtVersion string
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    DeferringEnvironmentId int
    Environment identifier that this job defers to (new deferring approach)
    DeferringJobId int
    Job identifier that this job defers to (legacy deferring approach)
    Description string
    Description for the job
    EnvironmentId int
    Environment ID to create the job in
    ErrorsOnLintFailure bool
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    ExecuteSteps []string
    List of commands to execute for the job
    Execution JobExecutionArgs
    Execution settings for the job
    ForceNodeSelection bool
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    GenerateDocs bool
    Flag for whether the job should generate documentation
    IsActive bool
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    JobCompletionTriggerConditions []JobJobCompletionTriggerConditionArgs
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    JobId int
    Job identifier
    JobType string
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    Name string
    Job name
    NumThreads int
    Number of threads to use in the job
    ProjectId int
    Project ID to create the job in
    RunCompareChanges bool
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    RunGenerateSources bool
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    RunLint bool
    Whether the CI job should lint SQL changes. Defaults to false.
    ScheduleCron string
    Custom cron expression for schedule
    ScheduleDays []int
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    ScheduleHours []int
    List of hours to execute the job at if running on a schedule
    ScheduleInterval int
    Number of hours between job executions if running on a schedule
    ScheduleType string
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    SelfDeferring bool
    Whether this job defers on a previous run of itself
    TargetName string
    Target name for the dbt profile
    TimeoutSeconds int
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    Triggers JobTriggersArgs
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    TriggersOnDraftPr bool
    Whether the CI job should be automatically triggered on draft PRs
    ValidateExecuteSteps bool
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    compareChangesFlags String
    The model selector for checking changes in the compare changes Advanced CI feature
    dbtVersion String
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferringEnvironmentId Integer
    Environment identifier that this job defers to (new deferring approach)
    deferringJobId Integer
    Job identifier that this job defers to (legacy deferring approach)
    description String
    Description for the job
    environmentId Integer
    Environment ID to create the job in
    errorsOnLintFailure Boolean
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    executeSteps List<String>
    List of commands to execute for the job
    execution JobExecution
    Execution settings for the job
    forceNodeSelection Boolean
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generateDocs Boolean
    Flag for whether the job should generate documentation
    isActive Boolean
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    jobCompletionTriggerConditions List<JobJobCompletionTriggerCondition>
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    jobId Integer
    Job identifier
    jobType String
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name String
    Job name
    numThreads Integer
    Number of threads to use in the job
    projectId Integer
    Project ID to create the job in
    runCompareChanges Boolean
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    runGenerateSources Boolean
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    runLint Boolean
    Whether the CI job should lint SQL changes. Defaults to false.
    scheduleCron String
    Custom cron expression for schedule
    scheduleDays List<Integer>
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    scheduleHours List<Integer>
    List of hours to execute the job at if running on a schedule
    scheduleInterval Integer
    Number of hours between job executions if running on a schedule
    scheduleType String
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    selfDeferring Boolean
    Whether this job defers on a previous run of itself
    targetName String
    Target name for the dbt profile
    timeoutSeconds Integer
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggers JobTriggers
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    triggersOnDraftPr Boolean
    Whether the CI job should be automatically triggered on draft PRs
    validateExecuteSteps Boolean
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    compareChangesFlags string
    The model selector for checking changes in the compare changes Advanced CI feature
    dbtVersion string
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferringEnvironmentId number
    Environment identifier that this job defers to (new deferring approach)
    deferringJobId number
    Job identifier that this job defers to (legacy deferring approach)
    description string
    Description for the job
    environmentId number
    Environment ID to create the job in
    errorsOnLintFailure boolean
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    executeSteps string[]
    List of commands to execute for the job
    execution JobExecution
    Execution settings for the job
    forceNodeSelection boolean
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generateDocs boolean
    Flag for whether the job should generate documentation
    isActive boolean
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    jobCompletionTriggerConditions JobJobCompletionTriggerCondition[]
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    jobId number
    Job identifier
    jobType string
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name string
    Job name
    numThreads number
    Number of threads to use in the job
    projectId number
    Project ID to create the job in
    runCompareChanges boolean
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    runGenerateSources boolean
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    runLint boolean
    Whether the CI job should lint SQL changes. Defaults to false.
    scheduleCron string
    Custom cron expression for schedule
    scheduleDays number[]
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    scheduleHours number[]
    List of hours to execute the job at if running on a schedule
    scheduleInterval number
    Number of hours between job executions if running on a schedule
    scheduleType string
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    selfDeferring boolean
    Whether this job defers on a previous run of itself
    targetName string
    Target name for the dbt profile
    timeoutSeconds number
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggers JobTriggers
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    triggersOnDraftPr boolean
    Whether the CI job should be automatically triggered on draft PRs
    validateExecuteSteps boolean
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    compare_changes_flags str
    The model selector for checking changes in the compare changes Advanced CI feature
    dbt_version str
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferring_environment_id int
    Environment identifier that this job defers to (new deferring approach)
    deferring_job_id int
    Job identifier that this job defers to (legacy deferring approach)
    description str
    Description for the job
    environment_id int
    Environment ID to create the job in
    errors_on_lint_failure bool
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    execute_steps Sequence[str]
    List of commands to execute for the job
    execution JobExecutionArgs
    Execution settings for the job
    force_node_selection bool
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generate_docs bool
    Flag for whether the job should generate documentation
    is_active bool
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    job_completion_trigger_conditions Sequence[JobJobCompletionTriggerConditionArgs]
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    job_id int
    Job identifier
    job_type str
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name str
    Job name
    num_threads int
    Number of threads to use in the job
    project_id int
    Project ID to create the job in
    run_compare_changes bool
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    run_generate_sources bool
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    run_lint bool
    Whether the CI job should lint SQL changes. Defaults to false.
    schedule_cron str
    Custom cron expression for schedule
    schedule_days Sequence[int]
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    schedule_hours Sequence[int]
    List of hours to execute the job at if running on a schedule
    schedule_interval int
    Number of hours between job executions if running on a schedule
    schedule_type str
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    self_deferring bool
    Whether this job defers on a previous run of itself
    target_name str
    Target name for the dbt profile
    timeout_seconds int
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggers JobTriggersArgs
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    triggers_on_draft_pr bool
    Whether the CI job should be automatically triggered on draft PRs
    validate_execute_steps bool
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.
    compareChangesFlags String
    The model selector for checking changes in the compare changes Advanced CI feature
    dbtVersion String
    Version number of dbt to use in this job, usually in the format 1.2.0-latest rather than core versions
    deferringEnvironmentId Number
    Environment identifier that this job defers to (new deferring approach)
    deferringJobId Number
    Job identifier that this job defers to (legacy deferring approach)
    description String
    Description for the job
    environmentId Number
    Environment ID to create the job in
    errorsOnLintFailure Boolean
    Whether the CI job should fail when a lint error is found. Only used when run_lint is set to true. Defaults to true.
    executeSteps List<String>
    List of commands to execute for the job
    execution Property Map
    Execution settings for the job
    forceNodeSelection Boolean
    Whether to force node selection (SAO - Select All Optimizations) for the job. If dbt_version is not set to latest-fusion, this must be set to true when specified.
    generateDocs Boolean
    Flag for whether the job should generate documentation
    isActive Boolean
    Should always be set to true as setting it to false is the same as creating a job in a deleted state. To create/keep a job in a 'deactivated' state, check the triggers config. Setting it to false essentially deletes the job. On resource creation, this field is enforced to be true.
    jobCompletionTriggerConditions List<Property Map>
    Which other job should trigger this job when it finishes, and on which conditions (sometimes referred as 'job chaining').
    jobId Number
    Job identifier
    jobType String
    Can be used to enforce the job type betwen ci, merge and scheduled. Without this value the job type is inferred from the triggers configured
    name String
    Job name
    numThreads Number
    Number of threads to use in the job
    projectId Number
    Project ID to create the job in
    runCompareChanges Boolean
    Whether the CI job should compare data changes introduced by the code changes. Requires deferring_environment_id to be set. (Advanced CI needs to be activated in the dbt Cloud Account Settings first as well)
    runGenerateSources Boolean
    Flag for whether the job should add a dbt source freshness step to the job. The difference between manually adding a step with dbt source freshness in the job steps or using this flag is that with this flag, a failed freshness will still allow the following steps to run.
    runLint Boolean
    Whether the CI job should lint SQL changes. Defaults to false.
    scheduleCron String
    Custom cron expression for schedule
    scheduleDays List<Number>
    List of days of week as numbers (0 = Sunday, 7 = Saturday) to execute the job at if running on a schedule
    scheduleHours List<Number>
    List of hours to execute the job at if running on a schedule
    scheduleInterval Number
    Number of hours between job executions if running on a schedule
    scheduleType String
    Type of schedule to use, one of everyday/ daysofweek/ customcron/ interval_cron
    selfDeferring Boolean
    Whether this job defers on a previous run of itself
    targetName String
    Target name for the dbt profile
    timeoutSeconds Number
    Number of seconds to allow the job to run before timing out. Use execution.timeout_seconds instead.

    Deprecated: Use execution.timeout_seconds instead

    triggers Property Map
    Flags for which types of triggers to use, the values are github_webhook, git_provider_webhook, schedule and on_merge. All flags should be listed and set with true or false. When on_merge is true, all the other values must be false.\n\ncustom_branch_only used to be allowed but has been deprecated from the API. The jobs will use the custom branch of the environment. Please remove the custom_branch_only from your config. \n\nTo create a job in a 'deactivated' state, set all to false.
    triggersOnDraftPr Boolean
    Whether the CI job should be automatically triggered on draft PRs
    validateExecuteSteps Boolean
    When set to true, the provider will validate the execute_steps during plan time to ensure they contain valid dbt commands. If a command is not recognized (e.g., a new dbt command not yet supported by the provider), the validation will fail. Defaults to false to allow flexibility with newer dbt commands.

    Supporting Types

    JobExecution, JobExecutionArgs

    TimeoutSeconds int
    The number of seconds before the job times out
    TimeoutSeconds int
    The number of seconds before the job times out
    timeoutSeconds Integer
    The number of seconds before the job times out
    timeoutSeconds number
    The number of seconds before the job times out
    timeout_seconds int
    The number of seconds before the job times out
    timeoutSeconds Number
    The number of seconds before the job times out

    JobJobCompletionTriggerCondition, JobJobCompletionTriggerConditionArgs

    JobId int
    The ID of the job that would trigger this job after completion.
    ProjectId int
    The ID of the project where the trigger job is running in.
    Statuses List<string>
    List of statuses to trigger the job on. Possible values are success, error and canceled.
    JobId int
    The ID of the job that would trigger this job after completion.
    ProjectId int
    The ID of the project where the trigger job is running in.
    Statuses []string
    List of statuses to trigger the job on. Possible values are success, error and canceled.
    jobId Integer
    The ID of the job that would trigger this job after completion.
    projectId Integer
    The ID of the project where the trigger job is running in.
    statuses List<String>
    List of statuses to trigger the job on. Possible values are success, error and canceled.
    jobId number
    The ID of the job that would trigger this job after completion.
    projectId number
    The ID of the project where the trigger job is running in.
    statuses string[]
    List of statuses to trigger the job on. Possible values are success, error and canceled.
    job_id int
    The ID of the job that would trigger this job after completion.
    project_id int
    The ID of the project where the trigger job is running in.
    statuses Sequence[str]
    List of statuses to trigger the job on. Possible values are success, error and canceled.
    jobId Number
    The ID of the job that would trigger this job after completion.
    projectId Number
    The ID of the project where the trigger job is running in.
    statuses List<String>
    List of statuses to trigger the job on. Possible values are success, error and canceled.

    JobTriggers, JobTriggersArgs

    GitProviderWebhook bool
    Whether the job runs automatically on PR creation
    GithubWebhook bool
    Whether the job runs automatically on PR creation
    OnMerge bool
    Whether the job runs automatically once a PR is merged
    Schedule bool
    Whether the job runs on a schedule
    GitProviderWebhook bool
    Whether the job runs automatically on PR creation
    GithubWebhook bool
    Whether the job runs automatically on PR creation
    OnMerge bool
    Whether the job runs automatically once a PR is merged
    Schedule bool
    Whether the job runs on a schedule
    gitProviderWebhook Boolean
    Whether the job runs automatically on PR creation
    githubWebhook Boolean
    Whether the job runs automatically on PR creation
    onMerge Boolean
    Whether the job runs automatically once a PR is merged
    schedule Boolean
    Whether the job runs on a schedule
    gitProviderWebhook boolean
    Whether the job runs automatically on PR creation
    githubWebhook boolean
    Whether the job runs automatically on PR creation
    onMerge boolean
    Whether the job runs automatically once a PR is merged
    schedule boolean
    Whether the job runs on a schedule
    git_provider_webhook bool
    Whether the job runs automatically on PR creation
    github_webhook bool
    Whether the job runs automatically on PR creation
    on_merge bool
    Whether the job runs automatically once a PR is merged
    schedule bool
    Whether the job runs on a schedule
    gitProviderWebhook Boolean
    Whether the job runs automatically on PR creation
    githubWebhook Boolean
    Whether the job runs automatically on PR creation
    onMerge Boolean
    Whether the job runs automatically once a PR is merged
    schedule Boolean
    Whether the job runs on a schedule

    Import

    using import blocks (requires Terraform >= 1.5) import { to = dbtcloud_job.my_job id = <span pulumi-lang-nodejs=““jobId”” pulumi-lang-dotnet=““JobId”” pulumi-lang-go=““jobId”” pulumi-lang-python=““job_id”” pulumi-lang-yaml=““jobId”” pulumi-lang-java=““jobId”">“job_id” }

    import { to = dbtcloud_job.my_job id = “12345” }

    using the older import command

    $ pulumi import dbtcloud:index/job:Job my_job "job_id"
$ pulumi import dbtcloud:index/job:Job my_job 12345

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    dbtcloud pulumi/pulumi-dbtcloud
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the dbtcloud Terraform Provider.
    dbtcloud logo
    dbt Cloud v1.6.0 published on Friday, Feb 20, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-dbtcloud
      Meet Neo: Your AI Platform Teammate