import * as outputs from "../types/output";
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: string;
    /**
     * ID of the server you want to apply the firewall to (only one of `server`
     * and `labelSelector`can be applied in one block)
     */
    server: number;
}
export interface FirewallRule {
    /**
     * Description of the firewall rule
     */
    description?: string;
    /**
     * List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
     * is `out`)
     */
    destinationIps?: string[];
    /**
     * Direction of the Firewall Rule. `in`
     */
    direction: 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?: string;
    /**
     * Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
     */
    protocol: string;
    /**
     * List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
     * is `in`)
     */
    sourceIps?: string[];
}
export interface GetCertificatesCertificate {
    certificate: string;
    created: string;
    domainNames: string[];
    fingerprint: string;
    id: number;
    labels: {
        [key: string]: string;
    };
    name?: string;
    notValidAfter: string;
    notValidBefore: string;
    type: string;
}
export interface GetDatacentersDatacenter {
    /**
     * List of currently available Server Types in the Datacenter.
     *
     * @deprecated This attribute is deprecated and will be dropped after 2026-10-01. Use hcloud_server_types[].locations[].available instead.
     */
    availableServerTypeIds: number[];
    /**
     * Description of the Datacenter.
     */
    description: string;
    /**
     * ID of the Datacenter.
     */
    id: number;
    /**
     * Location of the Datacenter. See the [Hetzner Docs](https://docs.hetzner.com/cloud/general/locations/#what-locations-are-there) for more details about locations.
     */
    location: {
        [key: string]: string;
    };
    /**
     * Name of the Datacenter.
     */
    name: string;
    /**
     * List of supported Server Types in the Datacenter.
     *
     * @deprecated This attribute is deprecated and will be dropped after 2026-10-01. Use hcloud_server_types[].locations[] instead.
     */
    supportedServerTypeIds: number[];
}
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 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 GetFirewallsFirewall {
    applyTos?: outputs.GetFirewallsFirewallApplyTo[];
    id?: number;
    labels?: {
        [key: string]: string;
    };
    name: string;
    rules?: outputs.GetFirewallsFirewallRule[];
}
export interface GetFirewallsFirewallApplyTo {
    labelSelector: string;
    server: number;
}
export interface GetFirewallsFirewallRule {
    description?: string;
    destinationIps?: string[];
    direction: string;
    port?: string;
    protocol?: string;
    sourceIps?: string[];
}
export interface GetFloatingIpsFloatingIp {
    deleteProtection: boolean;
    description: string;
    homeLocation: string;
    id: number;
    ipAddress: string;
    ipNetwork: string;
    labels: {
        [key: string]: string;
    };
    name?: string;
    serverId: number;
    type: string;
}
export interface GetImagesImage {
    architecture: string;
    created: string;
    deprecated: string;
    description: string;
    id: number;
    labels: {
        [key: string]: string;
    };
    name: string;
    osFlavor: string;
    osVersion: string;
    rapidDeploy: boolean;
    /**
     * @deprecated Please use the withSelector property instead.
     */
    selector?: string;
    type: string;
}
export interface GetLoadBalancerAlgorithm {
    /**
     * (string) Type of the target. `server` or `labelSelector`
     */
    type: string;
}
export interface GetLoadBalancerService {
    /**
     * (int) Port the service connects to the targets on. Can be everything between `1` and `65535`.
     */
    destinationPort: number;
    /**
     * (list) List of http configurations when `protocol` is `http` or `https`.
     */
    healthChecks: outputs.GetLoadBalancerServiceHealthCheck[];
    /**
     * (list) List of http configurations when `protocol` is `http` or `https`.
     */
    https: outputs.GetLoadBalancerServiceHttp[];
    /**
     * (int) Port the service listen on. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
     */
    listenPort: number;
    /**
     * (string) Protocol the health check uses. `http`, `https` or `tcp`
     */
    protocol: string;
    /**
     * (bool) Enable proxyprotocol.
     */
    proxyprotocol: boolean;
}
export interface GetLoadBalancerServiceHealthCheck {
    /**
     * (list) List of http configurations when `protocol` is `http` or `https`.
     */
    https: outputs.GetLoadBalancerServiceHealthCheckHttp[];
    /**
     * (int) Interval how often the health check will be performed, in seconds.
     */
    interval: number;
    /**
     * (int) Port the health check tries to connect to. Can be everything between `1` and `65535`.
     */
    port: number;
    /**
     * (string) Protocol the health check uses. `http`, `https` or `tcp`
     */
    protocol: string;
    /**
     * (int) Number of tries a health check will be performed until a target will be listed as `unhealthy`.
     */
    retries: number;
    /**
     * (int) Timeout when a health check try will be canceled if there is no response, in seconds.
     */
    timeout: number;
}
export interface GetLoadBalancerServiceHealthCheckHttp {
    /**
     * string) Domain we try to access when performing the Health Check.
     */
    domain: string;
    /**
     * (string) Path we try to access when performing the Health Check.
     */
    path: string;
    /**
     * (string) Response we expect to be included in the Target response when a Health Check was performed.
     */
    response: string;
    /**
     * (list[int]) We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
     */
    statusCodes: number[];
    /**
     * (bool) Enable TLS certificate checking.
     */
    tls: boolean;
}
export interface GetLoadBalancerServiceHttp {
    /**
     * (list[int]) List of IDs from certificates which the Load Balancer has.
     */
    certificates: string[];
    /**
     * (int) Lifetime of the cookie for sticky session (in seconds).
     */
    cookieLifetime: number;
    /**
     * (string) Name of the cookie for sticky session.
     */
    cookieName: string;
    /**
     * (string) Determine if all requests from port 80 should be redirected to port 443.
     */
    redirectHttp: boolean;
    /**
     * (string) Determine if sticky sessions are enabled or not.
     */
    stickySessions: boolean;
}
export interface GetLoadBalancerTarget {
    /**
     * (string) Label Selector to add a group of resources based on the label.
     */
    labelSelector: string;
    /**
     * (int) ID of the server which should be a target for this Load Balancer.
     */
    serverId: number;
    /**
     * (string) Type of the target. `server` or `labelSelector`
     */
    type: string;
}
export interface GetLoadBalancerTypesLoadBalancerType {
    /**
     * Description of the Load Balancer Type.
     */
    description: string;
    /**
     * ID of the Load Balancer Type.
     */
    id: number;
    /**
     * Maximum number of certificates that can be assigned for the Load Balancer of this type.
     */
    maxAssignedCertificates: number;
    /**
     * Maximum number of simultaneous open connections for the Load Balancer of this type.
     */
    maxConnections: number;
    /**
     * Maximum number of services for the Load Balancer of this type.
     */
    maxServices: number;
    /**
     * Maximum number of targets for the Load Balancer of this type.
     */
    maxTargets: number;
    /**
     * Name of the Load Balancer Type.
     */
    name: string;
}
export interface GetLoadBalancersLoadBalancer {
    algorithms: outputs.GetLoadBalancersLoadBalancerAlgorithm[];
    deleteProtection: boolean;
    id: number;
    ipv4: string;
    ipv6: string;
    labels: {
        [key: string]: string;
    };
    loadBalancerType: string;
    location: string;
    name?: string;
    networkId: number;
    networkIp: string;
    networkZone: string;
    services: outputs.GetLoadBalancersLoadBalancerService[];
    targets: outputs.GetLoadBalancersLoadBalancerTarget[];
}
export interface GetLoadBalancersLoadBalancerAlgorithm {
    type: string;
}
export interface GetLoadBalancersLoadBalancerService {
    destinationPort: number;
    healthChecks: outputs.GetLoadBalancersLoadBalancerServiceHealthCheck[];
    https: outputs.GetLoadBalancersLoadBalancerServiceHttp[];
    listenPort: number;
    protocol: string;
    proxyprotocol: boolean;
}
export interface GetLoadBalancersLoadBalancerServiceHealthCheck {
    https: outputs.GetLoadBalancersLoadBalancerServiceHealthCheckHttp[];
    interval: number;
    port: number;
    protocol: string;
    retries: number;
    timeout: number;
}
export interface GetLoadBalancersLoadBalancerServiceHealthCheckHttp {
    domain: string;
    path: string;
    response: string;
    statusCodes: number[];
    tls: boolean;
}
export interface GetLoadBalancersLoadBalancerServiceHttp {
    certificates: string[];
    cookieLifetime: number;
    cookieName: string;
    redirectHttp: boolean;
    stickySessions: boolean;
}
export interface GetLoadBalancersLoadBalancerTarget {
    labelSelector: string;
    serverId: number;
    type: string;
}
export interface GetLocationsLocation {
    /**
     * Name of the closest city to the Location. City name and optionally state in short form.
     */
    city: string;
    /**
     * Country the Location resides in. ISO 3166-1 alpha-2 code of the country.
     */
    country: string;
    /**
     * Description of the Location.
     */
    description: string;
    /**
     * ID of the Location.
     */
    id: number;
    /**
     * Latitude of the city closest to the Location.
     */
    latitude: number;
    /**
     * Longitude of the city closest to the Location.
     */
    longitude: number;
    /**
     * Name of the Location.
     */
    name: string;
    /**
     * Name of the Network Zone this Location resides in.
     */
    networkZone: string;
}
export interface GetNetworksNetwork {
    deleteProtection: boolean;
    /**
     * Indicates if the routes from this network should be exposed to the vSwitch connection. The exposing only takes effect if a vSwitch connection is active.
     */
    exposeRoutesToVswitch: boolean;
    id: number;
    ipRange: string;
    labels: {
        [key: string]: string;
    };
    name: string;
}
export interface GetPlacementGroupsPlacementGroup {
    id: number;
    labels: {
        [key: string]: string;
    };
    name: string;
    servers: number[];
    type: string;
}
export interface GetPrimaryIpsPrimaryIp {
    /**
     * ID of the resource the Primary IP is assigned to.
     */
    assigneeId: number;
    /**
     * Type of the resource the Primary IP is assigned to.
     */
    assigneeType: string;
    /**
     * Whether auto delete is enabled.
     */
    autoDelete: boolean;
    /**
     * Name of the Datacenter of the Primary IP.
     *
     * @deprecated The datacenter attribute is deprecated and will be removed after 1 July 2026. Please use the location attribute instead. See https://docs.hetzner.cloud/changelog#2025-12-16-phasing-out-datacenters.
     */
    datacenter: string;
    /**
     * Whether delete protection is enabled.
     */
    deleteProtection: boolean;
    /**
     * ID of the Primary IP.
     */
    id: number;
    /**
     * IP address of the Primary IP.
     */
    ipAddress: string;
    /**
     * IP network of the Primary IP for IPv6 addresses. Only set if `type` is `ipv6`.
     */
    ipNetwork: string;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Name of the Location of the Primary IP.
     */
    location: string;
    /**
     * Name of the Primary IP.
     */
    name: string;
    /**
     * Type of the Primary IP (`ipv4` or `ipv6`).
     */
    type: string;
}
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 GetServerTypeLocation {
    /**
     * Whether the Server Type is temporarily unavailable in this Location.
     */
    available: boolean;
    /**
     * Date of the Server Type deprecation announcement.
     */
    deprecationAnnounced: string;
    /**
     * ID of the Location.
     */
    id: number;
    /**
     * Whether the Server Type is deprecated.
     */
    isDeprecated: boolean;
    /**
     * Name of the Location.
     */
    name: string;
    /**
     * Whether the Server Type is recommended in this Location.
     */
    recommended: boolean;
    /**
     * Date of the Server Type removal. After this date, the Server Type cannot be used anymore.
     */
    unavailableAfter: string;
}
export interface GetServerTypesServerType {
    /**
     * Architecture of the cpu for a Server of this type.
     */
    architecture: string;
    /**
     * Category of the Server Type.
     */
    category: string;
    /**
     * Number of cpu cores for a Server of this type.
     */
    cores: number;
    /**
     * Type of cpu for a Server of this type.
     */
    cpuType: string;
    /**
     * Date of the Server Type deprecation announcement.
     *
     * @deprecated The field is deprecated and will gradually be phased out starting 2025-09-24. Use the deprecation in the locations list instead.
     */
    deprecationAnnounced: string;
    /**
     * Description of the Server Type.
     */
    description: string;
    /**
     * Disk size in GB for a Server of this type.
     */
    disk: number;
    /**
     * ID of the Server Type.
     */
    id: number;
    /**
     * @deprecated The field is deprecated and will always report 0 after 2024-08-05.
     */
    includedTraffic: number;
    /**
     * Whether the Server Type is deprecated.
     *
     * @deprecated The field is deprecated and will gradually be phased out starting 2025-09-24. Use the deprecation in the locations list instead.
     */
    isDeprecated: boolean;
    /**
     * List of supported Locations for this Server Type.
     */
    locations: outputs.GetServerTypesServerTypeLocation[];
    /**
     * Memory in GB for a Server of this type.
     */
    memory: number;
    /**
     * Name of the Server Type.
     */
    name: string;
    /**
     * Type of boot drive for a Server of this type.
     */
    storageType: string;
    /**
     * Date of the Server Type removal. After this date, the Server Type cannot be used anymore.
     *
     * @deprecated The field is deprecated and will gradually be phased out starting 2025-09-24. Use the deprecation in the locations list instead.
     */
    unavailableAfter: string;
}
export interface GetServerTypesServerTypeLocation {
    /**
     * Whether the Server Type is temporarily unavailable in this Location.
     */
    available: boolean;
    /**
     * Date of the Server Type deprecation announcement.
     */
    deprecationAnnounced: string;
    /**
     * ID of the Location.
     */
    id: number;
    /**
     * Whether the Server Type is deprecated.
     */
    isDeprecated: boolean;
    /**
     * Name of the Location.
     */
    name: string;
    /**
     * Whether the Server Type is recommended in this Location.
     */
    recommended: boolean;
    /**
     * Date of the Server Type removal. After this date, the Server Type cannot be used anymore.
     */
    unavailableAfter: string;
}
export interface GetServersServer {
    backupWindow: string;
    backups: boolean;
    /**
     * @deprecated The datacenter attribute is deprecated and will be removed after 1 July 2026. Please use the location attribute instead. See https://docs.hetzner.cloud/changelog#2025-12-16-phasing-out-datacenters.
     */
    datacenter: string;
    deleteProtection: boolean;
    firewallIds: number[];
    id: number;
    image: string;
    ipv4Address: string;
    ipv6Address: string;
    ipv6Network: string;
    iso: string;
    labels: {
        [key: string]: string;
    };
    location: string;
    name: string;
    networks?: outputs.GetServersServerNetwork[];
    placementGroupId?: number;
    primaryDiskSize: number;
    rebuildProtection: boolean;
    rescue: string;
    serverType: string;
    status: string;
}
export interface GetServersServerNetwork {
    aliasIps: string[];
    ip: string;
    macAddress: string;
    networkId: number;
}
export interface GetSshKeysSshKey {
    /**
     * Fingerprint of the SSH Key.
     */
    fingerprint: string;
    /**
     * ID of the SSH Key.
     */
    id: number;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Name of the SSH Key.
     */
    name: string;
    /**
     * Public key of the SSH Key pair.
     */
    publicKey: string;
}
export interface GetStorageBoxAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally: boolean;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled: boolean;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled: boolean;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled: boolean;
    /**
     * Whether the ZFS snapshot folder is visible.
     */
    zfsEnabled: boolean;
}
export interface GetStorageBoxSnapshotPlan {
    /**
     * Day of the month when the Snapshot Plan is executed. Null means every day.
     */
    dayOfMonth: number;
    /**
     * 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: number;
    /**
     * Hour when the Snapshot Plan is executed (UTC).
     */
    hour: number;
    /**
     * Maximum amount of Snapshots that will be created by this Snapshot Plan. Older Snapshots will be deleted.
     */
    maxSnapshots: number;
    /**
     * Minute when the Snapshot Plan is executed (UTC).
     */
    minute: number;
}
export interface GetStorageBoxSnapshotStats {
    /**
     * Current storage requirements of the Snapshot in bytes.
     */
    size: number;
    /**
     * Size of the compressed file system contained in the Snapshot in bytes.
     */
    sizeFilesystem: number;
}
export interface GetStorageBoxSnapshotsSnapshot {
    /**
     * Description of the Storage Box Snapshot.
     */
    description: string;
    /**
     * ID of the Storage Box Snapshot.
     */
    id: number;
    /**
     * Whether the Storage Box Snapshot was created automatically.
     */
    isAutomatic: boolean;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Name of the Storage Box Snapshot.
     */
    name: string;
    /**
     * Statistics of the Storage Box Snapshot.
     */
    stats: outputs.GetStorageBoxSnapshotsSnapshotStats;
    /**
     * ID of the Storage Box.
     */
    storageBoxId: number;
}
export interface GetStorageBoxSnapshotsSnapshotStats {
    /**
     * Current storage requirements of the Snapshot in bytes.
     */
    size: number;
    /**
     * Size of the compressed file system contained in the Snapshot in bytes.
     */
    sizeFilesystem: number;
}
export interface GetStorageBoxSubaccountAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally: boolean;
    /**
     * Whether the Subaccount is read-only.
     */
    readonly: boolean;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled: boolean;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled: boolean;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled: boolean;
}
export interface GetStorageBoxSubaccountsSubaccount {
    /**
     * Access settings for the Subaccount.
     */
    accessSettings: outputs.GetStorageBoxSubaccountsSubaccountAccessSettings;
    /**
     * Description of the Storage Box Subaccount.
     */
    description: string;
    /**
     * Home directory of the Storage Box Subaccount.
     */
    homeDirectory: string;
    /**
     * ID of the Storage Box Subaccount.
     */
    id: number;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Name of the Storage Box Subaccount.
     */
    name: string;
    /**
     * FQDN of the Storage Box Subaccount.
     */
    server: string;
    /**
     * ID of the Storage Box.
     */
    storageBoxId: number;
    /**
     * Username of the Storage Box Subaccount.
     */
    username: string;
}
export interface GetStorageBoxSubaccountsSubaccountAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally: boolean;
    /**
     * Whether the Subaccount is read-only.
     */
    readonly: boolean;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled: boolean;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled: boolean;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled: boolean;
}
export interface GetStorageBoxTypesStorageBoxType {
    /**
     * Maximum number of snapshots created automatically by a snapshot plan.
     */
    automaticSnapshotLimit: number;
    /**
     * Date of the Storage Box Type deprecation announcement.
     */
    deprecationAnnounced: string;
    /**
     * Description of the Storage Box Type.
     */
    description: string;
    /**
     * ID of the Storage Box Type.
     */
    id: number;
    /**
     * Whether the Storage Box Type is deprecated.
     */
    isDeprecated: boolean;
    /**
     * Name of the Storage Box Type.
     */
    name: string;
    /**
     * Available storage in bytes.
     */
    size: number;
    /**
     * Maximum number of allowed manual snapshots.
     */
    snapshotLimit: number;
    /**
     * Maximum number of subaccounts.
     */
    subaccountsLimit: number;
    /**
     * Date of the Storage Box Type removal. After this date, the Storage Box Type cannot be used anymore.
     */
    unavailableAfter: string;
}
export interface GetStorageBoxesStorageBox {
    /**
     * Access settings of the Storage Box.
     */
    accessSettings: outputs.GetStorageBoxesStorageBoxAccessSettings;
    /**
     * Whether delete protection is enabled.
     */
    deleteProtection: boolean;
    /**
     * ID of the Storage Box.
     */
    id: number;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Name of the Location.
     */
    location: string;
    /**
     * Name of the Storage Box.
     */
    name: string;
    /**
     * FQDN of the Storage Box.
     */
    server: string;
    /**
     * Details of the active snapshot plan.
     */
    snapshotPlan: outputs.GetStorageBoxesStorageBoxSnapshotPlan;
    /**
     * Name of the Storage Box Type.
     */
    storageBoxType: string;
    /**
     * Host system of the Storage Box.
     */
    system: string;
    /**
     * Primary username of the Storage Box.
     */
    username: string;
}
export interface GetStorageBoxesStorageBoxAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally: boolean;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled: boolean;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled: boolean;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled: boolean;
    /**
     * Whether the ZFS snapshot folder is visible.
     */
    zfsEnabled: boolean;
}
export interface GetStorageBoxesStorageBoxSnapshotPlan {
    /**
     * Day of the month when the Snapshot Plan is executed. Null means every day.
     */
    dayOfMonth: number;
    /**
     * 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: number;
    /**
     * Hour when the Snapshot Plan is executed (UTC).
     */
    hour: number;
    /**
     * Maximum amount of Snapshots that will be created by this Snapshot Plan. Older Snapshots will be deleted.
     */
    maxSnapshots: number;
    /**
     * Minute when the Snapshot Plan is executed (UTC).
     */
    minute: number;
}
export interface GetVolumesVolume {
    deleteProtection: boolean;
    id: number;
    labels: {
        [key: string]: string;
    };
    linuxDevice: string;
    location?: string;
    name: string;
    serverId?: number;
    size: number;
}
export interface GetZoneAuthoritativeNameservers {
    /**
     * Authoritative Hetzner nameservers assigned to the Zone.
     */
    assigneds: string[];
}
export interface GetZonePrimaryNameserver {
    /**
     * Public IPv4 or IPv6 address of the primary nameserver.
     */
    address: string;
    /**
     * Port of the primary nameserver.
     */
    port: number;
    /**
     * Transaction signature (TSIG) algorithm used to generate the TSIG key.
     */
    tsigAlgorithm: string;
    /**
     * Transaction signature (TSIG) key
     */
    tsigKey: string;
}
export interface GetZoneRrsetRecord {
    /**
     * Comment of the record.
     */
    comment: string;
    /**
     * Value of the record.
     */
    value: string;
}
export interface GetZoneRrsetsRrset {
    /**
     * Whether change protection is enabled.
     */
    changeProtection: boolean;
    /**
     * ID of the Zone RRSet.
     */
    id: string;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Name of the Zone RRSet.
     */
    name: string;
    /**
     * Records of the Zone RRSet.
     */
    records: outputs.GetZoneRrsetsRrsetRecord[];
    /**
     * Time To Live (TTL) of the Zone RRSet.
     */
    ttl: number;
    /**
     * Type of the Zone RRSet.
     */
    type: string;
    /**
     * ID or Name of the parent Zone.
     */
    zone: string;
}
export interface GetZoneRrsetsRrsetRecord {
    /**
     * Comment of the record.
     */
    comment: string;
    /**
     * Value of the record.
     */
    value: string;
}
export interface GetZonesZone {
    /**
     * Authoritative nameservers of the Zone.
     */
    authoritativeNameservers: outputs.GetZonesZoneAuthoritativeNameservers;
    /**
     * Whether delete protection is enabled.
     */
    deleteProtection: boolean;
    /**
     * ID of the Zone.
     */
    id: number;
    /**
     * User-defined [labels](https://docs.hetzner.cloud/reference/cloud#labels) (key-value pairs) for the resource.
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Mode of the Zone.
     */
    mode: string;
    /**
     * Name of the Zone.
     */
    name: string;
    /**
     * Primary nameservers of the Zone.
     */
    primaryNameservers: outputs.GetZonesZonePrimaryNameserver[];
    /**
     * Registrar of the Zone.
     */
    registrar: string;
    /**
     * Default Time To Live (TTL) of the Zone.
     */
    ttl: number;
}
export interface GetZonesZoneAuthoritativeNameservers {
    /**
     * Authoritative Hetzner nameservers assigned to the Zone.
     */
    assigneds: string[];
}
export interface GetZonesZonePrimaryNameserver {
    /**
     * Public IPv4 or IPv6 address of the primary nameserver.
     */
    address: string;
    /**
     * Port of the primary nameserver.
     */
    port: number;
    /**
     * Transaction signature (TSIG) algorithm used to generate the TSIG key.
     */
    tsigAlgorithm: string;
    /**
     * Transaction signature (TSIG) key
     */
    tsigKey: string;
}
export interface LoadBalancerAlgorithm {
    /**
     * Type of the Load Balancer Algorithm. `roundRobin` or `leastConnections`
     */
    type: string;
}
export interface LoadBalancerServiceHealthCheck {
    /**
     * HTTP configuration. Required if `protocol` is `http`.
     */
    http: outputs.LoadBalancerServiceHealthCheckHttp;
    /**
     * Interval how often the health check will be performed, in seconds.
     */
    interval: 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: number;
    /**
     * Protocol the health check uses. `http` or `tcp`
     */
    protocol: string;
    /**
     * Number of tries a health check will be performed until a target will be listed as `unhealthy`.
     */
    retries: number;
    /**
     * Timeout when a health check try will be canceled if there is no response, in seconds.
     */
    timeout: number;
}
export interface LoadBalancerServiceHealthCheckHttp {
    /**
     * Domain we try to access when performing the Health Check.
     */
    domain?: string;
    /**
     * Path we try to access when performing the Health Check.
     */
    path?: string;
    /**
     * Response we expect to be included in the Target response when a Health Check was performed.
     */
    response?: string;
    /**
     * We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
     */
    statusCodes?: string[];
    /**
     * Enable TLS certificate checking.
     */
    tls?: boolean;
}
export interface LoadBalancerServiceHttp {
    /**
     * List of IDs from certificates which the Load Balancer has.
     */
    certificates: number[];
    /**
     * Lifetime of the cookie for sticky session (in seconds). Default: `300`
     */
    cookieLifetime: number;
    /**
     * Name of the cookie for sticky session. Default: `HCLBSTICKY`
     */
    cookieName: string;
    /**
     * Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
     */
    redirectHttp: boolean;
    /**
     * Enable sticky sessions
     */
    stickySessions: boolean;
}
export interface LoadBalancerTarget {
    serverId?: number;
    /**
     * (string) Type of the Load Balancer Algorithm. `roundRobin` or `leastConnections`
     */
    type: string;
    /**
     * @deprecated Does not work. Use the hcloud.LoadBalancerTarget resource instead.
     */
    usePrivateIp?: boolean;
}
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: string[];
    /**
     * Specify the IP the server should get in the network
     */
    ip: string;
    /**
     * (Optional, string) The MAC address the private interface of the server has
     */
    macAddress: string;
    /**
     * ID of the network
     */
    networkId: number;
}
export interface ServerPublicNet {
    ipv4: number;
    ipv4Enabled?: boolean;
    ipv6: number;
    ipv6Enabled?: boolean;
}
export interface StorageBoxAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally: boolean;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled: boolean;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled: boolean;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled: boolean;
    /**
     * Whether the ZFS snapshot folder is visible.
     */
    zfsEnabled: boolean;
}
export interface StorageBoxSnapshotPlan {
    /**
     * Day of the month when the Snapshot Plan is executed. Null means every day.
     */
    dayOfMonth?: number;
    /**
     * 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?: number;
    /**
     * Hour when the Snapshot Plan is executed (UTC).
     */
    hour: number;
    /**
     * Maximum amount of Snapshots that will be created by this Snapshot Plan. Older Snapshots will be deleted.
     */
    maxSnapshots: number;
    /**
     * Minute when the Snapshot Plan is executed (UTC).
     */
    minute: number;
}
export interface StorageBoxSubaccountAccessSettings {
    /**
     * Whether access from outside the Hetzner network is allowed.
     */
    reachableExternally: boolean;
    /**
     * Whether the Subaccount is read-only.
     */
    readonly: boolean;
    /**
     * Whether the Samba subsystem is enabled.
     */
    sambaEnabled: boolean;
    /**
     * Whether the SSH subsystem is enabled.
     */
    sshEnabled: boolean;
    /**
     * Whether the WebDAV subsystem is enabled.
     */
    webdavEnabled: boolean;
}
export interface ZoneAuthoritativeNameservers {
    /**
     * Authoritative Hetzner nameservers assigned to the Zone.
     */
    assigneds: string[];
}
export interface ZonePrimaryNameserver {
    /**
     * Public IPv4 or IPv6 address of the primary nameserver.
     */
    address: string;
    /**
     * Port of the primary nameserver.
     */
    port: number;
    /**
     * Transaction signature (TSIG) algorithm used to generate the TSIG key.
     */
    tsigAlgorithm?: string;
    /**
     * Transaction signature (TSIG) key
     */
    tsigKey?: string;
}
export interface ZoneRrsetRecord {
    /**
     * Comment of the record.
     */
    comment?: string;
    /**
     * Value of the record.
     */
    value: string;
}