How to use the pulumi.ResourceOptions function in pulumi

def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 bindings: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['BindingArgs']]]]] = None,
                 etag: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 project: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[int]] = None,
                 workflow_template_id: Optional[pulumi.Input[str]] = None,
                 __props__=None):
        if opts is None:
            opts = pulumi.ResourceOptions()
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.version is None:
            opts.version = _utilities.get_version()
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = WorkflowTemplateIamPolicyArgs.__new__(WorkflowTemplateIamPolicyArgs)

            __props__.__dict__["bindings"] = bindings
            __props__.__dict__["etag"] = etag
            if location is None and not opts.urn:
                raise TypeError("Missing required property 'location'")
            __props__.__dict__["location"] = location
            if project is None and not opts.urn:
                raise TypeError("Missing required property 'project'")

def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 audit_configs: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['AuditConfigArgs']]]]] = None,
                 bindings: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['BindingArgs']]]]] = None,
                 etag: Optional[pulumi.Input[str]] = None,
                 locations_id: Optional[pulumi.Input[str]] = None,
                 projects_id: Optional[pulumi.Input[str]] = None,
                 services_id: Optional[pulumi.Input[str]] = None,
                 update_mask: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[int]] = None,
                 __props__=None):
        if opts is None:
            opts = pulumi.ResourceOptions()
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.version is None:
            opts.version = _utilities.get_version()
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = ServiceIamPolicyArgs.__new__(ServiceIamPolicyArgs)

            __props__.__dict__["audit_configs"] = audit_configs
            __props__.__dict__["bindings"] = bindings
            __props__.__dict__["etag"] = etag
            if locations_id is None and not opts.urn:
                raise TypeError("Missing required property 'locations_id'")
            __props__.__dict__["locations_id"] = locations_id
            if projects_id is None and not opts.urn:

def __init__(__self__, resource_name: str, *args, **kwargs):
        resource_args, opts = _utilities.get_resource_args_opts(EnvironmentEC2Args, pulumi.ResourceOptions, *args, **kwargs)
        if resource_args is not None:
            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
        else:
            __self__._internal_init(resource_name, *args, **kwargs)

def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 display_name: Optional[pulumi.Input[str]] = None,
                 inspect_config: Optional[pulumi.Input[pulumi.InputType['GooglePrivacyDlpV2InspectConfigArgs']]] = None,
                 inspect_templates_id: Optional[pulumi.Input[str]] = None,
                 locations_id: Optional[pulumi.Input[str]] = None,
                 organizations_id: Optional[pulumi.Input[str]] = None,
                 template_id: Optional[pulumi.Input[str]] = None,
                 __props__=None):
        if opts is None:
            opts = pulumi.ResourceOptions()
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.version is None:
            opts.version = _utilities.get_version()
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = OrganizationInspectTemplateArgs.__new__(OrganizationInspectTemplateArgs)

            __props__.__dict__["description"] = description
            __props__.__dict__["display_name"] = display_name
            __props__.__dict__["inspect_config"] = inspect_config
            if inspect_templates_id is None and not opts.urn:
                raise TypeError("Missing required property 'inspect_templates_id'")
            __props__.__dict__["inspect_templates_id"] = inspect_templates_id
            if locations_id is None and not opts.urn:

def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 audit_configs: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['AuditConfigArgs']]]]] = None,
                 bindings: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['BindingArgs']]]]] = None,
                 etag: Optional[pulumi.Input[str]] = None,
                 iam_owned: Optional[pulumi.Input[bool]] = None,
                 project: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 resource: Optional[pulumi.Input[str]] = None,
                 rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RuleArgs']]]]] = None,
                 version: Optional[pulumi.Input[int]] = None,
                 __props__=None):
        if opts is None:
            opts = pulumi.ResourceOptions()
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.version is None:
            opts.version = _utilities.get_version()
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = ResourcePolicyIamPolicyArgs.__new__(ResourcePolicyIamPolicyArgs)

            __props__.__dict__["audit_configs"] = audit_configs
            __props__.__dict__["bindings"] = bindings
            __props__.__dict__["etag"] = etag
            __props__.__dict__["iam_owned"] = iam_owned
            if project is None and not opts.urn:
                raise TypeError("Missing required property 'project'")
            __props__.__dict__["project"] = project

