# 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
from ._inputs import *

__all__ = [
    'GetStandardResult',
    'AwaitableGetStandardResult',
    'get_standard',
    'get_standard_output',
]

@pulumi.output_type
class GetStandardResult:
    """
    A collection of values returned by getStandard.
    """
    def __init__(__self__, app_service_plan_id=None, app_settings=None, bundle_version=None, client_affinity_enabled=None, client_certificate_mode=None, connection_strings=None, custom_domain_verification_id=None, default_hostname=None, enabled=None, https_only=None, id=None, identities=None, kind=None, location=None, name=None, outbound_ip_addresses=None, possible_outbound_ip_addresses=None, public_network_access=None, resource_group_name=None, site_config=None, site_credentials=None, storage_account_access_key=None, storage_account_name=None, storage_account_share_name=None, tags=None, use_extension_bundle=None, version=None, virtual_network_subnet_id=None):
        if app_service_plan_id and not isinstance(app_service_plan_id, str):
            raise TypeError("Expected argument 'app_service_plan_id' to be a str")
        pulumi.set(__self__, "app_service_plan_id", app_service_plan_id)
        if app_settings and not isinstance(app_settings, dict):
            raise TypeError("Expected argument 'app_settings' to be a dict")
        pulumi.set(__self__, "app_settings", app_settings)
        if bundle_version and not isinstance(bundle_version, str):
            raise TypeError("Expected argument 'bundle_version' to be a str")
        pulumi.set(__self__, "bundle_version", bundle_version)
        if client_affinity_enabled and not isinstance(client_affinity_enabled, bool):
            raise TypeError("Expected argument 'client_affinity_enabled' to be a bool")
        pulumi.set(__self__, "client_affinity_enabled", client_affinity_enabled)
        if client_certificate_mode and not isinstance(client_certificate_mode, str):
            raise TypeError("Expected argument 'client_certificate_mode' to be a str")
        pulumi.set(__self__, "client_certificate_mode", client_certificate_mode)
        if connection_strings and not isinstance(connection_strings, list):
            raise TypeError("Expected argument 'connection_strings' to be a list")
        pulumi.set(__self__, "connection_strings", connection_strings)
        if custom_domain_verification_id and not isinstance(custom_domain_verification_id, str):
            raise TypeError("Expected argument 'custom_domain_verification_id' to be a str")
        pulumi.set(__self__, "custom_domain_verification_id", custom_domain_verification_id)
        if default_hostname and not isinstance(default_hostname, str):
            raise TypeError("Expected argument 'default_hostname' to be a str")
        pulumi.set(__self__, "default_hostname", default_hostname)
        if enabled and not isinstance(enabled, bool):
            raise TypeError("Expected argument 'enabled' to be a bool")
        pulumi.set(__self__, "enabled", enabled)
        if https_only and not isinstance(https_only, bool):
            raise TypeError("Expected argument 'https_only' to be a bool")
        pulumi.set(__self__, "https_only", https_only)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if identities and not isinstance(identities, list):
            raise TypeError("Expected argument 'identities' to be a list")
        pulumi.set(__self__, "identities", identities)
        if kind and not isinstance(kind, str):
            raise TypeError("Expected argument 'kind' to be a str")
        pulumi.set(__self__, "kind", kind)
        if location and not isinstance(location, str):
            raise TypeError("Expected argument 'location' to be a str")
        pulumi.set(__self__, "location", location)
        if name and not isinstance(name, str):
            raise TypeError("Expected argument 'name' to be a str")
        pulumi.set(__self__, "name", name)
        if outbound_ip_addresses and not isinstance(outbound_ip_addresses, str):
            raise TypeError("Expected argument 'outbound_ip_addresses' to be a str")
        pulumi.set(__self__, "outbound_ip_addresses", outbound_ip_addresses)
        if possible_outbound_ip_addresses and not isinstance(possible_outbound_ip_addresses, str):
            raise TypeError("Expected argument 'possible_outbound_ip_addresses' to be a str")
        pulumi.set(__self__, "possible_outbound_ip_addresses", possible_outbound_ip_addresses)
        if public_network_access and not isinstance(public_network_access, str):
            raise TypeError("Expected argument 'public_network_access' to be a str")
        pulumi.set(__self__, "public_network_access", public_network_access)
        if resource_group_name and not isinstance(resource_group_name, str):
            raise TypeError("Expected argument 'resource_group_name' to be a str")
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        if site_config and not isinstance(site_config, dict):
            raise TypeError("Expected argument 'site_config' to be a dict")
        pulumi.set(__self__, "site_config", site_config)
        if site_credentials and not isinstance(site_credentials, list):
            raise TypeError("Expected argument 'site_credentials' to be a list")
        pulumi.set(__self__, "site_credentials", site_credentials)
        if storage_account_access_key and not isinstance(storage_account_access_key, str):
            raise TypeError("Expected argument 'storage_account_access_key' to be a str")
        pulumi.set(__self__, "storage_account_access_key", storage_account_access_key)
        if storage_account_name and not isinstance(storage_account_name, str):
            raise TypeError("Expected argument 'storage_account_name' to be a str")
        pulumi.set(__self__, "storage_account_name", storage_account_name)
        if storage_account_share_name and not isinstance(storage_account_share_name, str):
            raise TypeError("Expected argument 'storage_account_share_name' to be a str")
        pulumi.set(__self__, "storage_account_share_name", storage_account_share_name)
        if tags and not isinstance(tags, dict):
            raise TypeError("Expected argument 'tags' to be a dict")
        pulumi.set(__self__, "tags", tags)
        if use_extension_bundle and not isinstance(use_extension_bundle, bool):
            raise TypeError("Expected argument 'use_extension_bundle' to be a bool")
        pulumi.set(__self__, "use_extension_bundle", use_extension_bundle)
        if version and not isinstance(version, str):
            raise TypeError("Expected argument 'version' to be a str")
        pulumi.set(__self__, "version", version)
        if virtual_network_subnet_id and not isinstance(virtual_network_subnet_id, str):
            raise TypeError("Expected argument 'virtual_network_subnet_id' to be a str")
        pulumi.set(__self__, "virtual_network_subnet_id", virtual_network_subnet_id)

    @property
    @pulumi.getter(name="appServicePlanId")
    def app_service_plan_id(self) -> str:
        """
        The ID of the App Service Plan.
        """
        return pulumi.get(self, "app_service_plan_id")

    @property
    @pulumi.getter(name="appSettings")
    def app_settings(self) -> Mapping[str, str]:
        """
        A map of key-value pairs for [App Settings](https://docs.microsoft.com/azure/azure-functions/functions-app-settings) and custom values.
        """
        return pulumi.get(self, "app_settings")

    @property
    @pulumi.getter(name="bundleVersion")
    def bundle_version(self) -> str:
        """
        Controls the allowed range for bundle versions.
        """
        return pulumi.get(self, "bundle_version")

    @property
    @pulumi.getter(name="clientAffinityEnabled")
    def client_affinity_enabled(self) -> bool:
        """
        Should the Logic App send session affinity cookies, which route client requests in the same session to the same instance.
        """
        return pulumi.get(self, "client_affinity_enabled")

    @property
    @pulumi.getter(name="clientCertificateMode")
    def client_certificate_mode(self) -> str:
        """
        The mode of the Logic App's client certificates requirement for incoming requests.
        """
        return pulumi.get(self, "client_certificate_mode")

    @property
    @pulumi.getter(name="connectionStrings")
    def connection_strings(self) -> Sequence['outputs.GetStandardConnectionStringResult']:
        """
        A `connection_string` block as defined below.
        """
        return pulumi.get(self, "connection_strings")

    @property
    @pulumi.getter(name="customDomainVerificationId")
    def custom_domain_verification_id(self) -> str:
        """
        The custom domain verification of the Logic App.
        """
        return pulumi.get(self, "custom_domain_verification_id")

    @property
    @pulumi.getter(name="defaultHostname")
    def default_hostname(self) -> str:
        """
        The default hostname of the Logic App.
        """
        return pulumi.get(self, "default_hostname")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether the Logic App is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="httpsOnly")
    def https_only(self) -> bool:
        """
        Whether the Logic App can only be accessed via HTTPS.
        """
        return pulumi.get(self, "https_only")

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

    @property
    @pulumi.getter
    def identities(self) -> Sequence['outputs.GetStandardIdentityResult']:
        """
        An `identity` block as defined below.
        """
        return pulumi.get(self, "identities")

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        The kind of the Logic App.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        The Azure location where the Logic App Standard exists.
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name for this IP Restriction.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="outboundIpAddresses")
    def outbound_ip_addresses(self) -> str:
        """
        The outbound IP addresses of the Logic App.
        """
        return pulumi.get(self, "outbound_ip_addresses")

    @property
    @pulumi.getter(name="possibleOutboundIpAddresses")
    def possible_outbound_ip_addresses(self) -> str:
        """
        The possible outbound IP addresses of the Logic App.
        """
        return pulumi.get(self, "possible_outbound_ip_addresses")

    @property
    @pulumi.getter(name="publicNetworkAccess")
    def public_network_access(self) -> str:
        """
        Whether Public Network Access should be enabled or not.
        """
        return pulumi.get(self, "public_network_access")

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

    @property
    @pulumi.getter(name="siteConfig")
    def site_config(self) -> 'outputs.GetStandardSiteConfigResult':
        """
        A `site_config` object as defined below.
        """
        return pulumi.get(self, "site_config")

    @property
    @pulumi.getter(name="siteCredentials")
    def site_credentials(self) -> Sequence['outputs.GetStandardSiteCredentialResult']:
        """
        A `site_credential` block as defined below, which contains the site-level credentials used to publish to this Logic App.
        """
        return pulumi.get(self, "site_credentials")

    @property
    @pulumi.getter(name="storageAccountAccessKey")
    def storage_account_access_key(self) -> str:
        """
        The access key which will be used to access the backend storage account for the Logic App.
        """
        return pulumi.get(self, "storage_account_access_key")

    @property
    @pulumi.getter(name="storageAccountName")
    def storage_account_name(self) -> str:
        """
        The backend storage account name which will be used by this Logic App (e.g. for Stateful workflows data).
        """
        return pulumi.get(self, "storage_account_name")

    @property
    @pulumi.getter(name="storageAccountShareName")
    def storage_account_share_name(self) -> str:
        """
        The name of the share used by the logic app.
        """
        return pulumi.get(self, "storage_account_share_name")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, str]:
        """
        A mapping of tags assigned to the resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="useExtensionBundle")
    def use_extension_bundle(self) -> bool:
        """
        Whether the logic app should use the bundled extension package.
        """
        return pulumi.get(self, "use_extension_bundle")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The runtime version associated with the Logic App.
        """
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="virtualNetworkSubnetId")
    def virtual_network_subnet_id(self) -> str:
        """
        The Virtual Network Subnet ID used for this IP Restriction.
        """
        return pulumi.get(self, "virtual_network_subnet_id")


