# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** 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
from . import outputs

__all__ = [
    'GetInfluxDbResult',
    'AwaitableGetInfluxDbResult',
    'get_influx_db',
    'get_influx_db_output',
]

@pulumi.output_type
class GetInfluxDbResult:
    """
    A collection of values returned by getInfluxDb.
    """
    def __init__(__self__, additional_disk_space=None, cloud_name=None, components=None, disk_space=None, disk_space_cap=None, disk_space_default=None, disk_space_step=None, disk_space_used=None, id=None, influxdb_user_configs=None, influxdbs=None, maintenance_window_dow=None, maintenance_window_time=None, plan=None, project=None, project_vpc_id=None, service_host=None, service_integrations=None, service_name=None, service_password=None, service_port=None, service_type=None, service_uri=None, service_username=None, state=None, static_ips=None, tags=None, tech_emails=None, termination_protection=None):
        if additional_disk_space and not isinstance(additional_disk_space, str):
            raise TypeError("Expected argument 'additional_disk_space' to be a str")
        pulumi.set(__self__, "additional_disk_space", additional_disk_space)
        if cloud_name and not isinstance(cloud_name, str):
            raise TypeError("Expected argument 'cloud_name' to be a str")
        pulumi.set(__self__, "cloud_name", cloud_name)
        if components and not isinstance(components, list):
            raise TypeError("Expected argument 'components' to be a list")
        pulumi.set(__self__, "components", components)
        if disk_space and not isinstance(disk_space, str):
            raise TypeError("Expected argument 'disk_space' to be a str")
        pulumi.set(__self__, "disk_space", disk_space)
        if disk_space_cap and not isinstance(disk_space_cap, str):
            raise TypeError("Expected argument 'disk_space_cap' to be a str")
        pulumi.set(__self__, "disk_space_cap", disk_space_cap)
        if disk_space_default and not isinstance(disk_space_default, str):
            raise TypeError("Expected argument 'disk_space_default' to be a str")
        pulumi.set(__self__, "disk_space_default", disk_space_default)
        if disk_space_step and not isinstance(disk_space_step, str):
            raise TypeError("Expected argument 'disk_space_step' to be a str")
        pulumi.set(__self__, "disk_space_step", disk_space_step)
        if disk_space_used and not isinstance(disk_space_used, str):
            raise TypeError("Expected argument 'disk_space_used' to be a str")
        pulumi.set(__self__, "disk_space_used", disk_space_used)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if influxdb_user_configs and not isinstance(influxdb_user_configs, list):
            raise TypeError("Expected argument 'influxdb_user_configs' to be a list")
        pulumi.set(__self__, "influxdb_user_configs", influxdb_user_configs)
        if influxdbs and not isinstance(influxdbs, list):
            raise TypeError("Expected argument 'influxdbs' to be a list")
        pulumi.set(__self__, "influxdbs", influxdbs)
        if maintenance_window_dow and not isinstance(maintenance_window_dow, str):
            raise TypeError("Expected argument 'maintenance_window_dow' to be a str")
        pulumi.set(__self__, "maintenance_window_dow", maintenance_window_dow)
        if maintenance_window_time and not isinstance(maintenance_window_time, str):
            raise TypeError("Expected argument 'maintenance_window_time' to be a str")
        pulumi.set(__self__, "maintenance_window_time", maintenance_window_time)
        if plan and not isinstance(plan, str):
            raise TypeError("Expected argument 'plan' to be a str")
        pulumi.set(__self__, "plan", plan)
        if project and not isinstance(project, str):
            raise TypeError("Expected argument 'project' to be a str")
        pulumi.set(__self__, "project", project)
        if project_vpc_id and not isinstance(project_vpc_id, str):
            raise TypeError("Expected argument 'project_vpc_id' to be a str")
        pulumi.set(__self__, "project_vpc_id", project_vpc_id)
        if service_host and not isinstance(service_host, str):
            raise TypeError("Expected argument 'service_host' to be a str")
        pulumi.set(__self__, "service_host", service_host)
        if service_integrations and not isinstance(service_integrations, list):
            raise TypeError("Expected argument 'service_integrations' to be a list")
        pulumi.set(__self__, "service_integrations", service_integrations)
        if service_name and not isinstance(service_name, str):
            raise TypeError("Expected argument 'service_name' to be a str")
        pulumi.set(__self__, "service_name", service_name)
        if service_password and not isinstance(service_password, str):
            raise TypeError("Expected argument 'service_password' to be a str")
        pulumi.set(__self__, "service_password", service_password)
        if service_port and not isinstance(service_port, int):
            raise TypeError("Expected argument 'service_port' to be a int")
        pulumi.set(__self__, "service_port", service_port)
        if service_type and not isinstance(service_type, str):
            raise TypeError("Expected argument 'service_type' to be a str")
        pulumi.set(__self__, "service_type", service_type)
        if service_uri and not isinstance(service_uri, str):
            raise TypeError("Expected argument 'service_uri' to be a str")
        pulumi.set(__self__, "service_uri", service_uri)
        if service_username and not isinstance(service_username, str):
            raise TypeError("Expected argument 'service_username' to be a str")
        pulumi.set(__self__, "service_username", service_username)
        if state and not isinstance(state, str):
            raise TypeError("Expected argument 'state' to be a str")
        pulumi.set(__self__, "state", state)
        if static_ips and not isinstance(static_ips, list):
            raise TypeError("Expected argument 'static_ips' to be a list")
        pulumi.set(__self__, "static_ips", static_ips)
        if tags and not isinstance(tags, list):
            raise TypeError("Expected argument 'tags' to be a list")
        pulumi.set(__self__, "tags", tags)
        if tech_emails and not isinstance(tech_emails, list):
            raise TypeError("Expected argument 'tech_emails' to be a list")
        pulumi.set(__self__, "tech_emails", tech_emails)
        if termination_protection and not isinstance(termination_protection, bool):
            raise TypeError("Expected argument 'termination_protection' to be a bool")
        pulumi.set(__self__, "termination_protection", termination_protection)

    @property
    @pulumi.getter(name="additionalDiskSpace")
    def additional_disk_space(self) -> str:
        return pulumi.get(self, "additional_disk_space")

    @property
    @pulumi.getter(name="cloudName")
    def cloud_name(self) -> str:
        return pulumi.get(self, "cloud_name")

    @property
    @pulumi.getter
    def components(self) -> Sequence['outputs.GetInfluxDbComponentResult']:
        return pulumi.get(self, "components")

    @property
    @pulumi.getter(name="diskSpace")
    def disk_space(self) -> str:
        return pulumi.get(self, "disk_space")

    @property
    @pulumi.getter(name="diskSpaceCap")
    def disk_space_cap(self) -> str:
        return pulumi.get(self, "disk_space_cap")

    @property
    @pulumi.getter(name="diskSpaceDefault")
    def disk_space_default(self) -> str:
        return pulumi.get(self, "disk_space_default")

    @property
    @pulumi.getter(name="diskSpaceStep")
    def disk_space_step(self) -> str:
        return pulumi.get(self, "disk_space_step")

    @property
    @pulumi.getter(name="diskSpaceUsed")
    def disk_space_used(self) -> str:
        return pulumi.get(self, "disk_space_used")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The provider-assigned unique ID for this managed resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="influxdbUserConfigs")
    def influxdb_user_configs(self) -> Sequence['outputs.GetInfluxDbInfluxdbUserConfigResult']:
        return pulumi.get(self, "influxdb_user_configs")

    @property
    @pulumi.getter
    def influxdbs(self) -> Sequence['outputs.GetInfluxDbInfluxdbResult']:
        return pulumi.get(self, "influxdbs")

    @property
    @pulumi.getter(name="maintenanceWindowDow")
    def maintenance_window_dow(self) -> str:
        return pulumi.get(self, "maintenance_window_dow")

    @property
    @pulumi.getter(name="maintenanceWindowTime")
    def maintenance_window_time(self) -> str:
        return pulumi.get(self, "maintenance_window_time")

    @property
    @pulumi.getter
    def plan(self) -> str:
        return pulumi.get(self, "plan")

    @property
    @pulumi.getter
    def project(self) -> str:
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="projectVpcId")
    def project_vpc_id(self) -> str:
        return pulumi.get(self, "project_vpc_id")

    @property
    @pulumi.getter(name="serviceHost")
    def service_host(self) -> str:
        return pulumi.get(self, "service_host")

    @property
    @pulumi.getter(name="serviceIntegrations")
    def service_integrations(self) -> Sequence['outputs.GetInfluxDbServiceIntegrationResult']:
        return pulumi.get(self, "service_integrations")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> str:
        return pulumi.get(self, "service_name")

    @property
    @pulumi.getter(name="servicePassword")
    def service_password(self) -> str:
        return pulumi.get(self, "service_password")

    @property
    @pulumi.getter(name="servicePort")
    def service_port(self) -> int:
        return pulumi.get(self, "service_port")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> str:
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> str:
        return pulumi.get(self, "service_uri")

    @property
    @pulumi.getter(name="serviceUsername")
    def service_username(self) -> str:
        return pulumi.get(self, "service_username")

    @property
    @pulumi.getter
    def state(self) -> str:
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Sequence[str]:
        return pulumi.get(self, "static_ips")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetInfluxDbTagResult']:
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="techEmails")
    def tech_emails(self) -> Sequence['outputs.GetInfluxDbTechEmailResult']:
        return pulumi.get(self, "tech_emails")

    @property
    @pulumi.getter(name="terminationProtection")
    def termination_protection(self) -> bool:
        return pulumi.get(self, "termination_protection")


