# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities

__all__ = ['SchedulerArgs', 'Scheduler']

@pulumi.input_type
class SchedulerArgs:
    def __init__(__self__, *,
                 certification_type: Optional[pulumi.Input[str]] = None,
                 city: Optional[pulumi.Input[str]] = None,
                 country: Optional[pulumi.Input[str]] = None,
                 dedicated: Optional[pulumi.Input[bool]] = None,
                 domain: Optional[pulumi.Input[bool]] = None,
                 farm_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                 farm_name: Optional[pulumi.Input[str]] = None,
                 free_ips: Optional[pulumi.Input[int]] = None,
                 gpu_available: Optional[pulumi.Input[bool]] = None,
                 gpu_device_id: Optional[pulumi.Input[str]] = None,
                 gpu_device_name: Optional[pulumi.Input[str]] = None,
                 gpu_vendor_id: Optional[pulumi.Input[str]] = None,
                 gpu_vendor_name: Optional[pulumi.Input[str]] = None,
                 has_gpu: Optional[pulumi.Input[bool]] = None,
                 hru: Optional[pulumi.Input[int]] = None,
                 ipv4: Optional[pulumi.Input[bool]] = None,
                 ipv6: Optional[pulumi.Input[bool]] = None,
                 mru: Optional[pulumi.Input[int]] = None,
                 node_id: Optional[pulumi.Input[int]] = None,
                 rentable: Optional[pulumi.Input[bool]] = None,
                 rented: Optional[pulumi.Input[bool]] = None,
                 sru: Optional[pulumi.Input[int]] = None,
                 twin_id: Optional[pulumi.Input[int]] = None,
                 wireguard: Optional[pulumi.Input[bool]] = None,
                 ygg: Optional[pulumi.Input[bool]] = None):
        """
        The set of arguments for constructing a Scheduler resource.
        """
        if certification_type is not None:
            pulumi.set(__self__, "certification_type", certification_type)
        if city is not None:
            pulumi.set(__self__, "city", city)
        if country is not None:
            pulumi.set(__self__, "country", country)
        if dedicated is not None:
            pulumi.set(__self__, "dedicated", dedicated)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if farm_ids is not None:
            pulumi.set(__self__, "farm_ids", farm_ids)
        if farm_name is not None:
            pulumi.set(__self__, "farm_name", farm_name)
        if free_ips is not None:
            pulumi.set(__self__, "free_ips", free_ips)
        if gpu_available is not None:
            pulumi.set(__self__, "gpu_available", gpu_available)
        if gpu_device_id is not None:
            pulumi.set(__self__, "gpu_device_id", gpu_device_id)
        if gpu_device_name is not None:
            pulumi.set(__self__, "gpu_device_name", gpu_device_name)
        if gpu_vendor_id is not None:
            pulumi.set(__self__, "gpu_vendor_id", gpu_vendor_id)
        if gpu_vendor_name is not None:
            pulumi.set(__self__, "gpu_vendor_name", gpu_vendor_name)
        if has_gpu is not None:
            pulumi.set(__self__, "has_gpu", has_gpu)
        if hru is not None:
            pulumi.set(__self__, "hru", hru)
        if ipv4 is not None:
            pulumi.set(__self__, "ipv4", ipv4)
        if ipv6 is not None:
            pulumi.set(__self__, "ipv6", ipv6)
        if mru is not None:
            pulumi.set(__self__, "mru", mru)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if rentable is not None:
            pulumi.set(__self__, "rentable", rentable)
        if rented is not None:
            pulumi.set(__self__, "rented", rented)
        if sru is not None:
            pulumi.set(__self__, "sru", sru)
        if twin_id is not None:
            pulumi.set(__self__, "twin_id", twin_id)
        if wireguard is not None:
            pulumi.set(__self__, "wireguard", wireguard)
        if ygg is not None:
            pulumi.set(__self__, "ygg", ygg)

    @property
    @pulumi.getter
    def certification_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "certification_type")

    @certification_type.setter
    def certification_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certification_type", value)

    @property
    @pulumi.getter
    def city(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "city")

    @city.setter
    def city(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "city", value)

    @property
    @pulumi.getter
    def country(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "country")

    @country.setter
    def country(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "country", value)

    @property
    @pulumi.getter
    def dedicated(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "dedicated")

    @dedicated.setter
    def dedicated(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dedicated", value)

    @property
    @pulumi.getter
    def domain(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "domain")

    @domain.setter
    def domain(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "domain", value)

    @property
    @pulumi.getter
    def farm_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        return pulumi.get(self, "farm_ids")

    @farm_ids.setter
    def farm_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "farm_ids", value)

    @property
    @pulumi.getter
    def farm_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "farm_name")

    @farm_name.setter
    def farm_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "farm_name", value)

    @property
    @pulumi.getter
    def free_ips(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "free_ips")

    @free_ips.setter
    def free_ips(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "free_ips", value)

    @property
    @pulumi.getter
    def gpu_available(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "gpu_available")

    @gpu_available.setter
    def gpu_available(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gpu_available", value)

    @property
    @pulumi.getter
    def gpu_device_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gpu_device_id")

    @gpu_device_id.setter
    def gpu_device_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpu_device_id", value)

    @property
    @pulumi.getter
    def gpu_device_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gpu_device_name")

    @gpu_device_name.setter
    def gpu_device_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpu_device_name", value)

    @property
    @pulumi.getter
    def gpu_vendor_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gpu_vendor_id")

    @gpu_vendor_id.setter
    def gpu_vendor_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpu_vendor_id", value)

    @property
    @pulumi.getter
    def gpu_vendor_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gpu_vendor_name")

    @gpu_vendor_name.setter
    def gpu_vendor_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpu_vendor_name", value)

    @property
    @pulumi.getter
    def has_gpu(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "has_gpu")

    @has_gpu.setter
    def has_gpu(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "has_gpu", value)

    @property
    @pulumi.getter
    def hru(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "hru")

    @hru.setter
    def hru(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "hru", value)

    @property
    @pulumi.getter
    def ipv4(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ipv4")

    @ipv4.setter
    def ipv4(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ipv4", value)

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ipv6")

    @ipv6.setter
    def ipv6(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ipv6", value)

    @property
    @pulumi.getter
    def mru(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "mru")

    @mru.setter
    def mru(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "mru", value)

    @property
    @pulumi.getter
    def node_id(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "node_id")

    @node_id.setter
    def node_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "node_id", value)

    @property
    @pulumi.getter
    def rentable(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "rentable")

    @rentable.setter
    def rentable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rentable", value)

    @property
    @pulumi.getter
    def rented(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "rented")

    @rented.setter
    def rented(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rented", value)

    @property
    @pulumi.getter
    def sru(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "sru")

    @sru.setter
    def sru(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "sru", value)

    @property
    @pulumi.getter
    def twin_id(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "twin_id")

    @twin_id.setter
    def twin_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "twin_id", value)

    @property
    @pulumi.getter
    def wireguard(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "wireguard")

    @wireguard.setter
    def wireguard(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "wireguard", value)

    @property
    @pulumi.getter
    def ygg(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ygg")

    @ygg.setter
    def ygg(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ygg", value)


class Scheduler(pulumi.CustomResource):
    @overload
    def __init__(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 certification_type: Optional[pulumi.Input[str]] = None,
                 city: Optional[pulumi.Input[str]] = None,
                 country: Optional[pulumi.Input[str]] = None,
                 dedicated: Optional[pulumi.Input[bool]] = None,
                 domain: Optional[pulumi.Input[bool]] = None,
                 farm_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                 farm_name: Optional[pulumi.Input[str]] = None,
                 free_ips: Optional[pulumi.Input[int]] = None,
                 gpu_available: Optional[pulumi.Input[bool]] = None,
                 gpu_device_id: Optional[pulumi.Input[str]] = None,
                 gpu_device_name: Optional[pulumi.Input[str]] = None,
                 gpu_vendor_id: Optional[pulumi.Input[str]] = None,
                 gpu_vendor_name: Optional[pulumi.Input[str]] = None,
                 has_gpu: Optional[pulumi.Input[bool]] = None,
                 hru: Optional[pulumi.Input[int]] = None,
                 ipv4: Optional[pulumi.Input[bool]] = None,
                 ipv6: Optional[pulumi.Input[bool]] = None,
                 mru: Optional[pulumi.Input[int]] = None,
                 node_id: Optional[pulumi.Input[int]] = None,
                 rentable: Optional[pulumi.Input[bool]] = None,
                 rented: Optional[pulumi.Input[bool]] = None,
                 sru: Optional[pulumi.Input[int]] = None,
                 twin_id: Optional[pulumi.Input[int]] = None,
                 wireguard: Optional[pulumi.Input[bool]] = None,
                 ygg: Optional[pulumi.Input[bool]] = None,
                 __props__=None):
        """
        Create a Scheduler resource with the given unique name, props, and options.
        :param str resource_name: The name of the resource.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    @overload
    def __init__(__self__,
                 resource_name: str,
                 args: Optional[SchedulerArgs] = None,
                 opts: Optional[pulumi.ResourceOptions] = None):
        """
        Create a Scheduler resource with the given unique name, props, and options.
        :param str resource_name: The name of the resource.
        :param SchedulerArgs args: The arguments to use to populate this resource's properties.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    def __init__(__self__, resource_name: str, *args, **kwargs):
        resource_args, opts = _utilities.get_resource_args_opts(SchedulerArgs, pulumi.ResourceOptions, *args, **kwargs)
        if resource_args is not None:
            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
        else:
            __self__._internal_init(resource_name, *args, **kwargs)

    def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 certification_type: Optional[pulumi.Input[str]] = None,
                 city: Optional[pulumi.Input[str]] = None,
                 country: Optional[pulumi.Input[str]] = None,
                 dedicated: Optional[pulumi.Input[bool]] = None,
                 domain: Optional[pulumi.Input[bool]] = None,
                 farm_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                 farm_name: Optional[pulumi.Input[str]] = None,
                 free_ips: Optional[pulumi.Input[int]] = None,
                 gpu_available: Optional[pulumi.Input[bool]] = None,
                 gpu_device_id: Optional[pulumi.Input[str]] = None,
                 gpu_device_name: Optional[pulumi.Input[str]] = None,
                 gpu_vendor_id: Optional[pulumi.Input[str]] = None,
                 gpu_vendor_name: Optional[pulumi.Input[str]] = None,
                 has_gpu: Optional[pulumi.Input[bool]] = None,
                 hru: Optional[pulumi.Input[int]] = None,
                 ipv4: Optional[pulumi.Input[bool]] = None,
                 ipv6: Optional[pulumi.Input[bool]] = None,
                 mru: Optional[pulumi.Input[int]] = None,
                 node_id: Optional[pulumi.Input[int]] = None,
                 rentable: Optional[pulumi.Input[bool]] = None,
                 rented: Optional[pulumi.Input[bool]] = None,
                 sru: Optional[pulumi.Input[int]] = None,
                 twin_id: Optional[pulumi.Input[int]] = None,
                 wireguard: Optional[pulumi.Input[bool]] = None,
                 ygg: Optional[pulumi.Input[bool]] = None,
                 __props__=None):
        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = SchedulerArgs.__new__(SchedulerArgs)

            __props__.__dict__["certification_type"] = certification_type
            __props__.__dict__["city"] = city
            __props__.__dict__["country"] = country
            __props__.__dict__["dedicated"] = dedicated
            __props__.__dict__["domain"] = domain
            __props__.__dict__["farm_ids"] = farm_ids
            __props__.__dict__["farm_name"] = farm_name
            __props__.__dict__["free_ips"] = free_ips
            __props__.__dict__["gpu_available"] = gpu_available
            __props__.__dict__["gpu_device_id"] = gpu_device_id
            __props__.__dict__["gpu_device_name"] = gpu_device_name
            __props__.__dict__["gpu_vendor_id"] = gpu_vendor_id
            __props__.__dict__["gpu_vendor_name"] = gpu_vendor_name
            __props__.__dict__["has_gpu"] = has_gpu
            __props__.__dict__["hru"] = hru
            __props__.__dict__["ipv4"] = ipv4
            __props__.__dict__["ipv6"] = ipv6
            __props__.__dict__["mru"] = mru
            __props__.__dict__["node_id"] = node_id
            __props__.__dict__["rentable"] = rentable
            __props__.__dict__["rented"] = rented
            __props__.__dict__["sru"] = sru
            __props__.__dict__["twin_id"] = twin_id
            __props__.__dict__["wireguard"] = wireguard
            __props__.__dict__["ygg"] = ygg
            __props__.__dict__["nodes"] = None
        super(Scheduler, __self__).__init__(
            'threefold:index:Scheduler',
            resource_name,
            __props__,
            opts)

    @staticmethod
    def get(resource_name: str,
            id: pulumi.Input[str],
            opts: Optional[pulumi.ResourceOptions] = None) -> 'Scheduler':
        """
        Get an existing Scheduler resource's state with the given name, id, and optional extra
        properties used to qualify the lookup.

        :param str resource_name: The unique name of the resulting resource.
        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))

        __props__ = SchedulerArgs.__new__(SchedulerArgs)

        __props__.__dict__["certification_type"] = None
        __props__.__dict__["city"] = None
        __props__.__dict__["country"] = None
        __props__.__dict__["dedicated"] = None
        __props__.__dict__["domain"] = None
        __props__.__dict__["farm_ids"] = None
        __props__.__dict__["farm_name"] = None
        __props__.__dict__["free_ips"] = None
        __props__.__dict__["gpu_available"] = None
        __props__.__dict__["gpu_device_id"] = None
        __props__.__dict__["gpu_device_name"] = None
        __props__.__dict__["gpu_vendor_id"] = None
        __props__.__dict__["gpu_vendor_name"] = None
        __props__.__dict__["has_gpu"] = None
        __props__.__dict__["hru"] = None
        __props__.__dict__["ipv4"] = None
        __props__.__dict__["ipv6"] = None
        __props__.__dict__["mru"] = None
        __props__.__dict__["node_id"] = None
        __props__.__dict__["nodes"] = None
        __props__.__dict__["rentable"] = None
        __props__.__dict__["rented"] = None
        __props__.__dict__["sru"] = None
        __props__.__dict__["twin_id"] = None
        __props__.__dict__["wireguard"] = None
        __props__.__dict__["ygg"] = None
        return Scheduler(resource_name, opts=opts, __props__=__props__)

    @property
    @pulumi.getter
    def certification_type(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "certification_type")

    @property
    @pulumi.getter
    def city(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "city")

    @property
    @pulumi.getter
    def country(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "country")

    @property
    @pulumi.getter
    def dedicated(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "dedicated")

    @property
    @pulumi.getter
    def domain(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def farm_ids(self) -> pulumi.Output[Optional[Sequence[int]]]:
        return pulumi.get(self, "farm_ids")

    @property
    @pulumi.getter
    def farm_name(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "farm_name")

    @property
    @pulumi.getter
    def free_ips(self) -> pulumi.Output[Optional[int]]:
        return pulumi.get(self, "free_ips")

    @property
    @pulumi.getter
    def gpu_available(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "gpu_available")

    @property
    @pulumi.getter
    def gpu_device_id(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "gpu_device_id")

    @property
    @pulumi.getter
    def gpu_device_name(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "gpu_device_name")

    @property
    @pulumi.getter
    def gpu_vendor_id(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "gpu_vendor_id")

    @property
    @pulumi.getter
    def gpu_vendor_name(self) -> pulumi.Output[Optional[str]]:
        return pulumi.get(self, "gpu_vendor_name")

    @property
    @pulumi.getter
    def has_gpu(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "has_gpu")

    @property
    @pulumi.getter
    def hru(self) -> pulumi.Output[Optional[int]]:
        return pulumi.get(self, "hru")

    @property
    @pulumi.getter
    def ipv4(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "ipv4")

    @property
    @pulumi.getter
    def ipv6(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "ipv6")

    @property
    @pulumi.getter
    def mru(self) -> pulumi.Output[Optional[int]]:
        return pulumi.get(self, "mru")

    @property
    @pulumi.getter
    def node_id(self) -> pulumi.Output[Optional[int]]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def nodes(self) -> pulumi.Output[Sequence[int]]:
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter
    def rentable(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "rentable")

    @property
    @pulumi.getter
    def rented(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "rented")

    @property
    @pulumi.getter
    def sru(self) -> pulumi.Output[Optional[int]]:
        return pulumi.get(self, "sru")

    @property
    @pulumi.getter
    def twin_id(self) -> pulumi.Output[Optional[int]]:
        return pulumi.get(self, "twin_id")

    @property
    @pulumi.getter
    def wireguard(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "wireguard")

    @property
    @pulumi.getter
    def ygg(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "ygg")

