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

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._enums import *

__all__ = [
    'BackgroundWorkerDetailsOutput',
    'BackgroundWorkerOutput',
    'BuildFilter',
    'CommitProperties',
    'CriteriaProperties',
    'CriteriaPropertiesCpuProperties',
    'CronJobDetailsOutput',
    'CronJobOutput',
    'CustomDomain',
    'CustomDomainServerProperties',
    'CustomDomainWithCursor',
    'Deploy',
    'DeployCommitProperties',
    'DeployImageProperties',
    'EnvSpecificDetails',
    'EnvVar',
    'EnvVarInput',
    'EnvVarWithCursor',
    'Header',
    'HeaderWithCursor',
    'Image',
    'ImageProperties',
    'ListDeploysItemProperties',
    'ListJobItemProperties',
    'ListServicesResponse',
    'PrivateServiceDetailsOutput',
    'PrivateServiceOutput',
    'RegistryCredential',
    'RegistryCredentialSummary',
    'Resource',
    'Route',
    'RouteWithCursor',
    'SecretFile',
    'SecretFileInput',
    'SecretFileWithCursor',
    'ServerPort',
    'Service',
    'StaticSiteDetailsOutput',
    'StaticSiteOutput',
    'WebServiceDetailsOutput',
    'WebServiceDetailsOutputAutoscalingProperties',
    'WebServiceDetailsOutputAutoscalingPropertiesCriteriaProperties',
    'WebServiceDetailsOutputAutoscalingPropertiesCriteriaPropertiesCpuProperties',
    'WebServiceDetailsOutputDiskProperties',
    'WebServiceDetailspropertiesautoscaling',
    'WebServiceDetailspropertiesautoscalingCriteriaProperties',
    'WebServiceDetailspropertiesautoscalingCriteriaPropertiesCpuProperties',
    'WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu',
    'WebServiceDetailspropertiesdisk',
    'WebServiceOutput',
    'Paths1services17BserviceId7D1jobscreateresponses200contentapplication1jsonschema',
]

