import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * This resource allows you to create and manage GitHub-hosted runners within your GitHub organization.
 * You must have admin access to an organization to use this resource.
 *
 * GitHub-hosted runners are fully managed virtual machines that run your GitHub Actions workflows. Unlike self-hosted runners, GitHub handles the infrastructure, maintenance, and scaling.
 *
 * ## Example Usage
 *
 * ### Basic Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as github from "@pulumi/github";
 *
 * const example = new github.ActionsRunnerGroup("example", {
 *     name: "example-runner-group",
 *     visibility: "all",
 * });
 * const exampleActionsHostedRunner = new github.ActionsHostedRunner("example", {
 *     name: "example-hosted-runner",
 *     image: {
 *         id: "2306",
 *         source: "github",
 *     },
 *     size: "4-core",
 *     runnerGroupId: example.id.apply(x =>Number(x)),
 * });
 * ```
 *
 * ### Advanced Usage with Optional Parameters
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as github from "@pulumi/github";
 *
 * const advanced = new github.ActionsRunnerGroup("advanced", {
 *     name: "advanced-runner-group",
 *     visibility: "selected",
 * });
 * const advancedActionsHostedRunner = new github.ActionsHostedRunner("advanced", {
 *     name: "advanced-hosted-runner",
 *     image: {
 *         id: "2306",
 *         source: "github",
 *     },
 *     size: "8-core",
 *     runnerGroupId: advanced.id.apply(x =>Number(x)),
 *     maximumRunners: 10,
 *     publicIpEnabled: true,
 * });
 * ```
 *
 * ## Notes
 *
 * * This resource is **organization-only** and cannot be used with individual accounts.
 * * The `image` field cannot be changed after the runner is created. Changing it will force recreation of the runner.
 * * The `size` field can be updated to scale the runner up or down as needed.
 * * Image IDs for GitHub-owned images are numeric strings (e.g., "2306" for Ubuntu Latest 24.04), not names like "ubuntu-latest".
 * * Deletion of hosted runners is asynchronous. The provider will poll for up to 10 minutes (configurable via timeouts) to confirm deletion.
 * * Runner creation and updates may take several minutes as GitHub provisions the infrastructure.
 * * Static public IPs are subject to account limits. Check your organization's limits before enabling.
 *
 * ## Getting Available Images and Sizes
 *
 * To get a list of available images:
 *
 * To get available machine sizes:
 *
 * ## Import
 *
 * Hosted runners can be imported using the runner ID:
 *
 * ```sh
 * $ pulumi import github:index/actionsHostedRunner:ActionsHostedRunner example 123456
 * ```
 */
export declare class ActionsHostedRunner extends pulumi.CustomResource {
    /**
     * Get an existing ActionsHostedRunner 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?: ActionsHostedRunnerState, opts?: pulumi.CustomResourceOptions): ActionsHostedRunner;
    /**
     * Returns true if the given object is an instance of ActionsHostedRunner.  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 ActionsHostedRunner;
    /**
     * Image configuration for the hosted runner. Cannot be changed after creation. Block supports:
     */
    readonly image: pulumi.Output<outputs.ActionsHostedRunnerImage>;
    /**
     * Whether this runner should be used to generate custom images. Cannot be changed after creation.
     */
    readonly imageGen: pulumi.Output<boolean | undefined>;
    /**
     * The version of the runner image to deploy. This is only relevant for runners using custom images.
     */
    readonly imageVersion: pulumi.Output<string | undefined>;
    /**
     * Timestamp (RFC3339) when the runner was last active.
     */
    readonly lastActiveOn: pulumi.Output<string>;
    /**
     * Detailed specifications of the machine size:
     */
    readonly machineSizeDetails: pulumi.Output<outputs.ActionsHostedRunnerMachineSizeDetail[]>;
    /**
     * Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs.
     */
    readonly maximumRunners: pulumi.Output<number>;
    /**
     * Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'.
     */
    readonly name: pulumi.Output<string>;
    /**
     * Platform of the runner (e.g., "linux-x64", "win-x64").
     */
    readonly platform: pulumi.Output<string>;
    /**
     * Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false.
     */
    readonly publicIpEnabled: pulumi.Output<boolean | undefined>;
    /**
     * List of public IP ranges assigned to this runner (only if `publicIpEnabled` is true):
     */
    readonly publicIps: pulumi.Output<outputs.ActionsHostedRunnerPublicIp[]>;
    /**
     * The ID of the runner group to assign this runner to.
     */
    readonly runnerGroupId: pulumi.Output<number>;
    /**
     * Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`.
     */
    readonly size: pulumi.Output<string>;
    /**
     * Current status of the runner (e.g., "Ready", "Provisioning").
     */
    readonly status: pulumi.Output<string>;
    /**
     * Create a ActionsHostedRunner 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: ActionsHostedRunnerArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering ActionsHostedRunner resources.
 */
export interface ActionsHostedRunnerState {
    /**
     * Image configuration for the hosted runner. Cannot be changed after creation. Block supports:
     */
    image?: pulumi.Input<inputs.ActionsHostedRunnerImage | undefined>;
    /**
     * Whether this runner should be used to generate custom images. Cannot be changed after creation.
     */
    imageGen?: pulumi.Input<boolean | undefined>;
    /**
     * The version of the runner image to deploy. This is only relevant for runners using custom images.
     */
    imageVersion?: pulumi.Input<string | undefined>;
    /**
     * Timestamp (RFC3339) when the runner was last active.
     */
    lastActiveOn?: pulumi.Input<string | undefined>;
    /**
     * Detailed specifications of the machine size:
     */
    machineSizeDetails?: pulumi.Input<pulumi.Input<inputs.ActionsHostedRunnerMachineSizeDetail>[] | undefined>;
    /**
     * Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs.
     */
    maximumRunners?: pulumi.Input<number | undefined>;
    /**
     * Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Platform of the runner (e.g., "linux-x64", "win-x64").
     */
    platform?: pulumi.Input<string | undefined>;
    /**
     * Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false.
     */
    publicIpEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * List of public IP ranges assigned to this runner (only if `publicIpEnabled` is true):
     */
    publicIps?: pulumi.Input<pulumi.Input<inputs.ActionsHostedRunnerPublicIp>[] | undefined>;
    /**
     * The ID of the runner group to assign this runner to.
     */
    runnerGroupId?: pulumi.Input<number | undefined>;
    /**
     * Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`.
     */
    size?: pulumi.Input<string | undefined>;
    /**
     * Current status of the runner (e.g., "Ready", "Provisioning").
     */
    status?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a ActionsHostedRunner resource.
 */
export interface ActionsHostedRunnerArgs {
    /**
     * Image configuration for the hosted runner. Cannot be changed after creation. Block supports:
     */
    image: pulumi.Input<inputs.ActionsHostedRunnerImage>;
    /**
     * Whether this runner should be used to generate custom images. Cannot be changed after creation.
     */
    imageGen?: pulumi.Input<boolean | undefined>;
    /**
     * The version of the runner image to deploy. This is only relevant for runners using custom images.
     */
    imageVersion?: pulumi.Input<string | undefined>;
    /**
     * Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs.
     */
    maximumRunners?: pulumi.Input<number | undefined>;
    /**
     * Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false.
     */
    publicIpEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * The ID of the runner group to assign this runner to.
     */
    runnerGroupId: pulumi.Input<number>;
    /**
     * Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`.
     */
    size: pulumi.Input<string>;
}
//# sourceMappingURL=actionsHostedRunner.d.ts.map