import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * This message configures which resources and services to monitor for availability.
 *
 * To get more information about UptimeCheckConfig, see:
 *
 * * [API documentation](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.uptimeCheckConfigs)
 * * How-to Guides
 *     * [Official Documentation](https://cloud.google.com/monitoring/uptime-checks/)
 *
 * ## Example Usage
 *
 * ### Uptime Check Config Http
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const http = new gcp.monitoring.UptimeCheckConfig("http", {
 *     displayName: "http-uptime-check",
 *     timeout: "60s",
 *     logCheckFailures: true,
 *     userLabels: {
 *         "example-key": "example-value",
 *     },
 *     httpCheck: {
 *         path: "some-path",
 *         port: 8010,
 *         requestMethod: "POST",
 *         contentType: "USER_PROVIDED",
 *         customContentType: "application/json",
 *         body: "Zm9vJTI1M0RiYXI=",
 *         pingConfig: {
 *             pingsCount: 1,
 *         },
 *     },
 *     monitoredResource: {
 *         type: "uptime_url",
 *         labels: {
 *             project_id: "my-project-name",
 *             host: "192.168.1.1",
 *         },
 *     },
 *     contentMatchers: [{
 *         content: "\"example\"",
 *         matcher: "MATCHES_JSON_PATH",
 *         jsonPathMatcher: {
 *             jsonPath: "$.path",
 *             jsonMatcher: "EXACT_MATCH",
 *         },
 *     }],
 *     checkerType: "STATIC_IP_CHECKERS",
 * });
 * ```
 * ### Uptime Check Config Http Password Wo
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const http = new gcp.monitoring.UptimeCheckConfig("http", {
 *     displayName: "http-uptime-check",
 *     timeout: "60s",
 *     userLabels: {
 *         "example-key": "example-value",
 *     },
 *     httpCheck: {
 *         path: "some-path",
 *         port: 8010,
 *         requestMethod: "POST",
 *         contentType: "USER_PROVIDED",
 *         customContentType: "application/json",
 *         body: "Zm9vJTI1M0RiYXI=",
 *         pingConfig: {
 *             pingsCount: 1,
 *         },
 *         authInfo: {
 *             username: "name",
 *             passwordWo: "password1",
 *             passwordWoVersion: "1",
 *         },
 *     },
 *     monitoredResource: {
 *         type: "uptime_url",
 *         labels: {
 *             project_id: "my-project-name",
 *             host: "192.168.1.1",
 *         },
 *     },
 *     contentMatchers: [{
 *         content: "\"example\"",
 *         matcher: "MATCHES_JSON_PATH",
 *         jsonPathMatcher: {
 *             jsonPath: "$.path",
 *             jsonMatcher: "EXACT_MATCH",
 *         },
 *     }],
 *     checkerType: "STATIC_IP_CHECKERS",
 * });
 * ```
 * ### Uptime Check Config Status Code
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const statusCode = new gcp.monitoring.UptimeCheckConfig("status_code", {
 *     displayName: "http-uptime-check",
 *     timeout: "60s",
 *     httpCheck: {
 *         path: "some-path",
 *         port: 8010,
 *         requestMethod: "POST",
 *         contentType: "URL_ENCODED",
 *         body: "Zm9vJTI1M0RiYXI=",
 *         acceptedResponseStatusCodes: [
 *             {
 *                 statusClass: "STATUS_CLASS_2XX",
 *             },
 *             {
 *                 statusValue: 301,
 *             },
 *             {
 *                 statusValue: 302,
 *             },
 *         ],
 *     },
 *     monitoredResource: {
 *         type: "uptime_url",
 *         labels: {
 *             project_id: "my-project-name",
 *             host: "192.168.1.1",
 *         },
 *     },
 *     contentMatchers: [{
 *         content: "\"example\"",
 *         matcher: "MATCHES_JSON_PATH",
 *         jsonPathMatcher: {
 *             jsonPath: "$.path",
 *             jsonMatcher: "EXACT_MATCH",
 *         },
 *     }],
 *     checkerType: "STATIC_IP_CHECKERS",
 * });
 * ```
 * ### Uptime Check Config Https
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const https = new gcp.monitoring.UptimeCheckConfig("https", {
 *     displayName: "https-uptime-check",
 *     timeout: "60s",
 *     httpCheck: {
 *         path: "/some-path",
 *         port: 443,
 *         useSsl: true,
 *         validateSsl: true,
 *     },
 *     monitoredResource: {
 *         type: "uptime_url",
 *         labels: {
 *             project_id: "my-project-name",
 *             host: "192.168.1.1",
 *         },
 *     },
 *     contentMatchers: [{
 *         content: "example",
 *         matcher: "MATCHES_JSON_PATH",
 *         jsonPathMatcher: {
 *             jsonPath: "$.path",
 *             jsonMatcher: "REGEX_MATCH",
 *         },
 *     }],
 * });
 * ```
 * ### Uptime Check Tcp
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const check = new gcp.monitoring.Group("check", {
 *     displayName: "uptime-check-group",
 *     filter: "resource.metadata.name=has_substring(\"foo\")",
 * });
 * const tcpGroup = new gcp.monitoring.UptimeCheckConfig("tcp_group", {
 *     displayName: "tcp-uptime-check",
 *     timeout: "60s",
 *     tcpCheck: {
 *         port: 888,
 *         pingConfig: {
 *             pingsCount: 2,
 *         },
 *     },
 *     resourceGroup: {
 *         resourceType: "INSTANCE",
 *         groupId: check.name,
 *     },
 * });
 * ```
 * ### Uptime Check Config Synthetic Monitor
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 *
 * const bucket = new gcp.storage.Bucket("bucket", {
 *     name: "my-project-name-gcf-source",
 *     location: "US",
 *     uniformBucketLevelAccess: true,
 * });
 * const object = new gcp.storage.BucketObject("object", {
 *     name: "function-source.zip",
 *     bucket: bucket.name,
 *     source: new pulumi.asset.FileAsset("synthetic-fn-source.zip"),
 * });
 * const _function = new gcp.cloudfunctionsv2.Function("function", {
 *     name: "synthetic_function",
 *     location: "us-central1",
 *     buildConfig: {
 *         runtime: "nodejs20",
 *         entryPoint: "SyntheticFunction",
 *         source: {
 *             storageSource: {
 *                 bucket: bucket.name,
 *                 object: object.name,
 *             },
 *         },
 *     },
 *     serviceConfig: {
 *         maxInstanceCount: 1,
 *         availableMemory: "256M",
 *         timeoutSeconds: 60,
 *     },
 * });
 * const syntheticMonitor = new gcp.monitoring.UptimeCheckConfig("synthetic_monitor", {
 *     displayName: "synthetic_monitor",
 *     timeout: "60s",
 *     syntheticMonitor: {
 *         cloudFunctionV2: {
 *             name: _function.id,
 *         },
 *     },
 * });
 * ```
 *
 * ## Import
 *
 * UptimeCheckConfig can be imported using any of these accepted formats:
 *
 * * `{{project}}/{{name}}`
 *
 * * `{{project}} {{name}}`
 *
 * * `{{name}}`
 *
 * When using the `pulumi import` command, UptimeCheckConfig can be imported using one of the formats above. For example:
 *
 * ```sh
 * $ pulumi import gcp:monitoring/uptimeCheckConfig:UptimeCheckConfig default {{project}}/{{name}}
 * ```
 *
 * ```sh
 * $ pulumi import gcp:monitoring/uptimeCheckConfig:UptimeCheckConfig default "{{project}} {{name}}"
 * ```
 *
 * ```sh
 * $ pulumi import gcp:monitoring/uptimeCheckConfig:UptimeCheckConfig default {{name}}
 * ```
 */
export declare class UptimeCheckConfig extends pulumi.CustomResource {
    /**
     * Get an existing UptimeCheckConfig 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?: UptimeCheckConfigState, opts?: pulumi.CustomResourceOptions): UptimeCheckConfig;
    /**
     * Returns true if the given object is an instance of UptimeCheckConfig.  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 UptimeCheckConfig;
    /**
     * The checker type to use for the check. If the monitored resource type is `servicedirectoryService`, `checkerType` must be set to `VPC_CHECKERS`.
     * Possible values are: `STATIC_IP_CHECKERS`, `VPC_CHECKERS`.
     */
    readonly checkerType: pulumi.Output<string>;
    /**
     * The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response's content. This field is optional and should only be specified if a content match is required.
     * Structure is documented below.
     */
    readonly contentMatchers: pulumi.Output<outputs.monitoring.UptimeCheckConfigContentMatcher[] | undefined>;
    /**
     * A human-friendly name for the uptime check configuration. The display name should be unique within a Stackdriver Workspace in order to make it easier to identify; however, uniqueness is not enforced.
     */
    readonly displayName: pulumi.Output<string>;
    /**
     * Contains information needed to make an HTTP or HTTPS check.
     * Structure is documented below.
     */
    readonly httpCheck: pulumi.Output<outputs.monitoring.UptimeCheckConfigHttpCheck | undefined>;
    /**
     * Specifies whether to log the results of failed probes to Cloud Logging.
     */
    readonly logCheckFailures: pulumi.Output<boolean | undefined>;
    /**
     * The [monitored resource]
     * (https://cloud.google.com/monitoring/api/resources) associated with the
     * configuration. The following monitored resource types are supported for
     * uptime checks:
     */
    readonly monitoredResource: pulumi.Output<outputs.monitoring.UptimeCheckConfigMonitoredResource | undefined>;
    /**
     * A unique resource name for this UptimeCheckConfig. The format is `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
     */
    readonly name: pulumi.Output<string>;
    /**
     * How often, in seconds, the uptime check is performed. Currently, the only supported values are 60s (1 minute), 300s (5 minutes), 600s (10 minutes), and 900s (15 minutes). Optional, defaults to 300s.
     */
    readonly period: pulumi.Output<string | undefined>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    readonly project: pulumi.Output<string>;
    /**
     * The group resource associated with the configuration.
     * Structure is documented below.
     */
    readonly resourceGroup: pulumi.Output<outputs.monitoring.UptimeCheckConfigResourceGroup | undefined>;
    /**
     * The list of regions from which the check will be run. Some regions contain one location, and others contain more than one. If this field is specified, enough regions to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.
     */
    readonly selectedRegions: pulumi.Output<string[] | undefined>;
    /**
     * A Synthetic Monitor deployed to a Cloud Functions V2 instance.
     * Structure is documented below.
     */
    readonly syntheticMonitor: pulumi.Output<outputs.monitoring.UptimeCheckConfigSyntheticMonitor | undefined>;
    /**
     * Contains information needed to make a TCP check.
     * Structure is documented below.
     */
    readonly tcpCheck: pulumi.Output<outputs.monitoring.UptimeCheckConfigTcpCheck | undefined>;
    /**
     * The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). See the accepted formats
     */
    readonly timeout: pulumi.Output<string>;
    /**
     * The id of the uptime check
     */
    readonly uptimeCheckId: pulumi.Output<string>;
    /**
     * User-supplied key/value data to be used for organizing and identifying the `UptimeCheckConfig` objects. The field can contain up to 64 entries. Each key and value is limited to 63 Unicode characters or 128 bytes, whichever is smaller. Labels and values can contain only lowercase letters, numerals, underscores, and dashes. Keys must begin with a letter.
     */
    readonly userLabels: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * Create a UptimeCheckConfig 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: UptimeCheckConfigArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering UptimeCheckConfig resources.
 */
export interface UptimeCheckConfigState {
    /**
     * The checker type to use for the check. If the monitored resource type is `servicedirectoryService`, `checkerType` must be set to `VPC_CHECKERS`.
     * Possible values are: `STATIC_IP_CHECKERS`, `VPC_CHECKERS`.
     */
    checkerType?: pulumi.Input<string>;
    /**
     * The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response's content. This field is optional and should only be specified if a content match is required.
     * Structure is documented below.
     */
    contentMatchers?: pulumi.Input<pulumi.Input<inputs.monitoring.UptimeCheckConfigContentMatcher>[]>;
    /**
     * A human-friendly name for the uptime check configuration. The display name should be unique within a Stackdriver Workspace in order to make it easier to identify; however, uniqueness is not enforced.
     */
    displayName?: pulumi.Input<string>;
    /**
     * Contains information needed to make an HTTP or HTTPS check.
     * Structure is documented below.
     */
    httpCheck?: pulumi.Input<inputs.monitoring.UptimeCheckConfigHttpCheck>;
    /**
     * Specifies whether to log the results of failed probes to Cloud Logging.
     */
    logCheckFailures?: pulumi.Input<boolean>;
    /**
     * The [monitored resource]
     * (https://cloud.google.com/monitoring/api/resources) associated with the
     * configuration. The following monitored resource types are supported for
     * uptime checks:
     */
    monitoredResource?: pulumi.Input<inputs.monitoring.UptimeCheckConfigMonitoredResource>;
    /**
     * A unique resource name for this UptimeCheckConfig. The format is `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
     */
    name?: pulumi.Input<string>;
    /**
     * How often, in seconds, the uptime check is performed. Currently, the only supported values are 60s (1 minute), 300s (5 minutes), 600s (10 minutes), and 900s (15 minutes). Optional, defaults to 300s.
     */
    period?: pulumi.Input<string>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    project?: pulumi.Input<string>;
    /**
     * The group resource associated with the configuration.
     * Structure is documented below.
     */
    resourceGroup?: pulumi.Input<inputs.monitoring.UptimeCheckConfigResourceGroup>;
    /**
     * The list of regions from which the check will be run. Some regions contain one location, and others contain more than one. If this field is specified, enough regions to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.
     */
    selectedRegions?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * A Synthetic Monitor deployed to a Cloud Functions V2 instance.
     * Structure is documented below.
     */
    syntheticMonitor?: pulumi.Input<inputs.monitoring.UptimeCheckConfigSyntheticMonitor>;
    /**
     * Contains information needed to make a TCP check.
     * Structure is documented below.
     */
    tcpCheck?: pulumi.Input<inputs.monitoring.UptimeCheckConfigTcpCheck>;
    /**
     * The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). See the accepted formats
     */
    timeout?: pulumi.Input<string>;
    /**
     * The id of the uptime check
     */
    uptimeCheckId?: pulumi.Input<string>;
    /**
     * User-supplied key/value data to be used for organizing and identifying the `UptimeCheckConfig` objects. The field can contain up to 64 entries. Each key and value is limited to 63 Unicode characters or 128 bytes, whichever is smaller. Labels and values can contain only lowercase letters, numerals, underscores, and dashes. Keys must begin with a letter.
     */
    userLabels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
/**
 * The set of arguments for constructing a UptimeCheckConfig resource.
 */
export interface UptimeCheckConfigArgs {
    /**
     * The checker type to use for the check. If the monitored resource type is `servicedirectoryService`, `checkerType` must be set to `VPC_CHECKERS`.
     * Possible values are: `STATIC_IP_CHECKERS`, `VPC_CHECKERS`.
     */
    checkerType?: pulumi.Input<string>;
    /**
     * The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response's content. This field is optional and should only be specified if a content match is required.
     * Structure is documented below.
     */
    contentMatchers?: pulumi.Input<pulumi.Input<inputs.monitoring.UptimeCheckConfigContentMatcher>[]>;
    /**
     * A human-friendly name for the uptime check configuration. The display name should be unique within a Stackdriver Workspace in order to make it easier to identify; however, uniqueness is not enforced.
     */
    displayName: pulumi.Input<string>;
    /**
     * Contains information needed to make an HTTP or HTTPS check.
     * Structure is documented below.
     */
    httpCheck?: pulumi.Input<inputs.monitoring.UptimeCheckConfigHttpCheck>;
    /**
     * Specifies whether to log the results of failed probes to Cloud Logging.
     */
    logCheckFailures?: pulumi.Input<boolean>;
    /**
     * The [monitored resource]
     * (https://cloud.google.com/monitoring/api/resources) associated with the
     * configuration. The following monitored resource types are supported for
     * uptime checks:
     */
    monitoredResource?: pulumi.Input<inputs.monitoring.UptimeCheckConfigMonitoredResource>;
    /**
     * How often, in seconds, the uptime check is performed. Currently, the only supported values are 60s (1 minute), 300s (5 minutes), 600s (10 minutes), and 900s (15 minutes). Optional, defaults to 300s.
     */
    period?: pulumi.Input<string>;
    /**
     * The ID of the project in which the resource belongs.
     * If it is not provided, the provider project is used.
     */
    project?: pulumi.Input<string>;
    /**
     * The group resource associated with the configuration.
     * Structure is documented below.
     */
    resourceGroup?: pulumi.Input<inputs.monitoring.UptimeCheckConfigResourceGroup>;
    /**
     * The list of regions from which the check will be run. Some regions contain one location, and others contain more than one. If this field is specified, enough regions to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.
     */
    selectedRegions?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * A Synthetic Monitor deployed to a Cloud Functions V2 instance.
     * Structure is documented below.
     */
    syntheticMonitor?: pulumi.Input<inputs.monitoring.UptimeCheckConfigSyntheticMonitor>;
    /**
     * Contains information needed to make a TCP check.
     * Structure is documented below.
     */
    tcpCheck?: pulumi.Input<inputs.monitoring.UptimeCheckConfigTcpCheck>;
    /**
     * The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). See the accepted formats
     */
    timeout: pulumi.Input<string>;
    /**
     * User-supplied key/value data to be used for organizing and identifying the `UptimeCheckConfig` objects. The field can contain up to 64 entries. Each key and value is limited to 63 Unicode characters or 128 bytes, whichever is smaller. Labels and values can contain only lowercase letters, numerals, underscores, and dashes. Keys must begin with a letter.
     */
    userLabels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
}