@pulumi.output_type
class BackgroundWorkerDetailsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildPlan":
            suggest = "build_plan"
        elif key == "envSpecificDetails":
            suggest = "env_specific_details"
        elif key == "numInstances":
            suggest = "num_instances"
        elif key == "maxShutdownDelaySeconds":
            suggest = "max_shutdown_delay_seconds"
        elif key == "parentServer":
            suggest = "parent_server"
        elif key == "pullRequestPreviewsEnabled":
            suggest = "pull_request_previews_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BackgroundWorkerDetailsOutput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BackgroundWorkerDetailsOutput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BackgroundWorkerDetailsOutput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 build_plan: Optional['BackgroundWorkerDetailsOutputBuildPlan'] = None,
                 env: 'BackgroundWorkerDetailsOutputEnv',
                 env_specific_details: 'outputs.EnvSpecificDetails',
                 num_instances: int,
                 plan: 'BackgroundWorkerDetailsOutputPlan',
                 region: Optional['BackgroundWorkerDetailsOutputRegion'] = None,
                 autoscaling: Optional['outputs.WebServiceDetailspropertiesautoscaling'] = None,
                 disk: Optional['outputs.WebServiceDetailspropertiesdisk'] = None,
                 max_shutdown_delay_seconds: Optional[int] = None,
                 parent_server: Optional['outputs.Resource'] = None,
                 pull_request_previews_enabled: Optional['BackgroundWorkerDetailsOutputPullRequestPreviewsEnabled'] = None):
        """
        :param 'BackgroundWorkerDetailsOutputEnv' env: Runtime
        :param int num_instances: For a *manually* scaled service, this is the number of instances the service is scaled to. DOES NOT indicate the number of running instances for an *autoscaled* service.
        :param 'BackgroundWorkerDetailsOutputPlan' plan: The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        :param 'BackgroundWorkerDetailsOutputRegion' region: Defaults to "oregon"
        :param int max_shutdown_delay_seconds: The maximum amount of time (in seconds) that Render waits for your application process to exit gracefully after sending it a SIGTERM signal.
        :param 'BackgroundWorkerDetailsOutputPullRequestPreviewsEnabled' pull_request_previews_enabled: Defaults to "no"
        """
        if build_plan is None:
            build_plan = 'starter'
        pulumi.set(__self__, "build_plan", build_plan)
        pulumi.set(__self__, "env", env)
        pulumi.set(__self__, "env_specific_details", env_specific_details)
        pulumi.set(__self__, "num_instances", num_instances)
        pulumi.set(__self__, "plan", plan)
        if region is None:
            region = 'oregon'
        pulumi.set(__self__, "region", region)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if max_shutdown_delay_seconds is None:
            max_shutdown_delay_seconds = 30
        if max_shutdown_delay_seconds is not None:
            pulumi.set(__self__, "max_shutdown_delay_seconds", max_shutdown_delay_seconds)
        if parent_server is not None:
            pulumi.set(__self__, "parent_server", parent_server)
        if pull_request_previews_enabled is None:
            pull_request_previews_enabled = 'no'
        if pull_request_previews_enabled is not None:
            pulumi.set(__self__, "pull_request_previews_enabled", pull_request_previews_enabled)

    @property
    @pulumi.getter(name="buildPlan")
    def build_plan(self) -> 'BackgroundWorkerDetailsOutputBuildPlan':
        return pulumi.get(self, "build_plan")

    @property
    @pulumi.getter
    def env(self) -> 'BackgroundWorkerDetailsOutputEnv':
        """
        Runtime
        """
        return pulumi.get(self, "env")

    @property
    @pulumi.getter(name="envSpecificDetails")
    def env_specific_details(self) -> 'outputs.EnvSpecificDetails':
        return pulumi.get(self, "env_specific_details")

    @property
    @pulumi.getter(name="numInstances")
    def num_instances(self) -> int:
        """
        For a *manually* scaled service, this is the number of instances the service is scaled to. DOES NOT indicate the number of running instances for an *autoscaled* service.
        """
        return pulumi.get(self, "num_instances")

    @property
    @pulumi.getter
    def plan(self) -> 'BackgroundWorkerDetailsOutputPlan':
        """
        The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        """
        return pulumi.get(self, "plan")

    @property
    @pulumi.getter
    def region(self) -> 'BackgroundWorkerDetailsOutputRegion':
        """
        Defaults to "oregon"
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional['outputs.WebServiceDetailspropertiesautoscaling']:
        return pulumi.get(self, "autoscaling")

    @property
    @pulumi.getter
    def disk(self) -> Optional['outputs.WebServiceDetailspropertiesdisk']:
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="maxShutdownDelaySeconds")
    def max_shutdown_delay_seconds(self) -> Optional[int]:
        """
        The maximum amount of time (in seconds) that Render waits for your application process to exit gracefully after sending it a SIGTERM signal.
        """
        return pulumi.get(self, "max_shutdown_delay_seconds")

    @property
    @pulumi.getter(name="parentServer")
    def parent_server(self) -> Optional['outputs.Resource']:
        return pulumi.get(self, "parent_server")

    @property
    @pulumi.getter(name="pullRequestPreviewsEnabled")
    def pull_request_previews_enabled(self) -> Optional['BackgroundWorkerDetailsOutputPullRequestPreviewsEnabled']:
        """
        Defaults to "no"
        """
        return pulumi.get(self, "pull_request_previews_enabled")


@pulumi.output_type
class BackgroundWorkerOutput(dict):
    def __init__(__self__, *,
                 auto_deploy: Optional['ServiceAutoDeploy'] = None,
                 created_at: str,
                 dashboard_url: str,
                 id: str,
                 name: str,
                 notify_on_fail: 'ServiceNotifyOnFail',
                 owner_id: str,
                 root_dir: str,
                 slug: str,
                 suspended: 'ServiceSuspended',
                 suspenders: Sequence['ServiceSuspendersItem'],
                 updated_at: str,
                 branch: Optional[str] = None,
                 build_filter: Optional['outputs.BuildFilter'] = None,
                 environment_id: Optional[str] = None,
                 image_path: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredentialSummary'] = None,
                 repo: Optional[str] = None,
                 service_details: Optional['outputs.BackgroundWorkerDetailsOutput'] = None,
                 type: Optional[str] = None):
        """
        :param str dashboard_url: The URL to view the service in the Render Dashboard
        """
        if auto_deploy is None:
            auto_deploy = 'yes'
        pulumi.set(__self__, "auto_deploy", auto_deploy)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "dashboard_url", dashboard_url)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notify_on_fail", notify_on_fail)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "root_dir", root_dir)
        pulumi.set(__self__, "slug", slug)
        pulumi.set(__self__, "suspended", suspended)
        pulumi.set(__self__, "suspenders", suspenders)
        pulumi.set(__self__, "updated_at", updated_at)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if build_filter is not None:
            pulumi.set(__self__, "build_filter", build_filter)
        if environment_id is not None:
            pulumi.set(__self__, "environment_id", environment_id)
        if image_path is not None:
            pulumi.set(__self__, "image_path", image_path)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if repo is not None:
            pulumi.set(__self__, "repo", repo)
        if service_details is not None:
            pulumi.set(__self__, "service_details", service_details)
        if type is None:
            type = 'background_worker'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDeploy")
    def auto_deploy(self) -> 'ServiceAutoDeploy':
        return pulumi.get(self, "auto_deploy")

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

    @property
    @pulumi.getter(name="dashboardUrl")
    def dashboard_url(self) -> str:
        """
        The URL to view the service in the Render Dashboard
        """
        return pulumi.get(self, "dashboard_url")

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

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

    @property
    @pulumi.getter(name="notifyOnFail")
    def notify_on_fail(self) -> 'ServiceNotifyOnFail':
        return pulumi.get(self, "notify_on_fail")

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

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

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

    @property
    @pulumi.getter
    def suspended(self) -> 'ServiceSuspended':
        return pulumi.get(self, "suspended")

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

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

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

    @property
    @pulumi.getter(name="buildFilter")
    def build_filter(self) -> Optional['outputs.BuildFilter']:
        return pulumi.get(self, "build_filter")

    @property
    @pulumi.getter(name="environmentId")
    def environment_id(self) -> Optional[str]:
        return pulumi.get(self, "environment_id")

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> Optional[str]:
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredentialSummary']:
        return pulumi.get(self, "registry_credential")

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

    @property
    @pulumi.getter(name="serviceDetails")
    def service_details(self) -> Optional['outputs.BackgroundWorkerDetailsOutput']:
        return pulumi.get(self, "service_details")

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


@pulumi.output_type
class BuildFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ignoredPaths":
            suggest = "ignored_paths"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BuildFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BuildFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BuildFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ignored_paths: Sequence[str],
                 paths: Sequence[str]):
        pulumi.set(__self__, "ignored_paths", ignored_paths)
        pulumi.set(__self__, "paths", paths)

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

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


@pulumi.output_type
class CommitProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createdAt":
            suggest = "created_at"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CommitProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CommitProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CommitProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 created_at: Optional[str] = None,
                 id: Optional[str] = None,
                 message: Optional[str] = None):
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if message is not None:
            pulumi.set(__self__, "message", message)

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[str]:
        return pulumi.get(self, "created_at")

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

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


@pulumi.output_type
class CriteriaProperties(dict):
    def __init__(__self__, *,
                 cpu: 'outputs.CriteriaPropertiesCpuProperties',
                 memory: 'outputs.WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu'):
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> 'outputs.CriteriaPropertiesCpuProperties':
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> 'outputs.WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu':
        return pulumi.get(self, "memory")


@pulumi.output_type
class CriteriaPropertiesCpuProperties(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 percentage: int):
        """
        :param int percentage: Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        if enabled is None:
            enabled = False
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "percentage", percentage)

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

    @property
    @pulumi.getter
    def percentage(self) -> int:
        """
        Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class CronJobDetailsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildPlan":
            suggest = "build_plan"
        elif key == "envSpecificDetails":
            suggest = "env_specific_details"
        elif key == "lastSuccessfulRunAt":
            suggest = "last_successful_run_at"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CronJobDetailsOutput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CronJobDetailsOutput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CronJobDetailsOutput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 build_plan: Optional['CronJobDetailsOutputBuildPlan'] = None,
                 env: 'CronJobDetailsOutputEnv',
                 env_specific_details: 'outputs.EnvSpecificDetails',
                 plan: 'CronJobDetailsOutputPlan',
                 region: Optional['CronJobDetailsOutputRegion'] = None,
                 schedule: str,
                 last_successful_run_at: Optional[str] = None):
        """
        :param 'CronJobDetailsOutputEnv' env: Runtime
        :param 'CronJobDetailsOutputPlan' plan: The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        :param 'CronJobDetailsOutputRegion' region: Defaults to "oregon"
        """
        if build_plan is None:
            build_plan = 'starter'
        pulumi.set(__self__, "build_plan", build_plan)
        pulumi.set(__self__, "env", env)
        pulumi.set(__self__, "env_specific_details", env_specific_details)
        pulumi.set(__self__, "plan", plan)
        if region is None:
            region = 'oregon'
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "schedule", schedule)
        if last_successful_run_at is not None:
            pulumi.set(__self__, "last_successful_run_at", last_successful_run_at)

    @property
    @pulumi.getter(name="buildPlan")
    def build_plan(self) -> 'CronJobDetailsOutputBuildPlan':
        return pulumi.get(self, "build_plan")

    @property
    @pulumi.getter
    def env(self) -> 'CronJobDetailsOutputEnv':
        """
        Runtime
        """
        return pulumi.get(self, "env")

    @property
    @pulumi.getter(name="envSpecificDetails")
    def env_specific_details(self) -> 'outputs.EnvSpecificDetails':
        return pulumi.get(self, "env_specific_details")

    @property
    @pulumi.getter
    def plan(self) -> 'CronJobDetailsOutputPlan':
        """
        The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        """
        return pulumi.get(self, "plan")

    @property
    @pulumi.getter
    def region(self) -> 'CronJobDetailsOutputRegion':
        """
        Defaults to "oregon"
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="lastSuccessfulRunAt")
    def last_successful_run_at(self) -> Optional[str]:
        return pulumi.get(self, "last_successful_run_at")


@pulumi.output_type
class CronJobOutput(dict):
    def __init__(__self__, *,
                 auto_deploy: Optional['ServiceAutoDeploy'] = None,
                 created_at: str,
                 dashboard_url: str,
                 id: str,
                 name: str,
                 notify_on_fail: 'ServiceNotifyOnFail',
                 owner_id: str,
                 root_dir: str,
                 slug: str,
                 suspended: 'ServiceSuspended',
                 suspenders: Sequence['ServiceSuspendersItem'],
                 updated_at: str,
                 branch: Optional[str] = None,
                 build_filter: Optional['outputs.BuildFilter'] = None,
                 environment_id: Optional[str] = None,
                 image_path: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredentialSummary'] = None,
                 repo: Optional[str] = None,
                 service_details: Optional['outputs.CronJobDetailsOutput'] = None,
                 type: Optional[str] = None):
        """
        :param str dashboard_url: The URL to view the service in the Render Dashboard
        """
        if auto_deploy is None:
            auto_deploy = 'yes'
        pulumi.set(__self__, "auto_deploy", auto_deploy)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "dashboard_url", dashboard_url)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notify_on_fail", notify_on_fail)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "root_dir", root_dir)
        pulumi.set(__self__, "slug", slug)
        pulumi.set(__self__, "suspended", suspended)
        pulumi.set(__self__, "suspenders", suspenders)
        pulumi.set(__self__, "updated_at", updated_at)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if build_filter is not None:
            pulumi.set(__self__, "build_filter", build_filter)
        if environment_id is not None:
            pulumi.set(__self__, "environment_id", environment_id)
        if image_path is not None:
            pulumi.set(__self__, "image_path", image_path)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if repo is not None:
            pulumi.set(__self__, "repo", repo)
        if service_details is not None:
            pulumi.set(__self__, "service_details", service_details)
        if type is None:
            type = 'cron_job'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDeploy")
    def auto_deploy(self) -> 'ServiceAutoDeploy':
        return pulumi.get(self, "auto_deploy")

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

    @property
    @pulumi.getter(name="dashboardUrl")
    def dashboard_url(self) -> str:
        """
        The URL to view the service in the Render Dashboard
        """
        return pulumi.get(self, "dashboard_url")

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

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

    @property
    @pulumi.getter(name="notifyOnFail")
    def notify_on_fail(self) -> 'ServiceNotifyOnFail':
        return pulumi.get(self, "notify_on_fail")

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

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

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

    @property
    @pulumi.getter
    def suspended(self) -> 'ServiceSuspended':
        return pulumi.get(self, "suspended")

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

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

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

    @property
    @pulumi.getter(name="buildFilter")
    def build_filter(self) -> Optional['outputs.BuildFilter']:
        return pulumi.get(self, "build_filter")

    @property
    @pulumi.getter(name="environmentId")
    def environment_id(self) -> Optional[str]:
        return pulumi.get(self, "environment_id")

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> Optional[str]:
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredentialSummary']:
        return pulumi.get(self, "registry_credential")

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

    @property
    @pulumi.getter(name="serviceDetails")
    def service_details(self) -> Optional['outputs.CronJobDetailsOutput']:
        return pulumi.get(self, "service_details")

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


