@pulumi/hcloud/types/input.d.ts

A Pulumi package for creating and managing hcloud cloud resources.

import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
export interface FirewallApplyTo {
    /**
     * Label Selector to select servers the firewall should be applied to (only one
     * of `server` and `labelSelector`can be applied in one block)
     */
    labelSelector?: pulumi.Input<string | undefined>;
    /**
     * ID of the server you want to apply the firewall to (only one of `server`
     * and `labelSelector`can be applied in one block)
     */
    server?: pulumi.Input<number | undefined>;
}
export interface FirewallRule {
    /**
     * Description of the firewall rule
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
     * is `out`)
     */
    destinationIps?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * Direction of the Firewall Rule. `in`
     */
    direction: pulumi.Input<string>;
    /**
     * Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
     * to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
     */
    port?: pulumi.Input<string | undefined>;
    /**
     * Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
     */
    protocol: pulumi.Input<string>;
    /**
     * List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
     * is `in`)
     */
    sourceIps?: pulumi.Input<pulumi.Input<string>[] | undefined>;
}
export interface GetFirewallApplyTo {
    /**
     * (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
     * referenced
     */
    labelSelector?: string;
    /**
     * (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
     */
    server?: number;
}
export interface GetFirewallApplyToArgs {
    /**
     * (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
     * referenced
     */
    labelSelector?: pulumi.Input<string | undefined>;
    /**
     * (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
     */
    server?: pulumi.Input<number | undefined>;
}
export interface GetFirewallRule {
    /**
     * (Optional, string) Description of the firewall rule
     */
    description?: string;
    /**
     * (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
     */
    destinationIps?: string[];
    /**
     * (Required, string) Direction of the Firewall Rule. `in`, `out`
     */
    direction: string;
    /**
     * (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
     */
    port?: string;
    /**
     * (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
     */
    protocol?: string;
    /**
     * (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
     */
    sourceIps?: string[];
}
export interface GetFirewallRuleArgs {
    /**
     * (Optional, string) Description of the firewall rule
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
     */
    destinationIps?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * (Required, string) Direction of the Firewall Rule. `in`, `out`
     */
    direction: pulumi.Input<string>;
    /**
     * (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
     */
    port?: pulumi.Input<string | undefined>;
    /**
     * (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
     */
    protocol?: pulumi.Input<string | undefined>;
    /**
     * (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
     */
    sourceIps?: pulumi.Input<pulumi.Input<string>[] | undefined>;
}
export interface GetServerNetwork {
    /**
     * (list) A list of alias IP addresses assigned to the server in the network.
     */
    aliasIps?: string[];
    /**
     * (string) The server's IP address within the network.
     */
    ip?: string;
    /**
     * (string) The MAC address associated with the server's private network interface.
     */
    macAddress?: string;
    /**
     * (int) The unique identifier for the network.
     */
    networkId?: number;
}
export interface GetServerNetworkArgs {
    /**
     * (list) A list of alias IP addresses assigned to the server in the network.
     */
    aliasIps?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * (string) The server's IP address within the network.
     */
    ip?: pulumi.Input<string | undefined>;
    /**
     * (string) The MAC address associated with the server's private network interface.
     */
    macAddress?: pulumi.Input<string | undefined>;
    /**
     * (int) The unique identifier for the network.
     */
    networkId?: pulumi.Input<number | undefined>;
}
export interface LoadBalancerAlgorithm {
    /**
     * Type of the Load Balancer Algorithm. `roundRobin` or `leastConnections`
     */
    type?: pulumi.Input<string | undefined>;
}
export interface LoadBalancerServiceHealthCheck {
    /**
     * HTTP configuration. Required if `protocol` is `http`.
     */
    http?: pulumi.Input<inputs.LoadBalancerServiceHealthCheckHttp | undefined>;
    /**
     * Interval how often the health check will be performed, in seconds.
     */
    interval: pulumi.Input<number>;
    /**
     * Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
     */
    port: pulumi.Input<number>;
    /**
     * Protocol the health check uses. `http` or `tcp`
     */
    protocol: pulumi.Input<string>;
    /**
     * Number of tries a health check will be performed until a target will be listed as `unhealthy`.
     */
    retries: pulumi.Input<number>;
    /**
     * Timeout when a health check try will be canceled if there is no response, in seconds.
     */
    timeout: pulumi.Input<number>;
}
export interface LoadBalancerServiceHealthCheckHttp {
    /**
     * Domain we try to access when performing the Health Check.
     */
    domain?: pulumi.Input<string | undefined>;
    /**
     * Path we try to access when performing the Health Check.
     */
    path?: pulumi.Input<string | undefined>;
    /**
     * Response we expect to be included in the Target response when a Health Check was performed.
     */
    response?: pulumi.Input<string | undefined>;
    /**
     * We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
     */
    statusCodes?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * Enable TLS certificate checking.
     */
    tls?: pulumi.Input<boolean | undefined>;
}
export interface LoadBalancerServiceHttp {
    /**
     * List of IDs from certificates which the Load Balancer has.
     */
    certificates?: pulumi.Input<pulumi.Input<number>[] | undefined>;
    /**
     * Lifetime of the cookie for sticky session (in seconds). Default: `300`
     */
    cookieLifetime?: pulumi.Input<number | undefined>;
    /**
     * Name of the cookie for sticky session. Default: `HCLBSTICKY`
     */
    cookieName?: pulumi.Input<string | undefined>;
    /**
     * Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
     */
    redirectHttp?: pulumi.Input<boolean | undefined>;
    /**
     * Enable sticky sessions
     */
    stickySessions?: pulumi.Input<boolean | undefined>;
    /**
     * Idle timeout for HTTP connections in seconds. Must be between `30` and `300`.
     */
    timeoutIdle?: pulumi.Input<number | undefined>;
}
export interface LoadBalancerTarget {
    serverId?: pulumi.Input<number | undefined>;
    /**
     * (string) Type of the Load Balancer Algorithm. `roundRobin` or `leastConnections`
     */
    type: pulumi.Input<string>;
    /**
     * @deprecated Does not work. Use the hcloud.LoadBalancerTarget resource instead.
     */
    usePrivateIp?: pulumi.Input<boolean | undefined>;
}
export interface ServerNetwork {
    /**
     * Alias IPs the server should have in the Network.
     *
     * There is a bug with Terraform `1.4+` which causes the network to be detached & attached on every apply. Set `aliasIps = []` to avoid this. See #650 for details.
     */
    aliasIps?: pulumi.Input<pulumi.Input<string>[] | undefined>;
    /**
     * Specify the IP the server should get in the network
     */
    ip?: pulumi.Input<string | undefined>;
    /**
     * (Optional, string) The MAC address the private interface of the server has
     */
    macAddress?: pulumi.Input<string | undefined>;
    /**
     * ID of the network to attach the server to. Using `subnetId` is preferred. When used alone without `subnetId`, the server will be attached to the last subnet (ordered by `ipRange`), which may be unpredictable.
     */
    networkId?: pulumi.Input<number | undefined>;
    /**
     * ID of the network subnet to attach the server to.
     */
    subnetId?: pulumi.Input<string | undefined>;
}
export interface ServerPublicNet {
    ipv4?: pulumi.Input<number | undefined>;
    ipv4Enabled?: pulumi.Input<boolean | undefined>;
    ipv6?: pulumi.Input<number | undefined>;
    ipv6Enabled?: pulumi.Input<boolean | undefined>;
}
export interface StorageBoxAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the ZFS snapshot folder is visible.
     */
    zfsEnabled?: pulumi.Input<boolean | undefined>;
}
export interface StorageBoxSnapshotPlan {
    /**
     * Day of the month when the Snapshot Plan is executed. Null means every day.
     */
    dayOfMonth?: pulumi.Input<number | undefined>;
    /**
     * Day of the week when the Snapshot Plan is executed. Starts at 0 for Sunday til 6 for Saturday. Note that this differs from the API, which uses 1 (Monday) through 7 (Sunday). Null means every day.
     */
    dayOfWeek?: pulumi.Input<number | undefined>;
    /**
     * Hour when the Snapshot Plan is executed (UTC).
     */
    hour: pulumi.Input<number>;
    /**
     * Maximum amount of Snapshots that will be created by this Snapshot Plan. Older Snapshots will be deleted.
     */
    maxSnapshots: pulumi.Input<number>;
    /**
     * Minute when the Snapshot Plan is executed (UTC).
     */
    minute: pulumi.Input<number>;
}
export interface StorageBoxSubaccountAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the Subaccount is read-only.
     */
    readonly?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled?: pulumi.Input<boolean | undefined>;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled?: pulumi.Input<boolean | undefined>;
}
export interface ZoneAuthoritativeNameservers {
    /**
     * Authoritative Hetzner nameservers assigned to the Zone.
     */
    assigneds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
}
export interface ZonePrimaryNameserver {
    /**
     * Public IPv4 or IPv6 address of the primary nameserver.
     */
    address: pulumi.Input<string>;
    /**
     * Port of the primary nameserver.
     */
    port?: pulumi.Input<number | undefined>;
    /**
     * Transaction signature (TSIG) algorithm used to generate the TSIG key.
     */
    tsigAlgorithm?: pulumi.Input<string | undefined>;
    /**
     * Transaction signature (TSIG) key
     */
    tsigKey?: pulumi.Input<string | undefined>;
}
export interface ZoneRrsetRecord {
    /**
     * Comment of the record.
     */
    comment?: pulumi.Input<string | undefined>;
    /**
     * Value of the record.
     */
    value: pulumi.Input<string>;
}
//# sourceMappingURL=input.d.ts.map