def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 connection_pool_config: Optional[pulumi.Input[pulumi.InputType['ProxyDefaultTargetGroupConnectionPoolConfigArgs']]] = None,
                 db_proxy_name: Optional[pulumi.Input[str]] = None,
                 __props__=None):
        if opts is None:
            opts = pulumi.ResourceOptions()
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.version is None:
            opts.version = _utilities.get_version()
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = ProxyDefaultTargetGroupArgs.__new__(ProxyDefaultTargetGroupArgs)

            __props__.__dict__["connection_pool_config"] = connection_pool_config
            if db_proxy_name is None and not opts.urn:
                raise TypeError("Missing required property 'db_proxy_name'")
            __props__.__dict__["db_proxy_name"] = db_proxy_name
            __props__.__dict__["arn"] = None
            __props__.__dict__["name"] = None
        super(ProxyDefaultTargetGroup, __self__).__init__(
            'aws:rds/proxyDefaultTargetGroup:ProxyDefaultTargetGroup',

def construct(self, name: str, typ: str, urn: str) -> pulumi.Resource:
            if typ == "gcp-native:monitoring/v3:AlertPolicy":
                return AlertPolicy(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "gcp-native:monitoring/v3:Group":
                return Group(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "gcp-native:monitoring/v3:MetricDescriptor":
                return MetricDescriptor(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "gcp-native:monitoring/v3:NotificationChannel":
                return NotificationChannel(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "gcp-native:monitoring/v3:Service":
                return Service(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "gcp-native:monitoring/v3:ServiceServiceLevelObjective":
                return ServiceServiceLevelObjective(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "gcp-native:monitoring/v3:UptimeCheckConfig":
                return UptimeCheckConfig(name, pulumi.ResourceOptions(urn=urn))
            else:
                raise Exception(f"unknown resource type {typ}")

def construct(self, name: str, typ: str, urn: str) -> pulumi.Resource:
            if typ == "google-native:cloudresourcemanager/v3:Folder":
                return Folder(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:FolderIamPolicy":
                return FolderIamPolicy(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:Lien":
                return Lien(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:OrganizationIamPolicy":
                return OrganizationIamPolicy(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:Project":
                return Project(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:ProjectIamPolicy":
                return ProjectIamPolicy(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:TagKey":
                return TagKey(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:TagKeyIamPolicy":
                return TagKeyIamPolicy(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:TagValue":
                return TagValue(name, pulumi.ResourceOptions(urn=urn))
            elif typ == "google-native:cloudresourcemanager/v3:TagValueIamPolicy":
                return TagValueIamPolicy(name, pulumi.ResourceOptions(urn=urn))
            else:
                raise Exception(f"unknown resource type {typ}")

:param pulumi.Input[bool] auto_healing: Whether to enable auto-healing for the layer.
        :param pulumi.Input[str] custom_instance_profile_arn: The ARN of an IAM profile that will be used for the layer's instances.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_security_group_ids: Ids for a set of security groups to apply to the layer's instances.
        :param pulumi.Input[bool] drain_elb_on_shutdown: Whether to enable Elastic Load Balancing connection draining.
        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['StaticWebLayerEbsVolumeArgs']]]] ebs_volumes: `ebs_volume` blocks, as described below, will each create an EBS volume and connect it to the layer's instances.
        :param pulumi.Input[str] elastic_load_balancer: Name of an Elastic Load Balancer to attach to this layer
        :param pulumi.Input[bool] install_updates_on_boot: Whether to install OS and package updates on each instance when it boots.
        :param pulumi.Input[int] instance_shutdown_timeout: The time, in seconds, that OpsWorks will wait for Chef to complete after triggering the Shutdown event.
        :param pulumi.Input[str] name: A human-readable name for the layer.
        :param pulumi.Input[str] stack_id: The id of the stack the layer will belong to.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] system_packages: Names of a set of system packages to install on the layer's instances.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: A map of tags to assign to the resource. .If configured with a provider `default_tags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags_all: A map of tags assigned to the resource, including those inherited from the provider .
        :param pulumi.Input[bool] use_ebs_optimized_instances: Whether to use EBS-optimized instances.
        """
        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))

        __props__ = _StaticWebLayerState.__new__(_StaticWebLayerState)

        __props__.__dict__["arn"] = arn
        __props__.__dict__["auto_assign_elastic_ips"] = auto_assign_elastic_ips
        __props__.__dict__["auto_assign_public_ips"] = auto_assign_public_ips
        __props__.__dict__["auto_healing"] = auto_healing
        __props__.__dict__["custom_configure_recipes"] = custom_configure_recipes
        __props__.__dict__["custom_deploy_recipes"] = custom_deploy_recipes
        __props__.__dict__["custom_instance_profile_arn"] = custom_instance_profile_arn
        __props__.__dict__["custom_json"] = custom_json
        __props__.__dict__["custom_security_group_ids"] = custom_security_group_ids
        __props__.__dict__["custom_setup_recipes"] = custom_setup_recipes
        __props__.__dict__["custom_shutdown_recipes"] = custom_shutdown_recipes
        __props__.__dict__["custom_undeploy_recipes"] = custom_undeploy_recipes
        __props__.__dict__["drain_elb_on_shutdown"] = drain_elb_on_shutdown

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

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

        __props__ = CompositeTypeArgs.__new__(CompositeTypeArgs)

        __props__.__dict__["description"] = None
        __props__.__dict__["insert_time"] = None
        __props__.__dict__["labels"] = None
        __props__.__dict__["name"] = None
        __props__.__dict__["operation"] = None
        __props__.__dict__["self_link"] = None
        __props__.__dict__["status"] = None
        __props__.__dict__["template_contents"] = None
        return CompositeType(resource_name, opts=opts, __props__=__props__)