class AwaitableGetStandardResult(GetStandardResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetStandardResult(
            app_service_plan_id=self.app_service_plan_id,
            app_settings=self.app_settings,
            bundle_version=self.bundle_version,
            client_affinity_enabled=self.client_affinity_enabled,
            client_certificate_mode=self.client_certificate_mode,
            connection_strings=self.connection_strings,
            custom_domain_verification_id=self.custom_domain_verification_id,
            default_hostname=self.default_hostname,
            enabled=self.enabled,
            https_only=self.https_only,
            id=self.id,
            identities=self.identities,
            kind=self.kind,
            location=self.location,
            name=self.name,
            outbound_ip_addresses=self.outbound_ip_addresses,
            possible_outbound_ip_addresses=self.possible_outbound_ip_addresses,
            public_network_access=self.public_network_access,
            resource_group_name=self.resource_group_name,
            site_config=self.site_config,
            site_credentials=self.site_credentials,
            storage_account_access_key=self.storage_account_access_key,
            storage_account_name=self.storage_account_name,
            storage_account_share_name=self.storage_account_share_name,
            tags=self.tags,
            use_extension_bundle=self.use_extension_bundle,
            version=self.version,
            virtual_network_subnet_id=self.virtual_network_subnet_id)


def get_standard(name: Optional[str] = None,
                 resource_group_name: Optional[str] = None,
                 site_config: Optional[Union['GetStandardSiteConfigArgs', 'GetStandardSiteConfigArgsDict']] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStandardResult:
    """
    Use this data source to access information about an existing Logic App Standard instance.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_azure as azure

    example = azure.logicapps.get_standard(name="logicappstd",
        resource_group_name="example-rg")
    pulumi.export("id", example.id)
    ```


    :param str name: The name of this Logic App.
    :param str resource_group_name: The name of the Resource Group where the Logic App exists.
    :param Union['GetStandardSiteConfigArgs', 'GetStandardSiteConfigArgsDict'] site_config: A `site_config` object as defined below.
    """
    __args__ = dict()
    __args__['name'] = name
    __args__['resourceGroupName'] = resource_group_name
    __args__['siteConfig'] = site_config
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('azure:logicapps/getStandard:getStandard', __args__, opts=opts, typ=GetStandardResult).value

    return AwaitableGetStandardResult(
        app_service_plan_id=pulumi.get(__ret__, 'app_service_plan_id'),
        app_settings=pulumi.get(__ret__, 'app_settings'),
        bundle_version=pulumi.get(__ret__, 'bundle_version'),
        client_affinity_enabled=pulumi.get(__ret__, 'client_affinity_enabled'),
        client_certificate_mode=pulumi.get(__ret__, 'client_certificate_mode'),
        connection_strings=pulumi.get(__ret__, 'connection_strings'),
        custom_domain_verification_id=pulumi.get(__ret__, 'custom_domain_verification_id'),
        default_hostname=pulumi.get(__ret__, 'default_hostname'),
        enabled=pulumi.get(__ret__, 'enabled'),
        https_only=pulumi.get(__ret__, 'https_only'),
        id=pulumi.get(__ret__, 'id'),
        identities=pulumi.get(__ret__, 'identities'),
        kind=pulumi.get(__ret__, 'kind'),
        location=pulumi.get(__ret__, 'location'),
        name=pulumi.get(__ret__, 'name'),
        outbound_ip_addresses=pulumi.get(__ret__, 'outbound_ip_addresses'),
        possible_outbound_ip_addresses=pulumi.get(__ret__, 'possible_outbound_ip_addresses'),
        public_network_access=pulumi.get(__ret__, 'public_network_access'),
        resource_group_name=pulumi.get(__ret__, 'resource_group_name'),
        site_config=pulumi.get(__ret__, 'site_config'),
        site_credentials=pulumi.get(__ret__, 'site_credentials'),
        storage_account_access_key=pulumi.get(__ret__, 'storage_account_access_key'),
        storage_account_name=pulumi.get(__ret__, 'storage_account_name'),
        storage_account_share_name=pulumi.get(__ret__, 'storage_account_share_name'),
        tags=pulumi.get(__ret__, 'tags'),
        use_extension_bundle=pulumi.get(__ret__, 'use_extension_bundle'),
        version=pulumi.get(__ret__, 'version'),
        virtual_network_subnet_id=pulumi.get(__ret__, 'virtual_network_subnet_id'))
def get_standard_output(name: Optional[pulumi.Input[str]] = None,
                        resource_group_name: Optional[pulumi.Input[str]] = None,
                        site_config: Optional[pulumi.Input[Optional[Union['GetStandardSiteConfigArgs', 'GetStandardSiteConfigArgsDict']]]] = None,
                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStandardResult]:
    """
    Use this data source to access information about an existing Logic App Standard instance.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_azure as azure

    example = azure.logicapps.get_standard(name="logicappstd",
        resource_group_name="example-rg")
    pulumi.export("id", example.id)
    ```


    :param str name: The name of this Logic App.
    :param str resource_group_name: The name of the Resource Group where the Logic App exists.
    :param Union['GetStandardSiteConfigArgs', 'GetStandardSiteConfigArgsDict'] site_config: A `site_config` object as defined below.
    """
    __args__ = dict()
    __args__['name'] = name
    __args__['resourceGroupName'] = resource_group_name
    __args__['siteConfig'] = site_config
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('azure:logicapps/getStandard:getStandard', __args__, opts=opts, typ=GetStandardResult)
    return __ret__.apply(lambda __response__: GetStandardResult(
        app_service_plan_id=pulumi.get(__response__, 'app_service_plan_id'),
        app_settings=pulumi.get(__response__, 'app_settings'),
        bundle_version=pulumi.get(__response__, 'bundle_version'),
        client_affinity_enabled=pulumi.get(__response__, 'client_affinity_enabled'),
        client_certificate_mode=pulumi.get(__response__, 'client_certificate_mode'),
        connection_strings=pulumi.get(__response__, 'connection_strings'),
        custom_domain_verification_id=pulumi.get(__response__, 'custom_domain_verification_id'),
        default_hostname=pulumi.get(__response__, 'default_hostname'),
        enabled=pulumi.get(__response__, 'enabled'),
        https_only=pulumi.get(__response__, 'https_only'),
        id=pulumi.get(__response__, 'id'),
        identities=pulumi.get(__response__, 'identities'),
        kind=pulumi.get(__response__, 'kind'),
        location=pulumi.get(__response__, 'location'),
        name=pulumi.get(__response__, 'name'),
        outbound_ip_addresses=pulumi.get(__response__, 'outbound_ip_addresses'),
        possible_outbound_ip_addresses=pulumi.get(__response__, 'possible_outbound_ip_addresses'),
        public_network_access=pulumi.get(__response__, 'public_network_access'),
        resource_group_name=pulumi.get(__response__, 'resource_group_name'),
        site_config=pulumi.get(__response__, 'site_config'),
        site_credentials=pulumi.get(__response__, 'site_credentials'),
        storage_account_access_key=pulumi.get(__response__, 'storage_account_access_key'),
        storage_account_name=pulumi.get(__response__, 'storage_account_name'),
        storage_account_share_name=pulumi.get(__response__, 'storage_account_share_name'),
        tags=pulumi.get(__response__, 'tags'),
        use_extension_bundle=pulumi.get(__response__, 'use_extension_bundle'),
        version=pulumi.get(__response__, 'version'),
        virtual_network_subnet_id=pulumi.get(__response__, 'virtual_network_subnet_id')))
