import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * Retrohunt is an execution of a Rule over a time range in the past.
 *
 * To get more information about Retrohunt, see:
 *
 * * [API documentation](https://cloud.google.com/chronicle/docs/reference/rest/v1/projects.locations.instances.rules.retrohunts)
 * * How-to Guides
 *     * [Google SecOps Guides](https://cloud.google.com/chronicle/docs/secops/secops-overview)
 *
 * ## Example Usage
 *
 * ### Chronicle Retrohunt Basic
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * import * as std from "@pulumi/std";
 *
 * const my_rule = new gcp.chronicle.Rule("my-rule", {
 *     location: "us",
 *     instance: "00000000-0000-0000-0000-000000000000",
 *     deletionPolicy: "FORCE",
 *     text: "rule test_rule { meta: events:  $userid = $e.principal.user.userid  match: $userid over 10m condition: $e }\n",
 * });
 * const example = new gcp.chronicle.Retrohunt("example", {
 *     location: "us",
 *     instance: "00000000-0000-0000-0000-000000000000",
 *     rule: pulumi.all([std.split({
 *         separator: "/",
 *         text: googleChronicleRule["my-rule"].name,
 *     }), std.split({
 *         separator: "/",
 *         text: googleChronicleRule["my-rule"].name,
 *     }).then(invoke => invoke.result).length]).apply(([invoke, length]) => invoke.result[length - 1]),
 *     processInterval: {
 *         startTime: "2025-01-01T00:00:00Z",
 *         endTime: "2025-01-01T12:00:00Z",
 *     },
 * });
 * ```
 *
 * ## Import
 *
 * Retrohunt can be imported using any of these accepted formats:
 *
 * * `projects/{{project}}/locations/{{location}}/instances/{{instance}}/rules/{{rule}}/retrohunts/{{retrohunt}}`
 * * `{{project}}/{{location}}/{{instance}}/{{rule}}/{{retrohunt}}`
 * * `{{location}}/{{instance}}/{{rule}}/{{retrohunt}}`
 *
 * When using the `pulumi import` command, Retrohunt can be imported using one of the formats above. For example:
 *
 * ```sh
 * $ pulumi import gcp:chronicle/retrohunt:Retrohunt default projects/{{project}}/locations/{{location}}/instances/{{instance}}/rules/{{rule}}/retrohunts/{{retrohunt}}
 * $ pulumi import gcp:chronicle/retrohunt:Retrohunt default {{project}}/{{location}}/{{instance}}/{{rule}}/{{retrohunt}}
 * $ pulumi import gcp:chronicle/retrohunt:Retrohunt default {{location}}/{{instance}}/{{rule}}/{{retrohunt}}
 * ```
 */
export declare class Retrohunt extends pulumi.CustomResource {
    /**
     * Get an existing Retrohunt 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?: RetrohuntState, opts?: pulumi.CustomResourceOptions): Retrohunt;
    /**
     * Returns true if the given object is an instance of Retrohunt.  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 Retrohunt;
    /**
     * The retrohunt ID of the Retrohunt. A retrohunt is an execution of a Rule over a time range in the past.
     */
    readonly RetrohuntId: pulumi.Output<string>;
    /**
     * Represents a time interval, encoded as a Timestamp start (inclusive) and a
     * Timestamp end (exclusive).
     * The start must be less than or equal to the end.
     * When the start equals the end, the interval is empty (matches no time).
     * When both start and end are unspecified, the interval matches any time.
     * Structure is documented below.
     */
    readonly executionIntervals: pulumi.Output<outputs.chronicle.RetrohuntExecutionInterval[]>;
    /**
     * The unique identifier for the Chronicle instance, which is the same as the customer ID.
     */
    readonly instance: pulumi.Output<string>;
    /**
     * The location of the resource. This is the geographical region where the Chronicle instance resides, such as "us" or "europe-west2".
     */
    readonly location: pulumi.Output<string>;
    /**
     * The resource name of the retrohunt.
     * Retrohunt is the child of a rule revision. {rule} in the format below is
     * structured as {rule_id@revision_id}.
     * Format:
     * projects/{project}/locations/{location}/instances/{instance}/rules/{rule}/retrohunts/{retrohunt}
     */
    readonly name: pulumi.Output<string>;
    /**
     * Represents a time interval, encoded as a Timestamp start (inclusive) and a
     * Timestamp end (exclusive).
     * The start must be less than or equal to the end.
     * When the start equals the end, the interval is empty (matches no time).
     * When both start and end are unspecified, the interval matches any time.
     * Structure is documented below.
     */
    readonly processInterval: pulumi.Output<outputs.chronicle.RetrohuntProcessInterval>;
    /**
     * Output only. Percent progress of the retrohunt towards completion, from 0.00 to 100.00.
     */
    readonly progressPercentage: pulumi.Output<number>;
    /**
     * 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 Rule ID of the rule.
     */
    readonly rule: pulumi.Output<string>;
    /**
     * Output only. The state of the retrohunt.
     * Possible values:
     * RUNNING
     * DONE
     * CANCELLED
     * FAILED
     */
    readonly state: pulumi.Output<string>;
    /**
     * Create a Retrohunt 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: RetrohuntArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering Retrohunt resources.
 */
export interface RetrohuntState {
    /**
     * The retrohunt ID of the Retrohunt. A retrohunt is an execution of a Rule over a time range in the past.
     */
    RetrohuntId?: pulumi.Input<string>;
    /**
     * Represents a time interval, encoded as a Timestamp start (inclusive) and a
     * Timestamp end (exclusive).
     * The start must be less than or equal to the end.
     * When the start equals the end, the interval is empty (matches no time).
     * When both start and end are unspecified, the interval matches any time.
     * Structure is documented below.
     */
    executionIntervals?: pulumi.Input<pulumi.Input<inputs.chronicle.RetrohuntExecutionInterval>[]>;
    /**
     * The unique identifier for the Chronicle instance, which is the same as the customer ID.
     */
    instance?: pulumi.Input<string>;
    /**
     * The location of the resource. This is the geographical region where the Chronicle instance resides, such as "us" or "europe-west2".
     */
    location?: pulumi.Input<string>;
    /**
     * The resource name of the retrohunt.
     * Retrohunt is the child of a rule revision. {rule} in the format below is
     * structured as {rule_id@revision_id}.
     * Format:
     * projects/{project}/locations/{location}/instances/{instance}/rules/{rule}/retrohunts/{retrohunt}
     */
    name?: pulumi.Input<string>;
    /**
     * Represents a time interval, encoded as a Timestamp start (inclusive) and a
     * Timestamp end (exclusive).
     * The start must be less than or equal to the end.
     * When the start equals the end, the interval is empty (matches no time).
     * When both start and end are unspecified, the interval matches any time.
     * Structure is documented below.
     */
    processInterval?: pulumi.Input<inputs.chronicle.RetrohuntProcessInterval>;
    /**
     * Output only. Percent progress of the retrohunt towards completion, from 0.00 to 100.00.
     */
    progressPercentage?: pulumi.Input<number>;
    /**
     * 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 Rule ID of the rule.
     */
    rule?: pulumi.Input<string>;
    /**
     * Output only. The state of the retrohunt.
     * Possible values:
     * RUNNING
     * DONE
     * CANCELLED
     * FAILED
     */
    state?: pulumi.Input<string>;
}
/**
 * The set of arguments for constructing a Retrohunt resource.
 */
export interface RetrohuntArgs {
    /**
     * The retrohunt ID of the Retrohunt. A retrohunt is an execution of a Rule over a time range in the past.
     */
    RetrohuntId?: pulumi.Input<string>;
    /**
     * The unique identifier for the Chronicle instance, which is the same as the customer ID.
     */
    instance: pulumi.Input<string>;
    /**
     * The location of the resource. This is the geographical region where the Chronicle instance resides, such as "us" or "europe-west2".
     */
    location: pulumi.Input<string>;
    /**
     * Represents a time interval, encoded as a Timestamp start (inclusive) and a
     * Timestamp end (exclusive).
     * The start must be less than or equal to the end.
     * When the start equals the end, the interval is empty (matches no time).
     * When both start and end are unspecified, the interval matches any time.
     * Structure is documented below.
     */
    processInterval: pulumi.Input<inputs.chronicle.RetrohuntProcessInterval>;
    /**
     * 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 Rule ID of the rule.
     */
    rule: pulumi.Input<string>;
}