class AwaitableGetInfluxDbResult(GetInfluxDbResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetInfluxDbResult(
            additional_disk_space=self.additional_disk_space,
            cloud_name=self.cloud_name,
            components=self.components,
            disk_space=self.disk_space,
            disk_space_cap=self.disk_space_cap,
            disk_space_default=self.disk_space_default,
            disk_space_step=self.disk_space_step,
            disk_space_used=self.disk_space_used,
            id=self.id,
            influxdb_user_configs=self.influxdb_user_configs,
            influxdbs=self.influxdbs,
            maintenance_window_dow=self.maintenance_window_dow,
            maintenance_window_time=self.maintenance_window_time,
            plan=self.plan,
            project=self.project,
            project_vpc_id=self.project_vpc_id,
            service_host=self.service_host,
            service_integrations=self.service_integrations,
            service_name=self.service_name,
            service_password=self.service_password,
            service_port=self.service_port,
            service_type=self.service_type,
            service_uri=self.service_uri,
            service_username=self.service_username,
            state=self.state,
            static_ips=self.static_ips,
            tags=self.tags,
            tech_emails=self.tech_emails,
            termination_protection=self.termination_protection)


def get_influx_db(project: Optional[str] = None,
                  service_name: Optional[str] = None,
                  opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetInfluxDbResult:
    """
    Use this data source to access information about an existing resource.
    """
    __args__ = dict()
    __args__['project'] = project
    __args__['serviceName'] = service_name
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('aiven:index/getInfluxDb:getInfluxDb', __args__, opts=opts, typ=GetInfluxDbResult).value

    return AwaitableGetInfluxDbResult(
        additional_disk_space=pulumi.get(__ret__, 'additional_disk_space'),
        cloud_name=pulumi.get(__ret__, 'cloud_name'),
        components=pulumi.get(__ret__, 'components'),
        disk_space=pulumi.get(__ret__, 'disk_space'),
        disk_space_cap=pulumi.get(__ret__, 'disk_space_cap'),
        disk_space_default=pulumi.get(__ret__, 'disk_space_default'),
        disk_space_step=pulumi.get(__ret__, 'disk_space_step'),
        disk_space_used=pulumi.get(__ret__, 'disk_space_used'),
        id=pulumi.get(__ret__, 'id'),
        influxdb_user_configs=pulumi.get(__ret__, 'influxdb_user_configs'),
        influxdbs=pulumi.get(__ret__, 'influxdbs'),
        maintenance_window_dow=pulumi.get(__ret__, 'maintenance_window_dow'),
        maintenance_window_time=pulumi.get(__ret__, 'maintenance_window_time'),
        plan=pulumi.get(__ret__, 'plan'),
        project=pulumi.get(__ret__, 'project'),
        project_vpc_id=pulumi.get(__ret__, 'project_vpc_id'),
        service_host=pulumi.get(__ret__, 'service_host'),
        service_integrations=pulumi.get(__ret__, 'service_integrations'),
        service_name=pulumi.get(__ret__, 'service_name'),
        service_password=pulumi.get(__ret__, 'service_password'),
        service_port=pulumi.get(__ret__, 'service_port'),
        service_type=pulumi.get(__ret__, 'service_type'),
        service_uri=pulumi.get(__ret__, 'service_uri'),
        service_username=pulumi.get(__ret__, 'service_username'),
        state=pulumi.get(__ret__, 'state'),
        static_ips=pulumi.get(__ret__, 'static_ips'),
        tags=pulumi.get(__ret__, 'tags'),
        tech_emails=pulumi.get(__ret__, 'tech_emails'),
        termination_protection=pulumi.get(__ret__, 'termination_protection'))
def get_influx_db_output(project: Optional[pulumi.Input[str]] = None,
                         service_name: Optional[pulumi.Input[str]] = None,
                         opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetInfluxDbResult]:
    """
    Use this data source to access information about an existing resource.
    """
    __args__ = dict()
    __args__['project'] = project
    __args__['serviceName'] = service_name
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('aiven:index/getInfluxDb:getInfluxDb', __args__, opts=opts, typ=GetInfluxDbResult)
    return __ret__.apply(lambda __response__: GetInfluxDbResult(
        additional_disk_space=pulumi.get(__response__, 'additional_disk_space'),
        cloud_name=pulumi.get(__response__, 'cloud_name'),
        components=pulumi.get(__response__, 'components'),
        disk_space=pulumi.get(__response__, 'disk_space'),
        disk_space_cap=pulumi.get(__response__, 'disk_space_cap'),
        disk_space_default=pulumi.get(__response__, 'disk_space_default'),
        disk_space_step=pulumi.get(__response__, 'disk_space_step'),
        disk_space_used=pulumi.get(__response__, 'disk_space_used'),
        id=pulumi.get(__response__, 'id'),
        influxdb_user_configs=pulumi.get(__response__, 'influxdb_user_configs'),
        influxdbs=pulumi.get(__response__, 'influxdbs'),
        maintenance_window_dow=pulumi.get(__response__, 'maintenance_window_dow'),
        maintenance_window_time=pulumi.get(__response__, 'maintenance_window_time'),
        plan=pulumi.get(__response__, 'plan'),
        project=pulumi.get(__response__, 'project'),
        project_vpc_id=pulumi.get(__response__, 'project_vpc_id'),
        service_host=pulumi.get(__response__, 'service_host'),
        service_integrations=pulumi.get(__response__, 'service_integrations'),
        service_name=pulumi.get(__response__, 'service_name'),
        service_password=pulumi.get(__response__, 'service_password'),
        service_port=pulumi.get(__response__, 'service_port'),
        service_type=pulumi.get(__response__, 'service_type'),
        service_uri=pulumi.get(__response__, 'service_uri'),
        service_username=pulumi.get(__response__, 'service_username'),
        state=pulumi.get(__response__, 'state'),
        static_ips=pulumi.get(__response__, 'static_ips'),
        tags=pulumi.get(__response__, 'tags'),
        tech_emails=pulumi.get(__response__, 'tech_emails'),
        termination_protection=pulumi.get(__response__, 'termination_protection')))