@pulumi.output_type
class CustomDomain(dict):
    def __init__(__self__, *,
                 created_at: str,
                 domain_type: 'CustomDomainDomainType',
                 id: str,
                 name: str,
                 public_suffix: str,
                 redirect_for_name: str,
                 verification_status: 'CustomDomainVerificationStatus',
                 server: Optional['outputs.CustomDomainServerProperties'] = None):
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "domain_type", domain_type)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_suffix", public_suffix)
        pulumi.set(__self__, "redirect_for_name", redirect_for_name)
        pulumi.set(__self__, "verification_status", verification_status)
        if server is not None:
            pulumi.set(__self__, "server", server)

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

    @property
    @pulumi.getter(name="domainType")
    def domain_type(self) -> 'CustomDomainDomainType':
        return pulumi.get(self, "domain_type")

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

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

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

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

    @property
    @pulumi.getter(name="verificationStatus")
    def verification_status(self) -> 'CustomDomainVerificationStatus':
        return pulumi.get(self, "verification_status")

    @property
    @pulumi.getter
    def server(self) -> Optional['outputs.CustomDomainServerProperties']:
        return pulumi.get(self, "server")


@pulumi.output_type
class CustomDomainServerProperties(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 name: Optional[str] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class CustomDomainWithCursor(dict):
    def __init__(__self__, *,
                 cursor: str,
                 custom_domain: 'outputs.CustomDomain'):
        pulumi.set(__self__, "cursor", cursor)
        pulumi.set(__self__, "custom_domain", custom_domain)

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

    @property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> 'outputs.CustomDomain':
        return pulumi.get(self, "custom_domain")


@pulumi.output_type
class Deploy(dict):
    def __init__(__self__, *,
                 id: str,
                 commit: Optional['outputs.DeployCommitProperties'] = None,
                 created_at: Optional[str] = None,
                 finished_at: Optional[str] = None,
                 image: Optional['outputs.DeployImageProperties'] = None,
                 status: Optional['DeployStatus'] = None,
                 trigger: Optional['DeployTrigger'] = None,
                 updated_at: Optional[str] = None):
        """
        :param 'DeployImageProperties' image: Image information used when creating the deploy. Not present for Git-backed deploys
        """
        pulumi.set(__self__, "id", id)
        if commit is not None:
            pulumi.set(__self__, "commit", commit)
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if finished_at is not None:
            pulumi.set(__self__, "finished_at", finished_at)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if trigger is not None:
            pulumi.set(__self__, "trigger", trigger)
        if updated_at is not None:
            pulumi.set(__self__, "updated_at", updated_at)

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

    @property
    @pulumi.getter
    def commit(self) -> Optional['outputs.DeployCommitProperties']:
        return pulumi.get(self, "commit")

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[str]:
        return pulumi.get(self, "created_at")

    @property
    @pulumi.getter(name="finishedAt")
    def finished_at(self) -> Optional[str]:
        return pulumi.get(self, "finished_at")

    @property
    @pulumi.getter
    def image(self) -> Optional['outputs.DeployImageProperties']:
        """
        Image information used when creating the deploy. Not present for Git-backed deploys
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def status(self) -> Optional['DeployStatus']:
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def trigger(self) -> Optional['DeployTrigger']:
        return pulumi.get(self, "trigger")

    @property
    @pulumi.getter(name="updatedAt")
    def updated_at(self) -> Optional[str]:
        return pulumi.get(self, "updated_at")


@pulumi.output_type
class DeployCommitProperties(dict):
    def __init__(__self__, *,
                 created_at: Optional[str] = None,
                 id: Optional[str] = None,
                 message: Optional[str] = None):
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if message is not None:
            pulumi.set(__self__, "message", message)

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[str]:
        return pulumi.get(self, "created_at")

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

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


@pulumi.output_type
class DeployImageProperties(dict):
    """
    Image information used when creating the deploy. Not present for Git-backed deploys
    """
    def __init__(__self__, *,
                 ref: Optional[str] = None,
                 registry_credential: Optional[str] = None,
                 sha: Optional[str] = None):
        """
        Image information used when creating the deploy. Not present for Git-backed deploys
        :param str ref: Image reference used when creating the deploy
        :param str registry_credential: Name of credential used to pull the image, if provided
        :param str sha: SHA that the image reference was resolved to when creating the deploy
        """
        if ref is not None:
            pulumi.set(__self__, "ref", ref)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if sha is not None:
            pulumi.set(__self__, "sha", sha)

    @property
    @pulumi.getter
    def ref(self) -> Optional[str]:
        """
        Image reference used when creating the deploy
        """
        return pulumi.get(self, "ref")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional[str]:
        """
        Name of credential used to pull the image, if provided
        """
        return pulumi.get(self, "registry_credential")

    @property
    @pulumi.getter
    def sha(self) -> Optional[str]:
        """
        SHA that the image reference was resolved to when creating the deploy
        """
        return pulumi.get(self, "sha")


@pulumi.output_type
class EnvSpecificDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildCommand":
            suggest = "build_command"
        elif key == "dockerCommand":
            suggest = "docker_command"
        elif key == "dockerContext":
            suggest = "docker_context"
        elif key == "dockerfilePath":
            suggest = "dockerfile_path"
        elif key == "preDeployCommand":
            suggest = "pre_deploy_command"
        elif key == "registryCredential":
            suggest = "registry_credential"
        elif key == "startCommand":
            suggest = "start_command"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvSpecificDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvSpecificDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvSpecificDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 build_command: Optional[str] = None,
                 docker_command: Optional[str] = None,
                 docker_context: Optional[str] = None,
                 dockerfile_path: Optional[str] = None,
                 pre_deploy_command: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredential'] = None,
                 start_command: Optional[str] = None):
        if build_command is not None:
            pulumi.set(__self__, "build_command", build_command)
        if docker_command is not None:
            pulumi.set(__self__, "docker_command", docker_command)
        if docker_context is not None:
            pulumi.set(__self__, "docker_context", docker_context)
        if dockerfile_path is not None:
            pulumi.set(__self__, "dockerfile_path", dockerfile_path)
        if pre_deploy_command is not None:
            pulumi.set(__self__, "pre_deploy_command", pre_deploy_command)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if start_command is not None:
            pulumi.set(__self__, "start_command", start_command)

    @property
    @pulumi.getter(name="buildCommand")
    def build_command(self) -> Optional[str]:
        return pulumi.get(self, "build_command")

    @property
    @pulumi.getter(name="dockerCommand")
    def docker_command(self) -> Optional[str]:
        return pulumi.get(self, "docker_command")

    @property
    @pulumi.getter(name="dockerContext")
    def docker_context(self) -> Optional[str]:
        return pulumi.get(self, "docker_context")

    @property
    @pulumi.getter(name="dockerfilePath")
    def dockerfile_path(self) -> Optional[str]:
        return pulumi.get(self, "dockerfile_path")

    @property
    @pulumi.getter(name="preDeployCommand")
    def pre_deploy_command(self) -> Optional[str]:
        return pulumi.get(self, "pre_deploy_command")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredential']:
        return pulumi.get(self, "registry_credential")

    @property
    @pulumi.getter(name="startCommand")
    def start_command(self) -> Optional[str]:
        return pulumi.get(self, "start_command")


@pulumi.output_type
class EnvVar(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class EnvVarInput(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class EnvVarWithCursor(dict):
    def __init__(__self__, *,
                 cursor: str,
                 env_var: 'outputs.EnvVar'):
        pulumi.set(__self__, "cursor", cursor)
        pulumi.set(__self__, "env_var", env_var)

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

    @property
    @pulumi.getter(name="envVar")
    def env_var(self) -> 'outputs.EnvVar':
        return pulumi.get(self, "env_var")


@pulumi.output_type
class Header(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 path: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.output_type
class HeaderWithCursor(dict):
    def __init__(__self__, *,
                 cursor: str,
                 header: 'outputs.Header'):
        pulumi.set(__self__, "cursor", cursor)
        pulumi.set(__self__, "header", header)

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

    @property
    @pulumi.getter
    def header(self) -> 'outputs.Header':
        return pulumi.get(self, "header")


@pulumi.output_type
class Image(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imagePath":
            suggest = "image_path"
        elif key == "ownerId":
            suggest = "owner_id"
        elif key == "registryCredentialId":
            suggest = "registry_credential_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in Image. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        Image.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        Image.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 image_path: str,
                 owner_id: str,
                 registry_credential_id: Optional[str] = None):
        """
        :param str image_path: Path to the image used for this server (e.g docker.io/library/nginx:latest).
        :param str owner_id: The ID of the owner for this image. This should match the owner of the service as well as the owner of any specified registry credential.
        :param str registry_credential_id: Optional reference to the registry credential passed to the image repository to retrieve this image.
        """
        pulumi.set(__self__, "image_path", image_path)
        pulumi.set(__self__, "owner_id", owner_id)
        if registry_credential_id is not None:
            pulumi.set(__self__, "registry_credential_id", registry_credential_id)

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> str:
        """
        Path to the image used for this server (e.g docker.io/library/nginx:latest).
        """
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="ownerId")
    def owner_id(self) -> str:
        """
        The ID of the owner for this image. This should match the owner of the service as well as the owner of any specified registry credential.
        """
        return pulumi.get(self, "owner_id")

    @property
    @pulumi.getter(name="registryCredentialId")
    def registry_credential_id(self) -> Optional[str]:
        """
        Optional reference to the registry credential passed to the image repository to retrieve this image.
        """
        return pulumi.get(self, "registry_credential_id")


@pulumi.output_type
class ImageProperties(dict):
    """
    Image information used when creating the deploy. Not present for Git-backed deploys
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "registryCredential":
            suggest = "registry_credential"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ImageProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ImageProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ImageProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ref: Optional[str] = None,
                 registry_credential: Optional[str] = None,
                 sha: Optional[str] = None):
        """
        Image information used when creating the deploy. Not present for Git-backed deploys
        :param str ref: Image reference used when creating the deploy
        :param str registry_credential: Name of credential used to pull the image, if provided
        :param str sha: SHA that the image reference was resolved to when creating the deploy
        """
        if ref is not None:
            pulumi.set(__self__, "ref", ref)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if sha is not None:
            pulumi.set(__self__, "sha", sha)

    @property
    @pulumi.getter
    def ref(self) -> Optional[str]:
        """
        Image reference used when creating the deploy
        """
        return pulumi.get(self, "ref")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional[str]:
        """
        Name of credential used to pull the image, if provided
        """
        return pulumi.get(self, "registry_credential")

    @property
    @pulumi.getter
    def sha(self) -> Optional[str]:
        """
        SHA that the image reference was resolved to when creating the deploy
        """
        return pulumi.get(self, "sha")


