def __init__(__self__,
default_security_rules=None,
etag=None,
flow_logs=None,
id=None,
location=None,
name=None,
network_interfaces=None,
provisioning_state=None,
resource_guid=None,
security_rules=None,
subnets=None,
tags=None,
type=None):
if default_security_rules and not isinstance(default_security_rules,
list):
raise TypeError(
"Expected argument 'default_security_rules' to be a list")
pulumi.set(__self__, "default_security_rules", default_security_rules)
if etag and not isinstance(etag, str):
raise TypeError("Expected argument 'etag' to be a str")
pulumi.set(__self__, "etag", etag)
if flow_logs and not isinstance(flow_logs, list):
raise TypeError("Expected argument 'flow_logs' to be a list")
pulumi.set(__self__, "flow_logs", flow_logs)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if location and not isinstance(location, str):
raise TypeError("Expected argument 'location' to be a str")
pulumi.set(__self__, "location", location)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if network_interfaces and not isinstance(network_interfaces, list):
raise TypeError(
"Expected argument 'network_interfaces' to be a list")
pulumi.set(__self__, "network_interfaces", network_interfaces)
if provisioning_state and not isinstance(provisioning_state, str):
raise TypeError(
"Expected argument 'provisioning_state' to be a str")
pulumi.set(__self__, "provisioning_state", provisioning_state)
if resource_guid and not isinstance(resource_guid, str):
raise TypeError("Expected argument 'resource_guid' to be a str")
pulumi.set(__self__, "resource_guid", resource_guid)
if security_rules and not isinstance(security_rules, list):
raise TypeError("Expected argument 'security_rules' to be a list")
pulumi.set(__self__, "security_rules", security_rules)
if subnets and not isinstance(subnets, list):
raise TypeError("Expected argument 'subnets' to be a list")
pulumi.set(__self__, "subnets", subnets)
if tags and not isinstance(tags, dict):
raise TypeError("Expected argument 'tags' to be a dict")
pulumi.set(__self__, "tags", tags)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
def account_alias(self, value: pulumi.Input[str]):
pulumi.set(self, "account_alias", value)
def api_version(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "api_version", value)
def authentication_strategy(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "authentication_strategy", value)
def __init__(__self__, id=None, name=None, recurring_scans=None, storage_account_access_key=None, storage_container_path=None, storage_container_sas_key=None, type=None):
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 recurring_scans and not isinstance(recurring_scans, dict):
raise TypeError("Expected argument 'recurring_scans' to be a dict")
pulumi.set(__self__, "recurring_scans", recurring_scans)
if storage_account_access_key and not isinstance(storage_account_access_key, str):
raise TypeError("Expected argument 'storage_account_access_key' to be a str")
pulumi.set(__self__, "storage_account_access_key", storage_account_access_key)
if storage_container_path and not isinstance(storage_container_path, str):
raise TypeError("Expected argument 'storage_container_path' to be a str")
pulumi.set(__self__, "storage_container_path", storage_container_path)
if storage_container_sas_key and not isinstance(storage_container_sas_key, str):
raise TypeError("Expected argument 'storage_container_sas_key' to be a str")
pulumi.set(__self__, "storage_container_sas_key", storage_container_sas_key)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
def tags(self, value: Optional[pulumi.Input[Mapping[str,
pulumi.Input[str]]]]):
pulumi.set(self, "tags", value)
def engine_type(self, value: pulumi.Input[str]):
pulumi.set(self, "engine_type", value)
def default_store_account_name(self, value: pulumi.Input[str]):
pulumi.set(self, "default_store_account_name", value)
def resource_group_name(self, value: pulumi.Input[str]):
pulumi.set(self, "resource_group_name", value)
def __init__(
__self__,
*,
default_store_account_name: pulumi.Input[str],
resource_group_name: pulumi.Input[str],
location: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
tags: Optional[pulumi.Input[Mapping[str,
pulumi.Input[str]]]] = None,
tier: Optional[pulumi.Input[str]] = None):
"""
The set of arguments for constructing a AnalyticsAccount resource.
:param pulumi.Input[str] default_store_account_name: Specifies the data lake store to use by default. Changing this forces a new resource to be created.
:param pulumi.Input[str] resource_group_name: The name of the resource group in which to create the Data Lake Analytics Account.
:param pulumi.Input[str] location: Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
:param pulumi.Input[str] name: Specifies the name of the Data Lake Analytics Account. Changing this forces a new resource to be created. Has to be between 3 to 24 characters.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: A mapping of tags to assign to the resource.
:param pulumi.Input[str] tier: The monthly commitment tier for Data Lake Analytics Account. Accepted values are `Consumption`, `Commitment_100000AUHours`, `Commitment_10000AUHours`, `Commitment_1000AUHours`, `Commitment_100AUHours`, `Commitment_500000AUHours`, `Commitment_50000AUHours`, `Commitment_5000AUHours`, or `Commitment_500AUHours`.
"""
pulumi.set(__self__, "default_store_account_name",
default_store_account_name)
pulumi.set(__self__, "resource_group_name", resource_group_name)
if location is not None:
pulumi.set(__self__, "location", location)
if name is not None:
pulumi.set(__self__, "name", name)
if tags is not None:
pulumi.set(__self__, "tags", tags)
if tier is not None:
pulumi.set(__self__, "tier", tier)
def tier(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "tier", value)
def __init__(__self__, access=None, communities=None, etag=None, id=None, location=None, name=None, provisioning_state=None, route_filter_rule_type=None):
if access and not isinstance(access, str):
raise TypeError("Expected argument 'access' to be a str")
pulumi.set(__self__, "access", access)
if communities and not isinstance(communities, list):
raise TypeError("Expected argument 'communities' to be a list")
pulumi.set(__self__, "communities", communities)
if etag and not isinstance(etag, str):
raise TypeError("Expected argument 'etag' to be a str")
pulumi.set(__self__, "etag", etag)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if location and not isinstance(location, str):
raise TypeError("Expected argument 'location' to be a str")
pulumi.set(__self__, "location", location)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if provisioning_state and not isinstance(provisioning_state, str):
raise TypeError("Expected argument 'provisioning_state' to be a str")
pulumi.set(__self__, "provisioning_state", provisioning_state)
if route_filter_rule_type and not isinstance(route_filter_rule_type, str):
raise TypeError("Expected argument 'route_filter_rule_type' to be a str")
pulumi.set(__self__, "route_filter_rule_type", route_filter_rule_type)
def __init__(__self__,
admin_roles=None,
city=None,
cost_center=None,
country_code=None,
custom_profile_attributes=None,
department=None,
display_name=None,
division=None,
email=None,
employee_number=None,
first_name=None,
group_memberships=None,
honorific_prefix=None,
honorific_suffix=None,
id=None,
last_name=None,
locale=None,
login=None,
manager=None,
manager_id=None,
middle_name=None,
mobile_phone=None,
nick_name=None,
organization=None,
postal_address=None,
preferred_language=None,
primary_phone=None,
profile_url=None,
searches=None,
second_email=None,
state=None,
status=None,
street_address=None,
timezone=None,
title=None,
user_type=None,
zip_code=None):
if admin_roles and not isinstance(admin_roles, list):
raise TypeError("Expected argument 'admin_roles' to be a list")
pulumi.set(__self__, "admin_roles", admin_roles)
if city and not isinstance(city, str):
raise TypeError("Expected argument 'city' to be a str")
pulumi.set(__self__, "city", city)
if cost_center and not isinstance(cost_center, str):
raise TypeError("Expected argument 'cost_center' to be a str")
pulumi.set(__self__, "cost_center", cost_center)
if country_code and not isinstance(country_code, str):
raise TypeError("Expected argument 'country_code' to be a str")
pulumi.set(__self__, "country_code", country_code)
if custom_profile_attributes and not isinstance(
custom_profile_attributes, str):
raise TypeError(
"Expected argument 'custom_profile_attributes' to be a str")
pulumi.set(__self__, "custom_profile_attributes",
custom_profile_attributes)
if department and not isinstance(department, str):
raise TypeError("Expected argument 'department' to be a str")
pulumi.set(__self__, "department", department)
if display_name and not isinstance(display_name, str):
raise TypeError("Expected argument 'display_name' to be a str")
pulumi.set(__self__, "display_name", display_name)
if division and not isinstance(division, str):
raise TypeError("Expected argument 'division' to be a str")
pulumi.set(__self__, "division", division)
if email and not isinstance(email, str):
raise TypeError("Expected argument 'email' to be a str")
pulumi.set(__self__, "email", email)
if employee_number and not isinstance(employee_number, str):
raise TypeError("Expected argument 'employee_number' to be a str")
pulumi.set(__self__, "employee_number", employee_number)
if first_name and not isinstance(first_name, str):
raise TypeError("Expected argument 'first_name' to be a str")
pulumi.set(__self__, "first_name", first_name)
if group_memberships and not isinstance(group_memberships, list):
raise TypeError(
"Expected argument 'group_memberships' to be a list")
pulumi.set(__self__, "group_memberships", group_memberships)
if honorific_prefix and not isinstance(honorific_prefix, str):
raise TypeError("Expected argument 'honorific_prefix' to be a str")
pulumi.set(__self__, "honorific_prefix", honorific_prefix)
if honorific_suffix and not isinstance(honorific_suffix, str):
raise TypeError("Expected argument 'honorific_suffix' to be a str")
pulumi.set(__self__, "honorific_suffix", honorific_suffix)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if last_name and not isinstance(last_name, str):
raise TypeError("Expected argument 'last_name' to be a str")
pulumi.set(__self__, "last_name", last_name)
if locale and not isinstance(locale, str):
raise TypeError("Expected argument 'locale' to be a str")
pulumi.set(__self__, "locale", locale)
if login and not isinstance(login, str):
raise TypeError("Expected argument 'login' to be a str")
pulumi.set(__self__, "login", login)
if manager and not isinstance(manager, str):
raise TypeError("Expected argument 'manager' to be a str")
pulumi.set(__self__, "manager", manager)
if manager_id and not isinstance(manager_id, str):
raise TypeError("Expected argument 'manager_id' to be a str")
pulumi.set(__self__, "manager_id", manager_id)
if middle_name and not isinstance(middle_name, str):
raise TypeError("Expected argument 'middle_name' to be a str")
pulumi.set(__self__, "middle_name", middle_name)
if mobile_phone and not isinstance(mobile_phone, str):
raise TypeError("Expected argument 'mobile_phone' to be a str")
pulumi.set(__self__, "mobile_phone", mobile_phone)
if nick_name and not isinstance(nick_name, str):
raise TypeError("Expected argument 'nick_name' to be a str")
pulumi.set(__self__, "nick_name", nick_name)
if organization and not isinstance(organization, str):
raise TypeError("Expected argument 'organization' to be a str")
pulumi.set(__self__, "organization", organization)
if postal_address and not isinstance(postal_address, str):
raise TypeError("Expected argument 'postal_address' to be a str")
pulumi.set(__self__, "postal_address", postal_address)
if preferred_language and not isinstance(preferred_language, str):
raise TypeError(
"Expected argument 'preferred_language' to be a str")
pulumi.set(__self__, "preferred_language", preferred_language)
if primary_phone and not isinstance(primary_phone, str):
raise TypeError("Expected argument 'primary_phone' to be a str")
pulumi.set(__self__, "primary_phone", primary_phone)
if profile_url and not isinstance(profile_url, str):
raise TypeError("Expected argument 'profile_url' to be a str")
pulumi.set(__self__, "profile_url", profile_url)
if searches and not isinstance(searches, list):
raise TypeError("Expected argument 'searches' to be a list")
pulumi.set(__self__, "searches", searches)
if second_email and not isinstance(second_email, str):
raise TypeError("Expected argument 'second_email' to be a str")
pulumi.set(__self__, "second_email", second_email)
if state and not isinstance(state, str):
raise TypeError("Expected argument 'state' to be a str")
pulumi.set(__self__, "state", state)
if status and not isinstance(status, str):
raise TypeError("Expected argument 'status' to be a str")
pulumi.set(__self__, "status", status)
if street_address and not isinstance(street_address, str):
raise TypeError("Expected argument 'street_address' to be a str")
pulumi.set(__self__, "street_address", street_address)
if timezone and not isinstance(timezone, str):
raise TypeError("Expected argument 'timezone' to be a str")
pulumi.set(__self__, "timezone", timezone)
if title and not isinstance(title, str):
raise TypeError("Expected argument 'title' to be a str")
pulumi.set(__self__, "title", title)
if user_type and not isinstance(user_type, str):
raise TypeError("Expected argument 'user_type' to be a str")
pulumi.set(__self__, "user_type", user_type)
if zip_code and not isinstance(zip_code, str):
raise TypeError("Expected argument 'zip_code' to be a str")
pulumi.set(__self__, "zip_code", zip_code)
def __init__(__self__, bgp_settings=None, etag=None, gateway_ip_address=None, local_network_address_space=None, location=None, name=None, provisioning_state=None, resource_guid=None, tags=None, type=None):
if bgp_settings and not isinstance(bgp_settings, dict):
raise TypeError("Expected argument 'bgp_settings' to be a dict")
pulumi.set(__self__, "bgp_settings", bgp_settings)
if etag and not isinstance(etag, str):
raise TypeError("Expected argument 'etag' to be a str")
pulumi.set(__self__, "etag", etag)
if gateway_ip_address and not isinstance(gateway_ip_address, str):
raise TypeError("Expected argument 'gateway_ip_address' to be a str")
pulumi.set(__self__, "gateway_ip_address", gateway_ip_address)
if local_network_address_space and not isinstance(local_network_address_space, dict):
raise TypeError("Expected argument 'local_network_address_space' to be a dict")
pulumi.set(__self__, "local_network_address_space", local_network_address_space)
if location and not isinstance(location, str):
raise TypeError("Expected argument 'location' to be a str")
pulumi.set(__self__, "location", location)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if provisioning_state and not isinstance(provisioning_state, str):
raise TypeError("Expected argument 'provisioning_state' to be a str")
pulumi.set(__self__, "provisioning_state", provisioning_state)
if resource_guid and not isinstance(resource_guid, str):
raise TypeError("Expected argument 'resource_guid' to be a str")
pulumi.set(__self__, "resource_guid", resource_guid)
if tags and not isinstance(tags, dict):
raise TypeError("Expected argument 'tags' to be a dict")
pulumi.set(__self__, "tags", tags)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
def latest_revision(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "latest_revision", value)
def location(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "location", value)
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
def __init__(__self__,
ddos_settings=None,
dns_settings=None,
etag=None,
id=None,
idle_timeout_in_minutes=None,
ip_address=None,
ip_configuration=None,
ip_tags=None,
location=None,
name=None,
provisioning_state=None,
public_ip_address_version=None,
public_ip_allocation_method=None,
public_ip_prefix=None,
resource_guid=None,
sku=None,
tags=None,
type=None,
zones=None):
if ddos_settings and not isinstance(ddos_settings, dict):
raise TypeError("Expected argument 'ddos_settings' to be a dict")
pulumi.set(__self__, "ddos_settings", ddos_settings)
if dns_settings and not isinstance(dns_settings, dict):
raise TypeError("Expected argument 'dns_settings' to be a dict")
pulumi.set(__self__, "dns_settings", dns_settings)
if etag and not isinstance(etag, str):
raise TypeError("Expected argument 'etag' to be a str")
pulumi.set(__self__, "etag", etag)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if idle_timeout_in_minutes and not isinstance(idle_timeout_in_minutes,
int):
raise TypeError(
"Expected argument 'idle_timeout_in_minutes' to be a int")
pulumi.set(__self__, "idle_timeout_in_minutes",
idle_timeout_in_minutes)
if ip_address and not isinstance(ip_address, str):
raise TypeError("Expected argument 'ip_address' to be a str")
pulumi.set(__self__, "ip_address", ip_address)
if ip_configuration and not isinstance(ip_configuration, dict):
raise TypeError(
"Expected argument 'ip_configuration' to be a dict")
pulumi.set(__self__, "ip_configuration", ip_configuration)
if ip_tags and not isinstance(ip_tags, list):
raise TypeError("Expected argument 'ip_tags' to be a list")
pulumi.set(__self__, "ip_tags", ip_tags)
if location and not isinstance(location, str):
raise TypeError("Expected argument 'location' to be a str")
pulumi.set(__self__, "location", location)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if provisioning_state and not isinstance(provisioning_state, str):
raise TypeError(
"Expected argument 'provisioning_state' to be a str")
pulumi.set(__self__, "provisioning_state", provisioning_state)
if public_ip_address_version and not isinstance(
public_ip_address_version, str):
raise TypeError(
"Expected argument 'public_ip_address_version' to be a str")
pulumi.set(__self__, "public_ip_address_version",
public_ip_address_version)
if public_ip_allocation_method and not isinstance(
public_ip_allocation_method, str):
raise TypeError(
"Expected argument 'public_ip_allocation_method' to be a str")
pulumi.set(__self__, "public_ip_allocation_method",
public_ip_allocation_method)
if public_ip_prefix and not isinstance(public_ip_prefix, dict):
raise TypeError(
"Expected argument 'public_ip_prefix' to be a dict")
pulumi.set(__self__, "public_ip_prefix", public_ip_prefix)
if resource_guid and not isinstance(resource_guid, str):
raise TypeError("Expected argument 'resource_guid' to be a str")
pulumi.set(__self__, "resource_guid", resource_guid)
if sku and not isinstance(sku, dict):
raise TypeError("Expected argument 'sku' to be a dict")
pulumi.set(__self__, "sku", sku)
if tags and not isinstance(tags, dict):
raise TypeError("Expected argument 'tags' to be a dict")
pulumi.set(__self__, "tags", tags)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
if zones and not isinstance(zones, list):
raise TypeError("Expected argument 'zones' to be a list")
pulumi.set(__self__, "zones", zones)
def data(self, value: pulumi.Input[str]):
pulumi.set(self, "data", value)
def __init__(
__self__,
*,
data: pulumi.Input[str],
engine_type: pulumi.Input[str],
engine_version: pulumi.Input[str],
authentication_strategy: Optional[pulumi.Input[str]] = None,
description: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
tags: Optional[pulumi.Input[Mapping[str,
pulumi.Input[str]]]] = None):
"""
The set of arguments for constructing a Configuration resource.
:param pulumi.Input[str] data: Broker configuration in XML format. See [official docs](https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/amazon-mq-broker-configuration-parameters.html) for supported parameters and format of the XML.
:param pulumi.Input[str] engine_type: Type of broker engine. Valid values are `ActiveMQ` and `RabbitMQ`.
:param pulumi.Input[str] engine_version: Version of the broker engine.
:param pulumi.Input[str] authentication_strategy: Authentication strategy associated with the configuration. Valid values are `simple` and `ldap`. `ldap` is not supported for `engine_type` `RabbitMQ`.
:param pulumi.Input[str] description: Description of the configuration.
:param pulumi.Input[str] name: Name of the configuration.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Map of tags to assign to the resource.
"""
pulumi.set(__self__, "data", data)
pulumi.set(__self__, "engine_type", engine_type)
pulumi.set(__self__, "engine_version", engine_version)
if authentication_strategy is not None:
pulumi.set(__self__, "authentication_strategy",
authentication_strategy)
if description is not None:
pulumi.set(__self__, "description", description)
if name is not None:
pulumi.set(__self__, "name", name)
if tags is not None:
pulumi.set(__self__, "tags", tags)
def engine_version(self, value: pulumi.Input[str]):
pulumi.set(self, "engine_version", value)
def arn(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "arn", value)
def __init__(__self__,
location=None,
media_service_id=None,
name=None,
storage_accounts=None,
tags=None,
type=None):
if location and not isinstance(location, str):
raise TypeError("Expected argument 'location' to be a str")
pulumi.set(__self__, "location", location)
if media_service_id and not isinstance(media_service_id, str):
raise TypeError("Expected argument 'media_service_id' to be a str")
pulumi.set(__self__, "media_service_id", media_service_id)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if storage_accounts and not isinstance(storage_accounts, list):
raise TypeError(
"Expected argument 'storage_accounts' to be a list")
pulumi.set(__self__, "storage_accounts", storage_accounts)
if tags and not isinstance(tags, dict):
raise TypeError("Expected argument 'tags' to be a dict")
pulumi.set(__self__, "tags", tags)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
def data(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "data", value)
def __init__(__self__, *, account_alias: pulumi.Input[str]):
"""
The set of arguments for constructing a Alias resource.
"""
pulumi.set(__self__, "account_alias", account_alias)
def description(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "description", value)
def account_alias(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "account_alias", value)
def engine_type(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "engine_type", value)
def kind(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "kind", value)
def __init__(__self__, all_tenants=None, name=None, owner_tenant_id=None, resource_group=None, resource_name=None, subscription_id=None, tags=None, tenants=None, type=None):
if all_tenants and not isinstance(all_tenants, bool):
raise TypeError("Expected argument 'all_tenants' to be a bool")
pulumi.set(__self__, "all_tenants", all_tenants)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if owner_tenant_id and not isinstance(owner_tenant_id, str):
raise TypeError("Expected argument 'owner_tenant_id' to be a str")
pulumi.set(__self__, "owner_tenant_id", owner_tenant_id)
if resource_group and not isinstance(resource_group, str):
raise TypeError("Expected argument 'resource_group' to be a str")
pulumi.set(__self__, "resource_group", resource_group)
if resource_name and not isinstance(resource_name, str):
raise TypeError("Expected argument 'resource_name' to be a str")
pulumi.set(__self__, "resource_name", resource_name)
if subscription_id and not isinstance(subscription_id, str):
raise TypeError("Expected argument 'subscription_id' to be a str")
pulumi.set(__self__, "subscription_id", subscription_id)
if tags and not isinstance(tags, dict):
raise TypeError("Expected argument 'tags' to be a dict")
pulumi.set(__self__, "tags", tags)
if tenants and not isinstance(tenants, list):
raise TypeError("Expected argument 'tenants' to be a list")
pulumi.set(__self__, "tenants", tenants)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
