How to use the pulumi.set function in pulumi

def __init__(__self__, arn=None, id=None, name=None, tags=None, url=None):
        if arn and not isinstance(arn, str):
            raise TypeError("Expected argument 'arn' to be a str")
        pulumi.set(__self__, "arn", arn)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if name and not isinstance(name, str):
            raise TypeError("Expected argument 'name' to be a str")
        pulumi.set(__self__, "name", name)
        if tags and not isinstance(tags, dict):
            raise TypeError("Expected argument 'tags' to be a dict")
        pulumi.set(__self__, "tags", tags)
        if url and not isinstance(url, str):
            raise TypeError("Expected argument 'url' to be a str")
        pulumi.set(__self__, "url", url)

def __init__(__self__, *,
                 type: str,
                 queuing: Optional['outputs.QueuingConfiguration'] = None):
        """
        LimitResponse defines how to handle requests that can not be executed right now.
        :param str type: `type` is "Queue" or "Reject". "Queue" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. "Reject" means that requests that can not be executed upon arrival are rejected. Required.
        :param 'QueuingConfigurationArgs' queuing: `queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`.
        """
        pulumi.set(__self__, "type", type)
        if queuing is not None:
            pulumi.set(__self__, "queuing", queuing)

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

def custom_setup_recipes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "custom_setup_recipes", value)

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

if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if last_start_timestamp is not None:
            pulumi.set(__self__, "last_start_timestamp", last_start_timestamp)
        if last_stop_timestamp is not None:
            pulumi.set(__self__, "last_stop_timestamp", last_stop_timestamp)
        if last_suspended_timestamp is not None:
            pulumi.set(__self__, "last_suspended_timestamp", last_suspended_timestamp)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if min_cpu_platform is not None:
            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_interfaces is not None:
            pulumi.set(__self__, "network_interfaces", network_interfaces)
        if network_performance_config is not None:
            pulumi.set(__self__, "network_performance_config", network_performance_config)
        if post_key_revocation_action_type is not None:
            pulumi.set(__self__, "post_key_revocation_action_type", post_key_revocation_action_type)
        if preserved_state_size_gb is not None:
            pulumi.set(__self__, "preserved_state_size_gb", preserved_state_size_gb)
        if private_ipv6_google_access is not None:
            pulumi.set(__self__, "private_ipv6_google_access", private_ipv6_google_access)
        if request_id is not None:
            pulumi.set(__self__, "request_id", request_id)
        if reservation_affinity is not None:
            pulumi.set(__self__, "reservation_affinity", reservation_affinity)
        if resource_policies is not None:
            pulumi.set(__self__, "resource_policies", resource_policies)

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

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

pulumi.set(__self__, "ipv6_association_id", ipv6_association_id)
        if ipv6_cidr_block and not isinstance(ipv6_cidr_block, str):
            raise TypeError("Expected argument 'ipv6_cidr_block' to be a str")
        pulumi.set(__self__, "ipv6_cidr_block", ipv6_cidr_block)
        if main_route_table_id and not isinstance(main_route_table_id, str):
            raise TypeError("Expected argument 'main_route_table_id' to be a str")
        pulumi.set(__self__, "main_route_table_id", main_route_table_id)
        if owner_id and not isinstance(owner_id, str):
            raise TypeError("Expected argument 'owner_id' to be a str")
        pulumi.set(__self__, "owner_id", owner_id)
        if state and not isinstance(state, str):
            raise TypeError("Expected argument 'state' to be a str")
        pulumi.set(__self__, "state", state)
        if tags and not isinstance(tags, dict):
            raise TypeError("Expected argument 'tags' to be a dict")
        pulumi.set(__self__, "tags", tags)

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