@pulumi.output_type
class ListDeploysItemProperties(dict):
    def __init__(__self__, *,
                 cursor: Optional[str] = None,
                 deploy: Optional['outputs.Deploy'] = None):
        if cursor is not None:
            pulumi.set(__self__, "cursor", cursor)
        if deploy is not None:
            pulumi.set(__self__, "deploy", deploy)

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

    @property
    @pulumi.getter
    def deploy(self) -> Optional['outputs.Deploy']:
        return pulumi.get(self, "deploy")


@pulumi.output_type
class ListJobItemProperties(dict):
    def __init__(__self__, *,
                 cursor: Optional[str] = None,
                 job: Optional['outputs.Paths1services17BserviceId7D1jobscreateresponses200contentapplication1jsonschema'] = None):
        if cursor is not None:
            pulumi.set(__self__, "cursor", cursor)
        if job is not None:
            pulumi.set(__self__, "job", job)

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

    @property
    @pulumi.getter
    def job(self) -> Optional['outputs.Paths1services17BserviceId7D1jobscreateresponses200contentapplication1jsonschema']:
        return pulumi.get(self, "job")


@pulumi.output_type
class ListServicesResponse(dict):
    def __init__(__self__, *,
                 cursor: Optional[str] = None,
                 service: Optional[Any] = None):
        if cursor is not None:
            pulumi.set(__self__, "cursor", cursor)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

    @property
    @pulumi.getter
    def service(self) -> Optional[Any]:
        return pulumi.get(self, "service")


