@pulumi/pagerduty/jiraCloudAccountMappingRule.d.ts

A Pulumi package for creating and managing pagerduty cloud resources.

import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * An Jira Cloud's account mapping [rule](https://developer.pagerduty.com/api-reference/85dc30ba966a6-create-a-rule)
 * configures the bidirectional synchronization between Jira issues and PagerDuty
 * incidents.
 *
 * ## Example Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as pagerduty from "@pulumi/pagerduty";
 *
 * const _default = pagerduty.getEscalationPolicy({
 *     name: "Default",
 * });
 * const p1 = pagerduty.getPriority({
 *     name: "P1",
 * });
 * const p2 = pagerduty.getPriority({
 *     name: "P2",
 * });
 * const p3 = pagerduty.getPriority({
 *     name: "P3",
 * });
 * const foo = new pagerduty.Service("foo", {
 *     name: "My Web App",
 *     escalationPolicy: _default.then(_default => _default.id),
 * });
 * const fooUser = new pagerduty.User("foo", {
 *     name: "Earline Greenholt",
 *     email: "125.greenholt.earline@graham.name",
 * });
 * const fooJiraCloudAccountMappingRule = new pagerduty.JiraCloudAccountMappingRule("foo", {
 *     name: "Integration with My Web App",
 *     accountMapping: "PLBP09X",
 *     config: {
 *         service: foo.id,
 *         jira: {
 *             autocreateJql: "priority = Highest",
 *             createIssueOnIncidentTrigger: true,
 *             customFields: [
 *                 {
 *                     sourceIncidentField: "incident_description",
 *                     targetIssueField: "description",
 *                     targetIssueFieldName: "Description",
 *                     type: "attribute",
 *                 },
 *                 {
 *                     targetIssueField: "security",
 *                     targetIssueFieldName: "Security Level",
 *                     type: "jira_value",
 *                     value: JSON.stringify({
 *                         displayName: "Sec Level 1",
 *                         id: "10000",
 *                     }),
 *                 },
 *             ],
 *             issueType: {
 *                 id: "10001",
 *                 name: "Incident",
 *             },
 *             priorities: [
 *                 {
 *                     jiraId: "1",
 *                     pagerdutyId: p1.then(p1 => p1.id),
 *                 },
 *                 {
 *                     jiraId: "2",
 *                     pagerdutyId: p2.then(p2 => p2.id),
 *                 },
 *                 {
 *                     jiraId: "3",
 *                     pagerdutyId: p3.then(p3 => p3.id),
 *                 },
 *             ],
 *             project: {
 *                 id: "10100",
 *                 key: "ITS",
 *                 name: "IT Support",
 *             },
 *             statusMapping: {
 *                 acknowledged: {
 *                     id: "2",
 *                     name: "In Progress",
 *                 },
 *                 resolved: {
 *                     id: "3",
 *                     name: "Resolved",
 *                 },
 *                 triggered: {
 *                     id: "1",
 *                     name: "Open",
 *                 },
 *             },
 *             syncNotesUser: fooUser.id,
 *         },
 *     },
 * });
 * ```
 *
 * ## Import
 *
 * Jira Cloud account mapping rules can be imported using the `accountMappingId` and `ruleId`, e.g.
 *
 * ```sh
 * $ pulumi import pagerduty:index/jiraCloudAccountMappingRule:JiraCloudAccountMappingRule main PLBP09X:PLB09Z
 * ```
 */
export declare class JiraCloudAccountMappingRule extends pulumi.CustomResource {
    /**
     * Get an existing JiraCloudAccountMappingRule resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: JiraCloudAccountMappingRuleState, opts?: pulumi.CustomResourceOptions): JiraCloudAccountMappingRule;
    /**
     * Returns true if the given object is an instance of JiraCloudAccountMappingRule.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is JiraCloudAccountMappingRule;
    /**
     * [Updating can cause a resource replacement] The account mapping this rule belongs to.
     */
    readonly accountMapping: pulumi.Output<string>;
    /**
     * If auto-creation using JQL is disabled, this field provides the reason for the disablement.
     */
    readonly autocreateJqlDisabledReason: pulumi.Output<string>;
    /**
     * The timestamp until which the auto-creation using JQL feature is disabled.
     */
    readonly autocreateJqlDisabledUntil: pulumi.Output<string>;
    /**
     * Configuration for bidirectional synchronization between Jira issues and PagerDuty incidents.
     */
    readonly config: pulumi.Output<outputs.JiraCloudAccountMappingRuleConfig | undefined>;
    /**
     * Indicates if the rule is enabled. Defaults to `true`.
     */
    readonly enabled: pulumi.Output<boolean>;
    /**
     * The name of the rule.
     */
    readonly name: pulumi.Output<string>;
    /**
     * Create a JiraCloudAccountMappingRule resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: JiraCloudAccountMappingRuleArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering JiraCloudAccountMappingRule resources.
 */
export interface JiraCloudAccountMappingRuleState {
    /**
     * [Updating can cause a resource replacement] The account mapping this rule belongs to.
     */
    accountMapping?: pulumi.Input<string | undefined>;
    /**
     * If auto-creation using JQL is disabled, this field provides the reason for the disablement.
     */
    autocreateJqlDisabledReason?: pulumi.Input<string | undefined>;
    /**
     * The timestamp until which the auto-creation using JQL feature is disabled.
     */
    autocreateJqlDisabledUntil?: pulumi.Input<string | undefined>;
    /**
     * Configuration for bidirectional synchronization between Jira issues and PagerDuty incidents.
     */
    config?: pulumi.Input<inputs.JiraCloudAccountMappingRuleConfig | undefined>;
    /**
     * Indicates if the rule is enabled. Defaults to `true`.
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * The name of the rule.
     */
    name?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a JiraCloudAccountMappingRule resource.
 */
export interface JiraCloudAccountMappingRuleArgs {
    /**
     * [Updating can cause a resource replacement] The account mapping this rule belongs to.
     */
    accountMapping: pulumi.Input<string>;
    /**
     * Configuration for bidirectional synchronization between Jira issues and PagerDuty incidents.
     */
    config?: pulumi.Input<inputs.JiraCloudAccountMappingRuleConfig | undefined>;
    /**
     * Indicates if the rule is enabled. Defaults to `true`.
     */
    enabled?: pulumi.Input<boolean | undefined>;
    /**
     * The name of the rule.
     */
    name?: pulumi.Input<string | undefined>;
}
//# sourceMappingURL=jiraCloudAccountMappingRule.d.ts.map