@pulumi.output_type
class PrivateServiceDetailsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildPlan":
            suggest = "build_plan"
        elif key == "envSpecificDetails":
            suggest = "env_specific_details"
        elif key == "numInstances":
            suggest = "num_instances"
        elif key == "openPorts":
            suggest = "open_ports"
        elif key == "maxShutdownDelaySeconds":
            suggest = "max_shutdown_delay_seconds"
        elif key == "parentServer":
            suggest = "parent_server"
        elif key == "pullRequestPreviewsEnabled":
            suggest = "pull_request_previews_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateServiceDetailsOutput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateServiceDetailsOutput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateServiceDetailsOutput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 build_plan: Optional['PrivateServiceDetailsOutputBuildPlan'] = None,
                 env: 'PrivateServiceDetailsOutputEnv',
                 env_specific_details: 'outputs.EnvSpecificDetails',
                 num_instances: int,
                 open_ports: Sequence['outputs.ServerPort'],
                 plan: 'PrivateServiceDetailsOutputPlan',
                 region: Optional['PrivateServiceDetailsOutputRegion'] = None,
                 url: str,
                 autoscaling: Optional['outputs.WebServiceDetailspropertiesautoscaling'] = None,
                 disk: Optional['outputs.WebServiceDetailspropertiesdisk'] = None,
                 max_shutdown_delay_seconds: Optional[int] = None,
                 parent_server: Optional['outputs.Resource'] = None,
                 pull_request_previews_enabled: Optional['PrivateServiceDetailsOutputPullRequestPreviewsEnabled'] = None):
        """
        :param 'PrivateServiceDetailsOutputEnv' env: Runtime
        :param int num_instances: For a *manually* scaled service, this is the number of instances the service is scaled to. DOES NOT indicate the number of running instances for an *autoscaled* service.
        :param 'PrivateServiceDetailsOutputPlan' plan: The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        :param 'PrivateServiceDetailsOutputRegion' region: Defaults to "oregon"
        :param int max_shutdown_delay_seconds: The maximum amount of time (in seconds) that Render waits for your application process to exit gracefully after sending it a SIGTERM signal.
        :param 'PrivateServiceDetailsOutputPullRequestPreviewsEnabled' pull_request_previews_enabled: Defaults to "no"
        """
        if build_plan is None:
            build_plan = 'starter'
        pulumi.set(__self__, "build_plan", build_plan)
        pulumi.set(__self__, "env", env)
        pulumi.set(__self__, "env_specific_details", env_specific_details)
        pulumi.set(__self__, "num_instances", num_instances)
        pulumi.set(__self__, "open_ports", open_ports)
        pulumi.set(__self__, "plan", plan)
        if region is None:
            region = 'oregon'
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "url", url)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if max_shutdown_delay_seconds is None:
            max_shutdown_delay_seconds = 30
        if max_shutdown_delay_seconds is not None:
            pulumi.set(__self__, "max_shutdown_delay_seconds", max_shutdown_delay_seconds)
        if parent_server is not None:
            pulumi.set(__self__, "parent_server", parent_server)
        if pull_request_previews_enabled is None:
            pull_request_previews_enabled = 'no'
        if pull_request_previews_enabled is not None:
            pulumi.set(__self__, "pull_request_previews_enabled", pull_request_previews_enabled)

    @property
    @pulumi.getter(name="buildPlan")
    def build_plan(self) -> 'PrivateServiceDetailsOutputBuildPlan':
        return pulumi.get(self, "build_plan")

    @property
    @pulumi.getter
    def env(self) -> 'PrivateServiceDetailsOutputEnv':
        """
        Runtime
        """
        return pulumi.get(self, "env")

    @property
    @pulumi.getter(name="envSpecificDetails")
    def env_specific_details(self) -> 'outputs.EnvSpecificDetails':
        return pulumi.get(self, "env_specific_details")

    @property
    @pulumi.getter(name="numInstances")
    def num_instances(self) -> int:
        """
        For a *manually* scaled service, this is the number of instances the service is scaled to. DOES NOT indicate the number of running instances for an *autoscaled* service.
        """
        return pulumi.get(self, "num_instances")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Sequence['outputs.ServerPort']:
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter
    def plan(self) -> 'PrivateServiceDetailsOutputPlan':
        """
        The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        """
        return pulumi.get(self, "plan")

    @property
    @pulumi.getter
    def region(self) -> 'PrivateServiceDetailsOutputRegion':
        """
        Defaults to "oregon"
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional['outputs.WebServiceDetailspropertiesautoscaling']:
        return pulumi.get(self, "autoscaling")

    @property
    @pulumi.getter
    def disk(self) -> Optional['outputs.WebServiceDetailspropertiesdisk']:
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="maxShutdownDelaySeconds")
    def max_shutdown_delay_seconds(self) -> Optional[int]:
        """
        The maximum amount of time (in seconds) that Render waits for your application process to exit gracefully after sending it a SIGTERM signal.
        """
        return pulumi.get(self, "max_shutdown_delay_seconds")

    @property
    @pulumi.getter(name="parentServer")
    def parent_server(self) -> Optional['outputs.Resource']:
        return pulumi.get(self, "parent_server")

    @property
    @pulumi.getter(name="pullRequestPreviewsEnabled")
    def pull_request_previews_enabled(self) -> Optional['PrivateServiceDetailsOutputPullRequestPreviewsEnabled']:
        """
        Defaults to "no"
        """
        return pulumi.get(self, "pull_request_previews_enabled")


@pulumi.output_type
class PrivateServiceOutput(dict):
    def __init__(__self__, *,
                 auto_deploy: Optional['ServiceAutoDeploy'] = None,
                 created_at: str,
                 dashboard_url: str,
                 id: str,
                 name: str,
                 notify_on_fail: 'ServiceNotifyOnFail',
                 owner_id: str,
                 root_dir: str,
                 slug: str,
                 suspended: 'ServiceSuspended',
                 suspenders: Sequence['ServiceSuspendersItem'],
                 updated_at: str,
                 branch: Optional[str] = None,
                 build_filter: Optional['outputs.BuildFilter'] = None,
                 environment_id: Optional[str] = None,
                 image_path: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredentialSummary'] = None,
                 repo: Optional[str] = None,
                 service_details: Optional['outputs.PrivateServiceDetailsOutput'] = None,
                 type: Optional[str] = None):
        """
        :param str dashboard_url: The URL to view the service in the Render Dashboard
        """
        if auto_deploy is None:
            auto_deploy = 'yes'
        pulumi.set(__self__, "auto_deploy", auto_deploy)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "dashboard_url", dashboard_url)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notify_on_fail", notify_on_fail)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "root_dir", root_dir)
        pulumi.set(__self__, "slug", slug)
        pulumi.set(__self__, "suspended", suspended)
        pulumi.set(__self__, "suspenders", suspenders)
        pulumi.set(__self__, "updated_at", updated_at)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if build_filter is not None:
            pulumi.set(__self__, "build_filter", build_filter)
        if environment_id is not None:
            pulumi.set(__self__, "environment_id", environment_id)
        if image_path is not None:
            pulumi.set(__self__, "image_path", image_path)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if repo is not None:
            pulumi.set(__self__, "repo", repo)
        if service_details is not None:
            pulumi.set(__self__, "service_details", service_details)
        if type is None:
            type = 'private_service'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDeploy")
    def auto_deploy(self) -> 'ServiceAutoDeploy':
        return pulumi.get(self, "auto_deploy")

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

    @property
    @pulumi.getter(name="dashboardUrl")
    def dashboard_url(self) -> str:
        """
        The URL to view the service in the Render Dashboard
        """
        return pulumi.get(self, "dashboard_url")

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

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

    @property
    @pulumi.getter(name="notifyOnFail")
    def notify_on_fail(self) -> 'ServiceNotifyOnFail':
        return pulumi.get(self, "notify_on_fail")

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

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

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

    @property
    @pulumi.getter
    def suspended(self) -> 'ServiceSuspended':
        return pulumi.get(self, "suspended")

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

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

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

    @property
    @pulumi.getter(name="buildFilter")
    def build_filter(self) -> Optional['outputs.BuildFilter']:
        return pulumi.get(self, "build_filter")

    @property
    @pulumi.getter(name="environmentId")
    def environment_id(self) -> Optional[str]:
        return pulumi.get(self, "environment_id")

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> Optional[str]:
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredentialSummary']:
        return pulumi.get(self, "registry_credential")

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

    @property
    @pulumi.getter(name="serviceDetails")
    def service_details(self) -> Optional['outputs.PrivateServiceDetailsOutput']:
        return pulumi.get(self, "service_details")

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


@pulumi.output_type
class RegistryCredential(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 registry: 'RegistryCredentialRegistry',
                 username: str):
        """
        :param str id: Unique identifier for this credential
        :param str name: Descriptive name for this credential
        :param 'RegistryCredentialRegistry' registry: The registry to use this credential with
        :param str username: The username associated with the credential
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "registry", registry)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier for this credential
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def registry(self) -> 'RegistryCredentialRegistry':
        """
        The registry to use this credential with
        """
        return pulumi.get(self, "registry")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username associated with the credential
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class RegistryCredentialSummary(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class Resource(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class Route(dict):
    def __init__(__self__, *,
                 destination: str,
                 id: str,
                 priority: int,
                 source: str,
                 type: 'RouteType'):
        """
        :param int priority: Redirect and Rewrite Rules are applied in priority order starting at 0
        """
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "source", source)
        pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        Redirect and Rewrite Rules are applied in priority order starting at 0
        """
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter
    def type(self) -> 'RouteType':
        return pulumi.get(self, "type")


@pulumi.output_type
class RouteWithCursor(dict):
    def __init__(__self__, *,
                 cursor: str,
                 route: 'outputs.Route'):
        pulumi.set(__self__, "cursor", cursor)
        pulumi.set(__self__, "route", route)

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

    @property
    @pulumi.getter
    def route(self) -> 'outputs.Route':
        return pulumi.get(self, "route")


@pulumi.output_type
class SecretFile(dict):
    def __init__(__self__, *,
                 content: str,
                 name: str):
        pulumi.set(__self__, "content", content)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class SecretFileInput(dict):
    def __init__(__self__, *,
                 content: str,
                 name: str):
        pulumi.set(__self__, "content", content)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class SecretFileWithCursor(dict):
    def __init__(__self__, *,
                 cursor: str,
                 secret_file: 'outputs.SecretFile'):
        pulumi.set(__self__, "cursor", cursor)
        pulumi.set(__self__, "secret_file", secret_file)

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

    @property
    @pulumi.getter(name="secretFile")
    def secret_file(self) -> 'outputs.SecretFile':
        return pulumi.get(self, "secret_file")


@pulumi.output_type
class ServerPort(dict):
    def __init__(__self__, *,
                 port: int,
                 protocol: 'ServerPortProtocol'):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

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

    @property
    @pulumi.getter
    def protocol(self) -> 'ServerPortProtocol':
        return pulumi.get(self, "protocol")


@pulumi.output_type
class Service(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoDeploy":
            suggest = "auto_deploy"
        elif key == "createdAt":
            suggest = "created_at"
        elif key == "dashboardUrl":
            suggest = "dashboard_url"
        elif key == "notifyOnFail":
            suggest = "notify_on_fail"
        elif key == "ownerId":
            suggest = "owner_id"
        elif key == "rootDir":
            suggest = "root_dir"
        elif key == "updatedAt":
            suggest = "updated_at"
        elif key == "buildFilter":
            suggest = "build_filter"
        elif key == "environmentId":
            suggest = "environment_id"
        elif key == "imagePath":
            suggest = "image_path"
        elif key == "registryCredential":
            suggest = "registry_credential"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in Service. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        Service.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        Service.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_deploy: Optional['ServiceAutoDeploy'] = None,
                 created_at: str,
                 dashboard_url: str,
                 id: str,
                 name: str,
                 notify_on_fail: 'ServiceNotifyOnFail',
                 owner_id: str,
                 root_dir: str,
                 slug: str,
                 suspended: 'ServiceSuspended',
                 suspenders: Sequence['ServiceSuspendersItem'],
                 updated_at: str,
                 branch: Optional[str] = None,
                 build_filter: Optional['outputs.BuildFilter'] = None,
                 environment_id: Optional[str] = None,
                 image_path: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredentialSummary'] = None,
                 repo: Optional[str] = None):
        """
        :param str dashboard_url: The URL to view the service in the Render Dashboard
        """
        if auto_deploy is None:
            auto_deploy = 'yes'
        pulumi.set(__self__, "auto_deploy", auto_deploy)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "dashboard_url", dashboard_url)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notify_on_fail", notify_on_fail)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "root_dir", root_dir)
        pulumi.set(__self__, "slug", slug)
        pulumi.set(__self__, "suspended", suspended)
        pulumi.set(__self__, "suspenders", suspenders)
        pulumi.set(__self__, "updated_at", updated_at)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if build_filter is not None:
            pulumi.set(__self__, "build_filter", build_filter)
        if environment_id is not None:
            pulumi.set(__self__, "environment_id", environment_id)
        if image_path is not None:
            pulumi.set(__self__, "image_path", image_path)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if repo is not None:
            pulumi.set(__self__, "repo", repo)

    @property
    @pulumi.getter(name="autoDeploy")
    def auto_deploy(self) -> 'ServiceAutoDeploy':
        return pulumi.get(self, "auto_deploy")

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

    @property
    @pulumi.getter(name="dashboardUrl")
    def dashboard_url(self) -> str:
        """
        The URL to view the service in the Render Dashboard
        """
        return pulumi.get(self, "dashboard_url")

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

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

    @property
    @pulumi.getter(name="notifyOnFail")
    def notify_on_fail(self) -> 'ServiceNotifyOnFail':
        return pulumi.get(self, "notify_on_fail")

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

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

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

    @property
    @pulumi.getter
    def suspended(self) -> 'ServiceSuspended':
        return pulumi.get(self, "suspended")

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

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

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

    @property
    @pulumi.getter(name="buildFilter")
    def build_filter(self) -> Optional['outputs.BuildFilter']:
        return pulumi.get(self, "build_filter")

    @property
    @pulumi.getter(name="environmentId")
    def environment_id(self) -> Optional[str]:
        return pulumi.get(self, "environment_id")

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> Optional[str]:
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredentialSummary']:
        return pulumi.get(self, "registry_credential")

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


@pulumi.output_type
class StaticSiteDetailsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildCommand":
            suggest = "build_command"
        elif key == "buildPlan":
            suggest = "build_plan"
        elif key == "publishPath":
            suggest = "publish_path"
        elif key == "parentServer":
            suggest = "parent_server"
        elif key == "pullRequestPreviewsEnabled":
            suggest = "pull_request_previews_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StaticSiteDetailsOutput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StaticSiteDetailsOutput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StaticSiteDetailsOutput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 build_command: str,
                 build_plan: Optional['StaticSiteDetailsOutputBuildPlan'] = None,
                 publish_path: str,
                 url: str,
                 parent_server: Optional['outputs.Resource'] = None,
                 pull_request_previews_enabled: Optional['StaticSiteDetailsOutputPullRequestPreviewsEnabled'] = None):
        """
        :param 'StaticSiteDetailsOutputPullRequestPreviewsEnabled' pull_request_previews_enabled: Defaults to "no"
        """
        pulumi.set(__self__, "build_command", build_command)
        if build_plan is None:
            build_plan = 'starter'
        pulumi.set(__self__, "build_plan", build_plan)
        pulumi.set(__self__, "publish_path", publish_path)
        pulumi.set(__self__, "url", url)
        if parent_server is not None:
            pulumi.set(__self__, "parent_server", parent_server)
        if pull_request_previews_enabled is None:
            pull_request_previews_enabled = 'no'
        if pull_request_previews_enabled is not None:
            pulumi.set(__self__, "pull_request_previews_enabled", pull_request_previews_enabled)

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

    @property
    @pulumi.getter(name="buildPlan")
    def build_plan(self) -> 'StaticSiteDetailsOutputBuildPlan':
        return pulumi.get(self, "build_plan")

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

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

    @property
    @pulumi.getter(name="parentServer")
    def parent_server(self) -> Optional['outputs.Resource']:
        return pulumi.get(self, "parent_server")

    @property
    @pulumi.getter(name="pullRequestPreviewsEnabled")
    def pull_request_previews_enabled(self) -> Optional['StaticSiteDetailsOutputPullRequestPreviewsEnabled']:
        """
        Defaults to "no"
        """
        return pulumi.get(self, "pull_request_previews_enabled")


@pulumi.output_type
class StaticSiteOutput(dict):
    def __init__(__self__, *,
                 auto_deploy: Optional['ServiceAutoDeploy'] = None,
                 created_at: str,
                 dashboard_url: str,
                 id: str,
                 name: str,
                 notify_on_fail: 'ServiceNotifyOnFail',
                 owner_id: str,
                 root_dir: str,
                 slug: str,
                 suspended: 'ServiceSuspended',
                 suspenders: Sequence['ServiceSuspendersItem'],
                 updated_at: str,
                 branch: Optional[str] = None,
                 build_filter: Optional['outputs.BuildFilter'] = None,
                 environment_id: Optional[str] = None,
                 image_path: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredentialSummary'] = None,
                 repo: Optional[str] = None,
                 service_details: Optional['outputs.StaticSiteDetailsOutput'] = None,
                 type: Optional[str] = None):
        """
        :param str dashboard_url: The URL to view the service in the Render Dashboard
        """
        if auto_deploy is None:
            auto_deploy = 'yes'
        pulumi.set(__self__, "auto_deploy", auto_deploy)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "dashboard_url", dashboard_url)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notify_on_fail", notify_on_fail)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "root_dir", root_dir)
        pulumi.set(__self__, "slug", slug)
        pulumi.set(__self__, "suspended", suspended)
        pulumi.set(__self__, "suspenders", suspenders)
        pulumi.set(__self__, "updated_at", updated_at)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if build_filter is not None:
            pulumi.set(__self__, "build_filter", build_filter)
        if environment_id is not None:
            pulumi.set(__self__, "environment_id", environment_id)
        if image_path is not None:
            pulumi.set(__self__, "image_path", image_path)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if repo is not None:
            pulumi.set(__self__, "repo", repo)
        if service_details is not None:
            pulumi.set(__self__, "service_details", service_details)
        if type is None:
            type = 'static_site'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDeploy")
    def auto_deploy(self) -> 'ServiceAutoDeploy':
        return pulumi.get(self, "auto_deploy")

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

    @property
    @pulumi.getter(name="dashboardUrl")
    def dashboard_url(self) -> str:
        """
        The URL to view the service in the Render Dashboard
        """
        return pulumi.get(self, "dashboard_url")

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

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

    @property
    @pulumi.getter(name="notifyOnFail")
    def notify_on_fail(self) -> 'ServiceNotifyOnFail':
        return pulumi.get(self, "notify_on_fail")

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

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

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

    @property
    @pulumi.getter
    def suspended(self) -> 'ServiceSuspended':
        return pulumi.get(self, "suspended")

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

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

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

    @property
    @pulumi.getter(name="buildFilter")
    def build_filter(self) -> Optional['outputs.BuildFilter']:
        return pulumi.get(self, "build_filter")

    @property
    @pulumi.getter(name="environmentId")
    def environment_id(self) -> Optional[str]:
        return pulumi.get(self, "environment_id")

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> Optional[str]:
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredentialSummary']:
        return pulumi.get(self, "registry_credential")

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

    @property
    @pulumi.getter(name="serviceDetails")
    def service_details(self) -> Optional['outputs.StaticSiteDetailsOutput']:
        return pulumi.get(self, "service_details")

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


@pulumi.output_type
class WebServiceDetailsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildPlan":
            suggest = "build_plan"
        elif key == "envSpecificDetails":
            suggest = "env_specific_details"
        elif key == "healthCheckPath":
            suggest = "health_check_path"
        elif key == "numInstances":
            suggest = "num_instances"
        elif key == "openPorts":
            suggest = "open_ports"
        elif key == "maxShutdownDelaySeconds":
            suggest = "max_shutdown_delay_seconds"
        elif key == "parentServer":
            suggest = "parent_server"
        elif key == "pullRequestPreviewsEnabled":
            suggest = "pull_request_previews_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WebServiceDetailsOutput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WebServiceDetailsOutput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WebServiceDetailsOutput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 build_plan: Optional['WebServiceDetailsOutputBuildPlan'] = None,
                 env: 'WebServiceDetailsOutputEnv',
                 env_specific_details: 'outputs.EnvSpecificDetails',
                 health_check_path: str,
                 num_instances: int,
                 open_ports: Sequence['outputs.ServerPort'],
                 plan: 'WebServiceDetailsOutputPlan',
                 region: Optional['WebServiceDetailsOutputRegion'] = None,
                 url: str,
                 autoscaling: Optional['outputs.WebServiceDetailsOutputAutoscalingProperties'] = None,
                 disk: Optional['outputs.WebServiceDetailsOutputDiskProperties'] = None,
                 max_shutdown_delay_seconds: Optional[int] = None,
                 parent_server: Optional['outputs.Resource'] = None,
                 pull_request_previews_enabled: Optional['WebServiceDetailsOutputPullRequestPreviewsEnabled'] = None):
        """
        :param 'WebServiceDetailsOutputEnv' env: Runtime
        :param int num_instances: For a *manually* scaled service, this is the number of instances the service is scaled to. DOES NOT indicate the number of running instances for an *autoscaled* service.
        :param 'WebServiceDetailsOutputPlan' plan: The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        :param 'WebServiceDetailsOutputRegion' region: Defaults to "oregon"
        :param int max_shutdown_delay_seconds: The maximum amount of time (in seconds) that Render waits for your application process to exit gracefully after sending it a SIGTERM signal.
        :param 'WebServiceDetailsOutputPullRequestPreviewsEnabled' pull_request_previews_enabled: Defaults to "no"
        """
        if build_plan is None:
            build_plan = 'starter'
        pulumi.set(__self__, "build_plan", build_plan)
        pulumi.set(__self__, "env", env)
        pulumi.set(__self__, "env_specific_details", env_specific_details)
        pulumi.set(__self__, "health_check_path", health_check_path)
        pulumi.set(__self__, "num_instances", num_instances)
        pulumi.set(__self__, "open_ports", open_ports)
        pulumi.set(__self__, "plan", plan)
        if region is None:
            region = 'oregon'
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "url", url)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if max_shutdown_delay_seconds is None:
            max_shutdown_delay_seconds = 30
        if max_shutdown_delay_seconds is not None:
            pulumi.set(__self__, "max_shutdown_delay_seconds", max_shutdown_delay_seconds)
        if parent_server is not None:
            pulumi.set(__self__, "parent_server", parent_server)
        if pull_request_previews_enabled is None:
            pull_request_previews_enabled = 'no'
        if pull_request_previews_enabled is not None:
            pulumi.set(__self__, "pull_request_previews_enabled", pull_request_previews_enabled)

    @property
    @pulumi.getter(name="buildPlan")
    def build_plan(self) -> 'WebServiceDetailsOutputBuildPlan':
        return pulumi.get(self, "build_plan")

    @property
    @pulumi.getter
    def env(self) -> 'WebServiceDetailsOutputEnv':
        """
        Runtime
        """
        return pulumi.get(self, "env")

    @property
    @pulumi.getter(name="envSpecificDetails")
    def env_specific_details(self) -> 'outputs.EnvSpecificDetails':
        return pulumi.get(self, "env_specific_details")

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

    @property
    @pulumi.getter(name="numInstances")
    def num_instances(self) -> int:
        """
        For a *manually* scaled service, this is the number of instances the service is scaled to. DOES NOT indicate the number of running instances for an *autoscaled* service.
        """
        return pulumi.get(self, "num_instances")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Sequence['outputs.ServerPort']:
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter
    def plan(self) -> 'WebServiceDetailsOutputPlan':
        """
        The instance type to use for the preview instance. Note that base services with any paid instance type can't create preview instances with the `free` instance type.
        """
        return pulumi.get(self, "plan")

    @property
    @pulumi.getter
    def region(self) -> 'WebServiceDetailsOutputRegion':
        """
        Defaults to "oregon"
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter
    def autoscaling(self) -> Optional['outputs.WebServiceDetailsOutputAutoscalingProperties']:
        return pulumi.get(self, "autoscaling")

    @property
    @pulumi.getter
    def disk(self) -> Optional['outputs.WebServiceDetailsOutputDiskProperties']:
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="maxShutdownDelaySeconds")
    def max_shutdown_delay_seconds(self) -> Optional[int]:
        """
        The maximum amount of time (in seconds) that Render waits for your application process to exit gracefully after sending it a SIGTERM signal.
        """
        return pulumi.get(self, "max_shutdown_delay_seconds")

    @property
    @pulumi.getter(name="parentServer")
    def parent_server(self) -> Optional['outputs.Resource']:
        return pulumi.get(self, "parent_server")

    @property
    @pulumi.getter(name="pullRequestPreviewsEnabled")
    def pull_request_previews_enabled(self) -> Optional['WebServiceDetailsOutputPullRequestPreviewsEnabled']:
        """
        Defaults to "no"
        """
        return pulumi.get(self, "pull_request_previews_enabled")


@pulumi.output_type
class WebServiceDetailsOutputAutoscalingProperties(dict):
    def __init__(__self__, *,
                 criteria: 'outputs.WebServiceDetailsOutputAutoscalingPropertiesCriteriaProperties',
                 enabled: Optional[bool] = None,
                 max: int,
                 min: int):
        """
        :param int max: The maximum number of instances for the service
        :param int min: The minimum number of instances for the service
        """
        pulumi.set(__self__, "criteria", criteria)
        if enabled is None:
            enabled = False
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def criteria(self) -> 'outputs.WebServiceDetailsOutputAutoscalingPropertiesCriteriaProperties':
        return pulumi.get(self, "criteria")

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

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        The maximum number of instances for the service
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        The minimum number of instances for the service
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class WebServiceDetailsOutputAutoscalingPropertiesCriteriaProperties(dict):
    def __init__(__self__, *,
                 cpu: 'outputs.WebServiceDetailsOutputAutoscalingPropertiesCriteriaPropertiesCpuProperties',
                 memory: 'outputs.WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu'):
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> 'outputs.WebServiceDetailsOutputAutoscalingPropertiesCriteriaPropertiesCpuProperties':
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> 'outputs.WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu':
        return pulumi.get(self, "memory")


@pulumi.output_type
class WebServiceDetailsOutputAutoscalingPropertiesCriteriaPropertiesCpuProperties(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 percentage: int):
        """
        :param int percentage: Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        if enabled is None:
            enabled = False
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "percentage", percentage)

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

    @property
    @pulumi.getter
    def percentage(self) -> int:
        """
        Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class WebServiceDetailsOutputDiskProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPath":
            suggest = "mount_path"
        elif key == "sizeGB":
            suggest = "size_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WebServiceDetailsOutputDiskProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WebServiceDetailsOutputDiskProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WebServiceDetailsOutputDiskProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 mount_path: str,
                 name: str,
                 size_gb: int):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mount_path", mount_path)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size_gb", size_gb)

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

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

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

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


@pulumi.output_type
class WebServiceDetailspropertiesautoscaling(dict):
    def __init__(__self__, *,
                 criteria: 'outputs.WebServiceDetailspropertiesautoscalingCriteriaProperties',
                 enabled: Optional[bool] = None,
                 max: int,
                 min: int):
        """
        :param int max: The maximum number of instances for the service
        :param int min: The minimum number of instances for the service
        """
        pulumi.set(__self__, "criteria", criteria)
        if enabled is None:
            enabled = False
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def criteria(self) -> 'outputs.WebServiceDetailspropertiesautoscalingCriteriaProperties':
        return pulumi.get(self, "criteria")

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

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        The maximum number of instances for the service
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        The minimum number of instances for the service
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class WebServiceDetailspropertiesautoscalingCriteriaProperties(dict):
    def __init__(__self__, *,
                 cpu: 'outputs.WebServiceDetailspropertiesautoscalingCriteriaPropertiesCpuProperties',
                 memory: 'outputs.WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu'):
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> 'outputs.WebServiceDetailspropertiesautoscalingCriteriaPropertiesCpuProperties':
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> 'outputs.WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu':
        return pulumi.get(self, "memory")


@pulumi.output_type
class WebServiceDetailspropertiesautoscalingCriteriaPropertiesCpuProperties(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 percentage: int):
        """
        :param int percentage: Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        if enabled is None:
            enabled = False
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "percentage", percentage)

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

    @property
    @pulumi.getter
    def percentage(self) -> int:
        """
        Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class WebServiceDetailspropertiesautoscalingpropertiescriteriapropertiescpu(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 percentage: int):
        """
        :param int percentage: Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        if enabled is None:
            enabled = False
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "percentage", percentage)

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

    @property
    @pulumi.getter
    def percentage(self) -> int:
        """
        Determines when your service will be scaled. If the average resource utilization is significantly above/below the target, we will increase/decrease the number of instances.
        """
        return pulumi.get(self, "percentage")


@pulumi.output_type
class WebServiceDetailspropertiesdisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPath":
            suggest = "mount_path"
        elif key == "sizeGB":
            suggest = "size_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WebServiceDetailspropertiesdisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WebServiceDetailspropertiesdisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WebServiceDetailspropertiesdisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 mount_path: str,
                 name: str,
                 size_gb: int):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mount_path", mount_path)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size_gb", size_gb)

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

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

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

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


@pulumi.output_type
class WebServiceOutput(dict):
    def __init__(__self__, *,
                 auto_deploy: Optional['ServiceAutoDeploy'] = None,
                 created_at: str,
                 dashboard_url: str,
                 id: str,
                 name: str,
                 notify_on_fail: 'ServiceNotifyOnFail',
                 owner_id: str,
                 root_dir: str,
                 slug: str,
                 suspended: 'ServiceSuspended',
                 suspenders: Sequence['ServiceSuspendersItem'],
                 updated_at: str,
                 branch: Optional[str] = None,
                 build_filter: Optional['outputs.BuildFilter'] = None,
                 environment_id: Optional[str] = None,
                 image_path: Optional[str] = None,
                 registry_credential: Optional['outputs.RegistryCredentialSummary'] = None,
                 repo: Optional[str] = None,
                 service_details: Optional['outputs.WebServiceDetailsOutput'] = None,
                 type: Optional[str] = None):
        """
        :param str dashboard_url: The URL to view the service in the Render Dashboard
        """
        if auto_deploy is None:
            auto_deploy = 'yes'
        pulumi.set(__self__, "auto_deploy", auto_deploy)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "dashboard_url", dashboard_url)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notify_on_fail", notify_on_fail)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "root_dir", root_dir)
        pulumi.set(__self__, "slug", slug)
        pulumi.set(__self__, "suspended", suspended)
        pulumi.set(__self__, "suspenders", suspenders)
        pulumi.set(__self__, "updated_at", updated_at)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if build_filter is not None:
            pulumi.set(__self__, "build_filter", build_filter)
        if environment_id is not None:
            pulumi.set(__self__, "environment_id", environment_id)
        if image_path is not None:
            pulumi.set(__self__, "image_path", image_path)
        if registry_credential is not None:
            pulumi.set(__self__, "registry_credential", registry_credential)
        if repo is not None:
            pulumi.set(__self__, "repo", repo)
        if service_details is not None:
            pulumi.set(__self__, "service_details", service_details)
        if type is None:
            type = 'web_service'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="autoDeploy")
    def auto_deploy(self) -> 'ServiceAutoDeploy':
        return pulumi.get(self, "auto_deploy")

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

    @property
    @pulumi.getter(name="dashboardUrl")
    def dashboard_url(self) -> str:
        """
        The URL to view the service in the Render Dashboard
        """
        return pulumi.get(self, "dashboard_url")

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

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

    @property
    @pulumi.getter(name="notifyOnFail")
    def notify_on_fail(self) -> 'ServiceNotifyOnFail':
        return pulumi.get(self, "notify_on_fail")

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

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

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

    @property
    @pulumi.getter
    def suspended(self) -> 'ServiceSuspended':
        return pulumi.get(self, "suspended")

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

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

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

    @property
    @pulumi.getter(name="buildFilter")
    def build_filter(self) -> Optional['outputs.BuildFilter']:
        return pulumi.get(self, "build_filter")

    @property
    @pulumi.getter(name="environmentId")
    def environment_id(self) -> Optional[str]:
        return pulumi.get(self, "environment_id")

    @property
    @pulumi.getter(name="imagePath")
    def image_path(self) -> Optional[str]:
        return pulumi.get(self, "image_path")

    @property
    @pulumi.getter(name="registryCredential")
    def registry_credential(self) -> Optional['outputs.RegistryCredentialSummary']:
        return pulumi.get(self, "registry_credential")

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

    @property
    @pulumi.getter(name="serviceDetails")
    def service_details(self) -> Optional['outputs.WebServiceDetailsOutput']:
        return pulumi.get(self, "service_details")

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


@pulumi.output_type
class Paths1services17BserviceId7D1jobscreateresponses200contentapplication1jsonschema(dict):
    def __init__(__self__, *,
                 created_at: str,
                 id: str,
                 plan_id: str,
                 service_id: str,
                 start_command: str,
                 finished_at: Optional[str] = None,
                 started_at: Optional[str] = None,
                 status: Optional['Paths1services17BserviceId7D1jobscreateresponses200contentapplication1jsonschemaStatus'] = None):
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "plan_id", plan_id)
        pulumi.set(__self__, "service_id", service_id)
        pulumi.set(__self__, "start_command", start_command)
        if finished_at is not None:
            pulumi.set(__self__, "finished_at", finished_at)
        if started_at is not None:
            pulumi.set(__self__, "started_at", started_at)
        if status is not None:
            pulumi.set(__self__, "status", status)

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

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

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

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

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

    @property
    @pulumi.getter(name="finishedAt")
    def finished_at(self) -> Optional[str]:
        return pulumi.get(self, "finished_at")

    @property
    @pulumi.getter(name="startedAt")
    def started_at(self) -> Optional[str]:
        return pulumi.get(self, "started_at")

    @property
    @pulumi.getter
    def status(self) -> Optional['Paths1services17BserviceId7D1jobscreateresponses200contentapplication1jsonschemaStatus']:
        return pulumi.get(self, "status")


