pulumi-azuread 5.48.0a1706744699__py3-none-any.whl → 6.8.0a1766208344__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-azuread might be problematic. Click here for more details.
- pulumi_azuread/__init__.py +48 -1
- pulumi_azuread/_inputs.py +3803 -919
- pulumi_azuread/_utilities.py +52 -12
- pulumi_azuread/access_package.py +84 -78
- pulumi_azuread/access_package_assignment_policy.py +202 -196
- pulumi_azuread/access_package_catalog.py +82 -76
- pulumi_azuread/access_package_catalog_role_assignment.py +73 -67
- pulumi_azuread/access_package_resource_catalog_association.py +73 -67
- pulumi_azuread/access_package_resource_package_association.py +79 -73
- pulumi_azuread/administrative_unit.py +120 -100
- pulumi_azuread/administrative_unit_member.py +66 -50
- pulumi_azuread/administrative_unit_role_member.py +75 -69
- pulumi_azuread/app_role_assignment.py +164 -264
- pulumi_azuread/application.py +766 -692
- pulumi_azuread/application_api_access.py +84 -80
- pulumi_azuread/application_app_role.py +120 -116
- pulumi_azuread/application_certificate.py +349 -211
- pulumi_azuread/application_fallback_public_client.py +50 -44
- pulumi_azuread/application_federated_identity_credential.py +142 -197
- pulumi_azuread/application_from_template.py +90 -84
- pulumi_azuread/application_identifier_uri.py +56 -52
- pulumi_azuread/application_known_clients.py +50 -44
- pulumi_azuread/application_optional_claims.py +87 -81
- pulumi_azuread/application_owner.py +76 -42
- pulumi_azuread/application_password.py +159 -205
- pulumi_azuread/application_permission_scope.py +160 -156
- pulumi_azuread/application_pre_authorized.py +120 -236
- pulumi_azuread/application_redirect_uris.py +75 -69
- pulumi_azuread/application_registration.py +315 -309
- pulumi_azuread/authentication_strength_policy.py +73 -67
- pulumi_azuread/claims_mapping_policy.py +48 -42
- pulumi_azuread/conditional_access_policy.py +248 -232
- pulumi_azuread/config/__init__.py +2 -1
- pulumi_azuread/config/__init__.pyi +23 -17
- pulumi_azuread/config/vars.py +47 -37
- pulumi_azuread/custom_directory_role.py +128 -122
- pulumi_azuread/directory_role.py +60 -54
- pulumi_azuread/directory_role_assignment.py +194 -181
- pulumi_azuread/directory_role_eligibility_schedule_request.py +86 -80
- pulumi_azuread/directory_role_member.py +54 -48
- pulumi_azuread/get_access_package.py +45 -31
- pulumi_azuread/get_access_package_catalog.py +40 -27
- pulumi_azuread/get_access_package_catalog_role.py +39 -25
- pulumi_azuread/get_administrative_unit.py +42 -27
- pulumi_azuread/get_application.py +135 -94
- pulumi_azuread/get_application_published_app_ids.py +42 -47
- pulumi_azuread/get_application_template.py +49 -33
- pulumi_azuread/get_client_config.py +24 -15
- pulumi_azuread/get_directory_object.py +32 -21
- pulumi_azuread/get_directory_role_templates.py +20 -12
- pulumi_azuread/get_directory_roles.py +23 -14
- pulumi_azuread/get_domains.py +65 -46
- pulumi_azuread/get_group.py +147 -88
- pulumi_azuread/get_group_role_management_policy.py +178 -0
- pulumi_azuread/get_groups.py +71 -51
- pulumi_azuread/get_named_location.py +47 -22
- pulumi_azuread/get_service_principal.py +108 -90
- pulumi_azuread/get_service_principals.py +60 -64
- pulumi_azuread/get_user.py +186 -118
- pulumi_azuread/get_users.py +96 -53
- pulumi_azuread/group.py +622 -464
- pulumi_azuread/group_member.py +56 -50
- pulumi_azuread/group_role_management_policy.py +544 -0
- pulumi_azuread/group_without_members.py +1610 -0
- pulumi_azuread/invitation.py +126 -120
- pulumi_azuread/named_location.py +90 -76
- pulumi_azuread/outputs.py +2844 -1308
- pulumi_azuread/privileged_access_group_assignment_schedule.py +695 -0
- pulumi_azuread/privileged_access_group_eligibility_schedule.py +695 -0
- pulumi_azuread/provider.py +292 -246
- pulumi_azuread/pulumi-plugin.json +2 -1
- pulumi_azuread/service_principal.py +400 -461
- pulumi_azuread/service_principal_certificate.py +230 -145
- pulumi_azuread/service_principal_claims_mapping_policy_assignment.py +53 -47
- pulumi_azuread/service_principal_delegated_permission_grant.py +146 -140
- pulumi_azuread/service_principal_password.py +156 -141
- pulumi_azuread/service_principal_token_signing_certificate.py +119 -124
- pulumi_azuread/synchronization_job.py +105 -111
- pulumi_azuread/synchronization_job_provision_on_demand.py +396 -0
- pulumi_azuread/synchronization_secret.py +64 -70
- pulumi_azuread/user.py +776 -730
- pulumi_azuread/user_flow_attribute.py +76 -70
- {pulumi_azuread-5.48.0a1706744699.dist-info → pulumi_azuread-6.8.0a1766208344.dist-info}/METADATA +21 -20
- pulumi_azuread-6.8.0a1766208344.dist-info/RECORD +87 -0
- {pulumi_azuread-5.48.0a1706744699.dist-info → pulumi_azuread-6.8.0a1766208344.dist-info}/WHEEL +1 -1
- pulumi_azuread-5.48.0a1706744699.dist-info/RECORD +0 -81
- {pulumi_azuread-5.48.0a1706744699.dist-info → pulumi_azuread-6.8.0a1766208344.dist-info}/top_level.txt +0 -0
pulumi_azuread/application.py
CHANGED
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,69 +21,73 @@ __all__ = ['ApplicationArgs', 'Application']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class ApplicationArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
display_name: pulumi.Input[str],
|
|
24
|
+
display_name: pulumi.Input[_builtins.str],
|
|
20
25
|
api: Optional[pulumi.Input['ApplicationApiArgs']] = None,
|
|
21
26
|
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]]] = None,
|
|
22
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
23
|
-
device_only_auth_enabled: Optional[pulumi.Input[bool]] = None,
|
|
24
|
-
fallback_public_client_enabled: Optional[pulumi.Input[bool]] = None,
|
|
27
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
device_only_auth_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
29
|
+
fallback_public_client_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
25
30
|
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]]] = None,
|
|
26
|
-
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
27
|
-
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
28
|
-
logo_image: Optional[pulumi.Input[str]] = None,
|
|
29
|
-
marketing_url: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
notes: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
oauth2_post_response_required: Optional[pulumi.Input[bool]] = None,
|
|
31
|
+
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
32
|
+
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
33
|
+
logo_image: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
marketing_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
notes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
oauth2_post_response_required: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
37
|
optional_claims: Optional[pulumi.Input['ApplicationOptionalClaimsArgs']] = None,
|
|
33
|
-
owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
34
|
-
|
|
35
|
-
|
|
38
|
+
owners: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
39
|
+
password: Optional[pulumi.Input['ApplicationPasswordArgs']] = None,
|
|
40
|
+
prevent_duplicate_names: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
41
|
+
privacy_statement_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
42
|
public_client: Optional[pulumi.Input['ApplicationPublicClientArgs']] = None,
|
|
37
43
|
required_resource_accesses: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]]] = None,
|
|
38
|
-
service_management_reference: Optional[pulumi.Input[str]] = None,
|
|
39
|
-
sign_in_audience: Optional[pulumi.Input[str]] = None,
|
|
44
|
+
service_management_reference: Optional[pulumi.Input[_builtins.str]] = None,
|
|
45
|
+
sign_in_audience: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
46
|
single_page_application: Optional[pulumi.Input['ApplicationSinglePageApplicationArgs']] = None,
|
|
41
|
-
support_url: Optional[pulumi.Input[str]] = None,
|
|
42
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
43
|
-
template_id: Optional[pulumi.Input[str]] = None,
|
|
44
|
-
terms_of_service_url: Optional[pulumi.Input[str]] = None,
|
|
47
|
+
support_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
49
|
+
template_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
50
|
+
terms_of_service_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
45
51
|
web: Optional[pulumi.Input['ApplicationWebArgs']] = None):
|
|
46
52
|
"""
|
|
47
53
|
The set of arguments for constructing a Application resource.
|
|
48
|
-
:param pulumi.Input[str] display_name: The display name for the application.
|
|
54
|
+
:param pulumi.Input[_builtins.str] display_name: The display name for the application.
|
|
49
55
|
:param pulumi.Input['ApplicationApiArgs'] api: An `api` block as documented below, which configures API related settings for this application.
|
|
50
56
|
:param pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]] app_roles: A collection of `app_role` blocks as documented below. For more information see [official documentation on Application Roles](https://docs.microsoft.com/en-us/azure/architecture/multitenant-identity/app-roles).
|
|
51
|
-
:param pulumi.Input[str] description: A description of the application, as shown to end users.
|
|
52
|
-
:param pulumi.Input[bool] device_only_auth_enabled: Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
53
|
-
:param pulumi.Input[bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
57
|
+
:param pulumi.Input[_builtins.str] description: A description of the application, as shown to end users.
|
|
58
|
+
:param pulumi.Input[_builtins.bool] device_only_auth_enabled: Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
59
|
+
:param pulumi.Input[_builtins.bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
54
60
|
:param pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]] feature_tags: A `feature_tags` block as described below. Cannot be used together with the `tags` property.
|
|
55
61
|
|
|
56
62
|
> **Features and Tags** Features are configured for an application using tags, and are provided as a shortcut to set the corresponding magic tag value for each feature. You cannot configure `feature_tags` and `tags` for an application at the same time, so if you need to assign additional custom tags it's recommended to use the `tags` property instead. Tag values also propagate to any linked service principals.
|
|
57
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_membership_claims:
|
|
58
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
59
|
-
:param pulumi.Input[str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
60
|
-
:param pulumi.Input[str] marketing_url: URL of the application's marketing page.
|
|
61
|
-
:param pulumi.Input[str] notes: User-specified notes relevant for the management of the application.
|
|
62
|
-
:param pulumi.Input[bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
63
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] group_membership_claims: A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
64
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
65
|
+
:param pulumi.Input[_builtins.str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
66
|
+
:param pulumi.Input[_builtins.str] marketing_url: URL of the application's marketing page.
|
|
67
|
+
:param pulumi.Input[_builtins.str] notes: User-specified notes relevant for the management of the application.
|
|
68
|
+
:param pulumi.Input[_builtins.bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
63
69
|
:param pulumi.Input['ApplicationOptionalClaimsArgs'] optional_claims: An `optional_claims` block as documented below.
|
|
64
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
|
|
70
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
71
|
+
:param pulumi.Input['ApplicationPasswordArgs'] password: A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
72
|
+
|
|
73
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
74
|
+
:param pulumi.Input[_builtins.bool] prevent_duplicate_names: If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
75
|
+
:param pulumi.Input[_builtins.str] privacy_statement_url: URL of the application's privacy statement.
|
|
67
76
|
:param pulumi.Input['ApplicationPublicClientArgs'] public_client: A `public_client` block as documented below, which configures non-web app or non-web API application settings, for example mobile or other public clients such as an installed application running on a desktop device.
|
|
68
77
|
:param pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]] required_resource_accesses: A collection of `required_resource_access` blocks as documented below.
|
|
69
|
-
:param pulumi.Input[str] service_management_reference: References application context information from a Service or Asset Management database.
|
|
70
|
-
:param pulumi.Input[str] sign_in_audience: The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
78
|
+
:param pulumi.Input[_builtins.str] service_management_reference: References application context information from a Service or Asset Management database.
|
|
79
|
+
:param pulumi.Input[_builtins.str] sign_in_audience: The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
71
80
|
|
|
72
81
|
> **Changing `sign_in_audience` for existing applications** When updating an existing application to use a `sign_in_audience` value of `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`, your configuration may no longer be valid. Refer to [official documentation](https://docs.microsoft.com/en-gb/azure/active-directory/develop/supported-accounts-validation) to understand the differences in supported configurations. Where possible, the provider will attempt to validate your configuration and try to avoid applying unsupported settings to your application.
|
|
73
82
|
:param pulumi.Input['ApplicationSinglePageApplicationArgs'] single_page_application: A `single_page_application` block as documented below, which configures single-page application (SPA) related settings for this application.
|
|
74
|
-
:param pulumi.Input[str] support_url: URL of the application's support page.
|
|
75
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
83
|
+
:param pulumi.Input[_builtins.str] support_url: URL of the application's support page.
|
|
84
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
76
85
|
|
|
77
86
|
> **Tags and Features** Azure Active Directory uses special tag values to configure the behavior of applications. These can be specified using either the `tags` property or with the `feature_tags` block. If you need to set any custom tag values not supported by the `feature_tags` block, it's recommended to use the `tags` property. Tag values also propagate to any linked service principals.
|
|
78
|
-
:param pulumi.Input[str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
87
|
+
:param pulumi.Input[_builtins.str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
79
88
|
|
|
80
89
|
> **Tip for Gallery Applications** This resource can be used to instantiate a gallery application, however it will also attempt to manage the properties of the resulting application. If this is not desired, consider using the ApplicationRegistration resource instead.
|
|
81
|
-
:param pulumi.Input[str] terms_of_service_url: URL of the application's terms of service statement.
|
|
90
|
+
:param pulumi.Input[_builtins.str] terms_of_service_url: URL of the application's terms of service statement.
|
|
82
91
|
:param pulumi.Input['ApplicationWebArgs'] web: A `web` block as documented below, which configures web related settings for this application.
|
|
83
92
|
|
|
84
93
|
> **Application Name Uniqueness** Application names are not unique within Azure Active Directory. Use the `prevent_duplicate_names` argument to check for existing applications if you want to avoid name collisions.
|
|
@@ -112,6 +121,8 @@ class ApplicationArgs:
|
|
|
112
121
|
pulumi.set(__self__, "optional_claims", optional_claims)
|
|
113
122
|
if owners is not None:
|
|
114
123
|
pulumi.set(__self__, "owners", owners)
|
|
124
|
+
if password is not None:
|
|
125
|
+
pulumi.set(__self__, "password", password)
|
|
115
126
|
if prevent_duplicate_names is not None:
|
|
116
127
|
pulumi.set(__self__, "prevent_duplicate_names", prevent_duplicate_names)
|
|
117
128
|
if privacy_statement_url is not None:
|
|
@@ -137,19 +148,19 @@ class ApplicationArgs:
|
|
|
137
148
|
if web is not None:
|
|
138
149
|
pulumi.set(__self__, "web", web)
|
|
139
150
|
|
|
140
|
-
@property
|
|
151
|
+
@_builtins.property
|
|
141
152
|
@pulumi.getter(name="displayName")
|
|
142
|
-
def display_name(self) -> pulumi.Input[str]:
|
|
153
|
+
def display_name(self) -> pulumi.Input[_builtins.str]:
|
|
143
154
|
"""
|
|
144
155
|
The display name for the application.
|
|
145
156
|
"""
|
|
146
157
|
return pulumi.get(self, "display_name")
|
|
147
158
|
|
|
148
159
|
@display_name.setter
|
|
149
|
-
def display_name(self, value: pulumi.Input[str]):
|
|
160
|
+
def display_name(self, value: pulumi.Input[_builtins.str]):
|
|
150
161
|
pulumi.set(self, "display_name", value)
|
|
151
162
|
|
|
152
|
-
@property
|
|
163
|
+
@_builtins.property
|
|
153
164
|
@pulumi.getter
|
|
154
165
|
def api(self) -> Optional[pulumi.Input['ApplicationApiArgs']]:
|
|
155
166
|
"""
|
|
@@ -161,7 +172,7 @@ class ApplicationArgs:
|
|
|
161
172
|
def api(self, value: Optional[pulumi.Input['ApplicationApiArgs']]):
|
|
162
173
|
pulumi.set(self, "api", value)
|
|
163
174
|
|
|
164
|
-
@property
|
|
175
|
+
@_builtins.property
|
|
165
176
|
@pulumi.getter(name="appRoles")
|
|
166
177
|
def app_roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]]]:
|
|
167
178
|
"""
|
|
@@ -173,43 +184,43 @@ class ApplicationArgs:
|
|
|
173
184
|
def app_roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]]]):
|
|
174
185
|
pulumi.set(self, "app_roles", value)
|
|
175
186
|
|
|
176
|
-
@property
|
|
187
|
+
@_builtins.property
|
|
177
188
|
@pulumi.getter
|
|
178
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
189
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
179
190
|
"""
|
|
180
191
|
A description of the application, as shown to end users.
|
|
181
192
|
"""
|
|
182
193
|
return pulumi.get(self, "description")
|
|
183
194
|
|
|
184
195
|
@description.setter
|
|
185
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
196
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
186
197
|
pulumi.set(self, "description", value)
|
|
187
198
|
|
|
188
|
-
@property
|
|
199
|
+
@_builtins.property
|
|
189
200
|
@pulumi.getter(name="deviceOnlyAuthEnabled")
|
|
190
|
-
def device_only_auth_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
201
|
+
def device_only_auth_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
191
202
|
"""
|
|
192
203
|
Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
193
204
|
"""
|
|
194
205
|
return pulumi.get(self, "device_only_auth_enabled")
|
|
195
206
|
|
|
196
207
|
@device_only_auth_enabled.setter
|
|
197
|
-
def device_only_auth_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
208
|
+
def device_only_auth_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
198
209
|
pulumi.set(self, "device_only_auth_enabled", value)
|
|
199
210
|
|
|
200
|
-
@property
|
|
211
|
+
@_builtins.property
|
|
201
212
|
@pulumi.getter(name="fallbackPublicClientEnabled")
|
|
202
|
-
def fallback_public_client_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
213
|
+
def fallback_public_client_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
203
214
|
"""
|
|
204
215
|
Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
205
216
|
"""
|
|
206
217
|
return pulumi.get(self, "fallback_public_client_enabled")
|
|
207
218
|
|
|
208
219
|
@fallback_public_client_enabled.setter
|
|
209
|
-
def fallback_public_client_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
220
|
+
def fallback_public_client_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
210
221
|
pulumi.set(self, "fallback_public_client_enabled", value)
|
|
211
222
|
|
|
212
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
213
224
|
@pulumi.getter(name="featureTags")
|
|
214
225
|
def feature_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]]]:
|
|
215
226
|
"""
|
|
@@ -223,79 +234,79 @@ class ApplicationArgs:
|
|
|
223
234
|
def feature_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]]]):
|
|
224
235
|
pulumi.set(self, "feature_tags", value)
|
|
225
236
|
|
|
226
|
-
@property
|
|
237
|
+
@_builtins.property
|
|
227
238
|
@pulumi.getter(name="groupMembershipClaims")
|
|
228
|
-
def group_membership_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
239
|
+
def group_membership_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
229
240
|
"""
|
|
230
|
-
|
|
241
|
+
A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
231
242
|
"""
|
|
232
243
|
return pulumi.get(self, "group_membership_claims")
|
|
233
244
|
|
|
234
245
|
@group_membership_claims.setter
|
|
235
|
-
def group_membership_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
246
|
+
def group_membership_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
236
247
|
pulumi.set(self, "group_membership_claims", value)
|
|
237
248
|
|
|
238
|
-
@property
|
|
249
|
+
@_builtins.property
|
|
239
250
|
@pulumi.getter(name="identifierUris")
|
|
240
|
-
def identifier_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
251
|
+
def identifier_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
241
252
|
"""
|
|
242
253
|
A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
243
254
|
"""
|
|
244
255
|
return pulumi.get(self, "identifier_uris")
|
|
245
256
|
|
|
246
257
|
@identifier_uris.setter
|
|
247
|
-
def identifier_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
258
|
+
def identifier_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
248
259
|
pulumi.set(self, "identifier_uris", value)
|
|
249
260
|
|
|
250
|
-
@property
|
|
261
|
+
@_builtins.property
|
|
251
262
|
@pulumi.getter(name="logoImage")
|
|
252
|
-
def logo_image(self) -> Optional[pulumi.Input[str]]:
|
|
263
|
+
def logo_image(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
253
264
|
"""
|
|
254
265
|
A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
255
266
|
"""
|
|
256
267
|
return pulumi.get(self, "logo_image")
|
|
257
268
|
|
|
258
269
|
@logo_image.setter
|
|
259
|
-
def logo_image(self, value: Optional[pulumi.Input[str]]):
|
|
270
|
+
def logo_image(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
260
271
|
pulumi.set(self, "logo_image", value)
|
|
261
272
|
|
|
262
|
-
@property
|
|
273
|
+
@_builtins.property
|
|
263
274
|
@pulumi.getter(name="marketingUrl")
|
|
264
|
-
def marketing_url(self) -> Optional[pulumi.Input[str]]:
|
|
275
|
+
def marketing_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
265
276
|
"""
|
|
266
277
|
URL of the application's marketing page.
|
|
267
278
|
"""
|
|
268
279
|
return pulumi.get(self, "marketing_url")
|
|
269
280
|
|
|
270
281
|
@marketing_url.setter
|
|
271
|
-
def marketing_url(self, value: Optional[pulumi.Input[str]]):
|
|
282
|
+
def marketing_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
272
283
|
pulumi.set(self, "marketing_url", value)
|
|
273
284
|
|
|
274
|
-
@property
|
|
285
|
+
@_builtins.property
|
|
275
286
|
@pulumi.getter
|
|
276
|
-
def notes(self) -> Optional[pulumi.Input[str]]:
|
|
287
|
+
def notes(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
277
288
|
"""
|
|
278
289
|
User-specified notes relevant for the management of the application.
|
|
279
290
|
"""
|
|
280
291
|
return pulumi.get(self, "notes")
|
|
281
292
|
|
|
282
293
|
@notes.setter
|
|
283
|
-
def notes(self, value: Optional[pulumi.Input[str]]):
|
|
294
|
+
def notes(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
284
295
|
pulumi.set(self, "notes", value)
|
|
285
296
|
|
|
286
|
-
@property
|
|
297
|
+
@_builtins.property
|
|
287
298
|
@pulumi.getter(name="oauth2PostResponseRequired")
|
|
288
|
-
def oauth2_post_response_required(self) -> Optional[pulumi.Input[bool]]:
|
|
299
|
+
def oauth2_post_response_required(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
289
300
|
"""
|
|
290
301
|
Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
291
302
|
"""
|
|
292
303
|
return pulumi.get(self, "oauth2_post_response_required")
|
|
293
304
|
|
|
294
305
|
@oauth2_post_response_required.setter
|
|
295
|
-
def oauth2_post_response_required(self, value: Optional[pulumi.Input[bool]]):
|
|
306
|
+
def oauth2_post_response_required(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
296
307
|
pulumi.set(self, "oauth2_post_response_required", value)
|
|
297
308
|
|
|
298
|
-
@property
|
|
309
|
+
@_builtins.property
|
|
299
310
|
@pulumi.getter(name="optionalClaims")
|
|
300
311
|
def optional_claims(self) -> Optional[pulumi.Input['ApplicationOptionalClaimsArgs']]:
|
|
301
312
|
"""
|
|
@@ -307,43 +318,57 @@ class ApplicationArgs:
|
|
|
307
318
|
def optional_claims(self, value: Optional[pulumi.Input['ApplicationOptionalClaimsArgs']]):
|
|
308
319
|
pulumi.set(self, "optional_claims", value)
|
|
309
320
|
|
|
310
|
-
@property
|
|
321
|
+
@_builtins.property
|
|
311
322
|
@pulumi.getter
|
|
312
|
-
def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
323
|
+
def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
313
324
|
"""
|
|
314
325
|
A list of object IDs of principals that will be granted ownership of the application
|
|
315
326
|
"""
|
|
316
327
|
return pulumi.get(self, "owners")
|
|
317
328
|
|
|
318
329
|
@owners.setter
|
|
319
|
-
def owners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
330
|
+
def owners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
320
331
|
pulumi.set(self, "owners", value)
|
|
321
332
|
|
|
322
|
-
@property
|
|
333
|
+
@_builtins.property
|
|
334
|
+
@pulumi.getter
|
|
335
|
+
def password(self) -> Optional[pulumi.Input['ApplicationPasswordArgs']]:
|
|
336
|
+
"""
|
|
337
|
+
A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
338
|
+
|
|
339
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
340
|
+
"""
|
|
341
|
+
return pulumi.get(self, "password")
|
|
342
|
+
|
|
343
|
+
@password.setter
|
|
344
|
+
def password(self, value: Optional[pulumi.Input['ApplicationPasswordArgs']]):
|
|
345
|
+
pulumi.set(self, "password", value)
|
|
346
|
+
|
|
347
|
+
@_builtins.property
|
|
323
348
|
@pulumi.getter(name="preventDuplicateNames")
|
|
324
|
-
def prevent_duplicate_names(self) -> Optional[pulumi.Input[bool]]:
|
|
349
|
+
def prevent_duplicate_names(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
325
350
|
"""
|
|
326
351
|
If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
327
352
|
"""
|
|
328
353
|
return pulumi.get(self, "prevent_duplicate_names")
|
|
329
354
|
|
|
330
355
|
@prevent_duplicate_names.setter
|
|
331
|
-
def prevent_duplicate_names(self, value: Optional[pulumi.Input[bool]]):
|
|
356
|
+
def prevent_duplicate_names(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
332
357
|
pulumi.set(self, "prevent_duplicate_names", value)
|
|
333
358
|
|
|
334
|
-
@property
|
|
359
|
+
@_builtins.property
|
|
335
360
|
@pulumi.getter(name="privacyStatementUrl")
|
|
336
|
-
def privacy_statement_url(self) -> Optional[pulumi.Input[str]]:
|
|
361
|
+
def privacy_statement_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
337
362
|
"""
|
|
338
363
|
URL of the application's privacy statement.
|
|
339
364
|
"""
|
|
340
365
|
return pulumi.get(self, "privacy_statement_url")
|
|
341
366
|
|
|
342
367
|
@privacy_statement_url.setter
|
|
343
|
-
def privacy_statement_url(self, value: Optional[pulumi.Input[str]]):
|
|
368
|
+
def privacy_statement_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
344
369
|
pulumi.set(self, "privacy_statement_url", value)
|
|
345
370
|
|
|
346
|
-
@property
|
|
371
|
+
@_builtins.property
|
|
347
372
|
@pulumi.getter(name="publicClient")
|
|
348
373
|
def public_client(self) -> Optional[pulumi.Input['ApplicationPublicClientArgs']]:
|
|
349
374
|
"""
|
|
@@ -355,7 +380,7 @@ class ApplicationArgs:
|
|
|
355
380
|
def public_client(self, value: Optional[pulumi.Input['ApplicationPublicClientArgs']]):
|
|
356
381
|
pulumi.set(self, "public_client", value)
|
|
357
382
|
|
|
358
|
-
@property
|
|
383
|
+
@_builtins.property
|
|
359
384
|
@pulumi.getter(name="requiredResourceAccesses")
|
|
360
385
|
def required_resource_accesses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]]]:
|
|
361
386
|
"""
|
|
@@ -367,21 +392,21 @@ class ApplicationArgs:
|
|
|
367
392
|
def required_resource_accesses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]]]):
|
|
368
393
|
pulumi.set(self, "required_resource_accesses", value)
|
|
369
394
|
|
|
370
|
-
@property
|
|
395
|
+
@_builtins.property
|
|
371
396
|
@pulumi.getter(name="serviceManagementReference")
|
|
372
|
-
def service_management_reference(self) -> Optional[pulumi.Input[str]]:
|
|
397
|
+
def service_management_reference(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
373
398
|
"""
|
|
374
399
|
References application context information from a Service or Asset Management database.
|
|
375
400
|
"""
|
|
376
401
|
return pulumi.get(self, "service_management_reference")
|
|
377
402
|
|
|
378
403
|
@service_management_reference.setter
|
|
379
|
-
def service_management_reference(self, value: Optional[pulumi.Input[str]]):
|
|
404
|
+
def service_management_reference(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
380
405
|
pulumi.set(self, "service_management_reference", value)
|
|
381
406
|
|
|
382
|
-
@property
|
|
407
|
+
@_builtins.property
|
|
383
408
|
@pulumi.getter(name="signInAudience")
|
|
384
|
-
def sign_in_audience(self) -> Optional[pulumi.Input[str]]:
|
|
409
|
+
def sign_in_audience(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
385
410
|
"""
|
|
386
411
|
The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
387
412
|
|
|
@@ -390,10 +415,10 @@ class ApplicationArgs:
|
|
|
390
415
|
return pulumi.get(self, "sign_in_audience")
|
|
391
416
|
|
|
392
417
|
@sign_in_audience.setter
|
|
393
|
-
def sign_in_audience(self, value: Optional[pulumi.Input[str]]):
|
|
418
|
+
def sign_in_audience(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
394
419
|
pulumi.set(self, "sign_in_audience", value)
|
|
395
420
|
|
|
396
|
-
@property
|
|
421
|
+
@_builtins.property
|
|
397
422
|
@pulumi.getter(name="singlePageApplication")
|
|
398
423
|
def single_page_application(self) -> Optional[pulumi.Input['ApplicationSinglePageApplicationArgs']]:
|
|
399
424
|
"""
|
|
@@ -405,21 +430,21 @@ class ApplicationArgs:
|
|
|
405
430
|
def single_page_application(self, value: Optional[pulumi.Input['ApplicationSinglePageApplicationArgs']]):
|
|
406
431
|
pulumi.set(self, "single_page_application", value)
|
|
407
432
|
|
|
408
|
-
@property
|
|
433
|
+
@_builtins.property
|
|
409
434
|
@pulumi.getter(name="supportUrl")
|
|
410
|
-
def support_url(self) -> Optional[pulumi.Input[str]]:
|
|
435
|
+
def support_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
411
436
|
"""
|
|
412
437
|
URL of the application's support page.
|
|
413
438
|
"""
|
|
414
439
|
return pulumi.get(self, "support_url")
|
|
415
440
|
|
|
416
441
|
@support_url.setter
|
|
417
|
-
def support_url(self, value: Optional[pulumi.Input[str]]):
|
|
442
|
+
def support_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
418
443
|
pulumi.set(self, "support_url", value)
|
|
419
444
|
|
|
420
|
-
@property
|
|
445
|
+
@_builtins.property
|
|
421
446
|
@pulumi.getter
|
|
422
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
447
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
423
448
|
"""
|
|
424
449
|
A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
425
450
|
|
|
@@ -428,12 +453,12 @@ class ApplicationArgs:
|
|
|
428
453
|
return pulumi.get(self, "tags")
|
|
429
454
|
|
|
430
455
|
@tags.setter
|
|
431
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
456
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
432
457
|
pulumi.set(self, "tags", value)
|
|
433
458
|
|
|
434
|
-
@property
|
|
459
|
+
@_builtins.property
|
|
435
460
|
@pulumi.getter(name="templateId")
|
|
436
|
-
def template_id(self) -> Optional[pulumi.Input[str]]:
|
|
461
|
+
def template_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
437
462
|
"""
|
|
438
463
|
Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
439
464
|
|
|
@@ -442,22 +467,22 @@ class ApplicationArgs:
|
|
|
442
467
|
return pulumi.get(self, "template_id")
|
|
443
468
|
|
|
444
469
|
@template_id.setter
|
|
445
|
-
def template_id(self, value: Optional[pulumi.Input[str]]):
|
|
470
|
+
def template_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
446
471
|
pulumi.set(self, "template_id", value)
|
|
447
472
|
|
|
448
|
-
@property
|
|
473
|
+
@_builtins.property
|
|
449
474
|
@pulumi.getter(name="termsOfServiceUrl")
|
|
450
|
-
def terms_of_service_url(self) -> Optional[pulumi.Input[str]]:
|
|
475
|
+
def terms_of_service_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
451
476
|
"""
|
|
452
477
|
URL of the application's terms of service statement.
|
|
453
478
|
"""
|
|
454
479
|
return pulumi.get(self, "terms_of_service_url")
|
|
455
480
|
|
|
456
481
|
@terms_of_service_url.setter
|
|
457
|
-
def terms_of_service_url(self, value: Optional[pulumi.Input[str]]):
|
|
482
|
+
def terms_of_service_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
458
483
|
pulumi.set(self, "terms_of_service_url", value)
|
|
459
484
|
|
|
460
|
-
@property
|
|
485
|
+
@_builtins.property
|
|
461
486
|
@pulumi.getter
|
|
462
487
|
def web(self) -> Optional[pulumi.Input['ApplicationWebArgs']]:
|
|
463
488
|
"""
|
|
@@ -476,84 +501,86 @@ class ApplicationArgs:
|
|
|
476
501
|
class _ApplicationState:
|
|
477
502
|
def __init__(__self__, *,
|
|
478
503
|
api: Optional[pulumi.Input['ApplicationApiArgs']] = None,
|
|
479
|
-
app_role_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
504
|
+
app_role_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
480
505
|
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]]] = None,
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
fallback_public_client_enabled: Optional[pulumi.Input[bool]] = None,
|
|
506
|
+
client_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
507
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
508
|
+
device_only_auth_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
509
|
+
disabled_by_microsoft: Optional[pulumi.Input[_builtins.str]] = None,
|
|
510
|
+
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
511
|
+
fallback_public_client_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
488
512
|
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]]] = None,
|
|
489
|
-
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
490
|
-
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
491
|
-
logo_image: Optional[pulumi.Input[str]] = None,
|
|
492
|
-
logo_url: Optional[pulumi.Input[str]] = None,
|
|
493
|
-
marketing_url: Optional[pulumi.Input[str]] = None,
|
|
494
|
-
notes: Optional[pulumi.Input[str]] = None,
|
|
495
|
-
oauth2_permission_scope_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
496
|
-
oauth2_post_response_required: Optional[pulumi.Input[bool]] = None,
|
|
497
|
-
object_id: Optional[pulumi.Input[str]] = None,
|
|
513
|
+
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
514
|
+
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
515
|
+
logo_image: Optional[pulumi.Input[_builtins.str]] = None,
|
|
516
|
+
logo_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
517
|
+
marketing_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
518
|
+
notes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
519
|
+
oauth2_permission_scope_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
520
|
+
oauth2_post_response_required: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
521
|
+
object_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
498
522
|
optional_claims: Optional[pulumi.Input['ApplicationOptionalClaimsArgs']] = None,
|
|
499
|
-
owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
500
|
-
|
|
501
|
-
|
|
523
|
+
owners: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
524
|
+
password: Optional[pulumi.Input['ApplicationPasswordArgs']] = None,
|
|
525
|
+
prevent_duplicate_names: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
526
|
+
privacy_statement_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
502
527
|
public_client: Optional[pulumi.Input['ApplicationPublicClientArgs']] = None,
|
|
503
|
-
publisher_domain: Optional[pulumi.Input[str]] = None,
|
|
528
|
+
publisher_domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
504
529
|
required_resource_accesses: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]]] = None,
|
|
505
|
-
service_management_reference: Optional[pulumi.Input[str]] = None,
|
|
506
|
-
sign_in_audience: Optional[pulumi.Input[str]] = None,
|
|
530
|
+
service_management_reference: Optional[pulumi.Input[_builtins.str]] = None,
|
|
531
|
+
sign_in_audience: Optional[pulumi.Input[_builtins.str]] = None,
|
|
507
532
|
single_page_application: Optional[pulumi.Input['ApplicationSinglePageApplicationArgs']] = None,
|
|
508
|
-
support_url: Optional[pulumi.Input[str]] = None,
|
|
509
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
510
|
-
template_id: Optional[pulumi.Input[str]] = None,
|
|
511
|
-
terms_of_service_url: Optional[pulumi.Input[str]] = None,
|
|
533
|
+
support_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
534
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
535
|
+
template_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
536
|
+
terms_of_service_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
512
537
|
web: Optional[pulumi.Input['ApplicationWebArgs']] = None):
|
|
513
538
|
"""
|
|
514
539
|
Input properties used for looking up and filtering Application resources.
|
|
515
540
|
:param pulumi.Input['ApplicationApiArgs'] api: An `api` block as documented below, which configures API related settings for this application.
|
|
516
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] app_role_ids: A mapping of app role values to app role IDs, intended to be useful when referencing app roles in other resources in your configuration.
|
|
541
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] app_role_ids: A mapping of app role values to app role IDs, intended to be useful when referencing app roles in other resources in your configuration.
|
|
517
542
|
:param pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]] app_roles: A collection of `app_role` blocks as documented below. For more information see [official documentation on Application Roles](https://docs.microsoft.com/en-us/azure/architecture/multitenant-identity/app-roles).
|
|
518
|
-
:param pulumi.Input[str]
|
|
519
|
-
:param pulumi.Input[str]
|
|
520
|
-
:param pulumi.Input[
|
|
521
|
-
:param pulumi.Input[
|
|
522
|
-
:param pulumi.Input[str]
|
|
523
|
-
:param pulumi.Input[
|
|
524
|
-
:param pulumi.Input[bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
543
|
+
:param pulumi.Input[_builtins.str] client_id: The Client ID for the application.
|
|
544
|
+
:param pulumi.Input[_builtins.str] description: A description of the application, as shown to end users.
|
|
545
|
+
:param pulumi.Input[_builtins.bool] device_only_auth_enabled: Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
546
|
+
:param pulumi.Input[_builtins.str] disabled_by_microsoft: Whether Microsoft has disabled the registered application. If the application is disabled, this will be a string indicating the status/reason, e.g. `DisabledDueToViolationOfServicesAgreement`
|
|
547
|
+
:param pulumi.Input[_builtins.str] display_name: The display name for the application.
|
|
548
|
+
:param pulumi.Input[_builtins.bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
525
549
|
:param pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]] feature_tags: A `feature_tags` block as described below. Cannot be used together with the `tags` property.
|
|
526
550
|
|
|
527
551
|
> **Features and Tags** Features are configured for an application using tags, and are provided as a shortcut to set the corresponding magic tag value for each feature. You cannot configure `feature_tags` and `tags` for an application at the same time, so if you need to assign additional custom tags it's recommended to use the `tags` property instead. Tag values also propagate to any linked service principals.
|
|
528
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_membership_claims:
|
|
529
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
530
|
-
:param pulumi.Input[str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
531
|
-
:param pulumi.Input[str] logo_url: CDN URL to the application's logo, as uploaded with the `logo_image` property.
|
|
532
|
-
:param pulumi.Input[str] marketing_url: URL of the application's marketing page.
|
|
533
|
-
:param pulumi.Input[str] notes: User-specified notes relevant for the management of the application.
|
|
534
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] oauth2_permission_scope_ids: A mapping of OAuth2.0 permission scope values to scope IDs, intended to be useful when referencing permission scopes in other resources in your configuration.
|
|
535
|
-
:param pulumi.Input[bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
536
|
-
:param pulumi.Input[str] object_id: The application's object ID.
|
|
552
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] group_membership_claims: A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
553
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
554
|
+
:param pulumi.Input[_builtins.str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
555
|
+
:param pulumi.Input[_builtins.str] logo_url: CDN URL to the application's logo, as uploaded with the `logo_image` property.
|
|
556
|
+
:param pulumi.Input[_builtins.str] marketing_url: URL of the application's marketing page.
|
|
557
|
+
:param pulumi.Input[_builtins.str] notes: User-specified notes relevant for the management of the application.
|
|
558
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] oauth2_permission_scope_ids: A mapping of OAuth2.0 permission scope values to scope IDs, intended to be useful when referencing permission scopes in other resources in your configuration.
|
|
559
|
+
:param pulumi.Input[_builtins.bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
560
|
+
:param pulumi.Input[_builtins.str] object_id: The application's object ID.
|
|
537
561
|
:param pulumi.Input['ApplicationOptionalClaimsArgs'] optional_claims: An `optional_claims` block as documented below.
|
|
538
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
539
|
-
:param pulumi.Input[
|
|
540
|
-
|
|
562
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
563
|
+
:param pulumi.Input['ApplicationPasswordArgs'] password: A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
564
|
+
|
|
565
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
566
|
+
:param pulumi.Input[_builtins.bool] prevent_duplicate_names: If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
567
|
+
:param pulumi.Input[_builtins.str] privacy_statement_url: URL of the application's privacy statement.
|
|
541
568
|
:param pulumi.Input['ApplicationPublicClientArgs'] public_client: A `public_client` block as documented below, which configures non-web app or non-web API application settings, for example mobile or other public clients such as an installed application running on a desktop device.
|
|
542
|
-
:param pulumi.Input[str] publisher_domain: The verified publisher domain for the application.
|
|
569
|
+
:param pulumi.Input[_builtins.str] publisher_domain: The verified publisher domain for the application.
|
|
543
570
|
:param pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]] required_resource_accesses: A collection of `required_resource_access` blocks as documented below.
|
|
544
|
-
:param pulumi.Input[str] service_management_reference: References application context information from a Service or Asset Management database.
|
|
545
|
-
:param pulumi.Input[str] sign_in_audience: The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
571
|
+
:param pulumi.Input[_builtins.str] service_management_reference: References application context information from a Service or Asset Management database.
|
|
572
|
+
:param pulumi.Input[_builtins.str] sign_in_audience: The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
546
573
|
|
|
547
574
|
> **Changing `sign_in_audience` for existing applications** When updating an existing application to use a `sign_in_audience` value of `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`, your configuration may no longer be valid. Refer to [official documentation](https://docs.microsoft.com/en-gb/azure/active-directory/develop/supported-accounts-validation) to understand the differences in supported configurations. Where possible, the provider will attempt to validate your configuration and try to avoid applying unsupported settings to your application.
|
|
548
575
|
:param pulumi.Input['ApplicationSinglePageApplicationArgs'] single_page_application: A `single_page_application` block as documented below, which configures single-page application (SPA) related settings for this application.
|
|
549
|
-
:param pulumi.Input[str] support_url: URL of the application's support page.
|
|
550
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
576
|
+
:param pulumi.Input[_builtins.str] support_url: URL of the application's support page.
|
|
577
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
551
578
|
|
|
552
579
|
> **Tags and Features** Azure Active Directory uses special tag values to configure the behavior of applications. These can be specified using either the `tags` property or with the `feature_tags` block. If you need to set any custom tag values not supported by the `feature_tags` block, it's recommended to use the `tags` property. Tag values also propagate to any linked service principals.
|
|
553
|
-
:param pulumi.Input[str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
580
|
+
:param pulumi.Input[_builtins.str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
554
581
|
|
|
555
582
|
> **Tip for Gallery Applications** This resource can be used to instantiate a gallery application, however it will also attempt to manage the properties of the resulting application. If this is not desired, consider using the ApplicationRegistration resource instead.
|
|
556
|
-
:param pulumi.Input[str] terms_of_service_url: URL of the application's terms of service statement.
|
|
583
|
+
:param pulumi.Input[_builtins.str] terms_of_service_url: URL of the application's terms of service statement.
|
|
557
584
|
:param pulumi.Input['ApplicationWebArgs'] web: A `web` block as documented below, which configures web related settings for this application.
|
|
558
585
|
|
|
559
586
|
> **Application Name Uniqueness** Application names are not unique within Azure Active Directory. Use the `prevent_duplicate_names` argument to check for existing applications if you want to avoid name collisions.
|
|
@@ -564,11 +591,6 @@ class _ApplicationState:
|
|
|
564
591
|
pulumi.set(__self__, "app_role_ids", app_role_ids)
|
|
565
592
|
if app_roles is not None:
|
|
566
593
|
pulumi.set(__self__, "app_roles", app_roles)
|
|
567
|
-
if application_id is not None:
|
|
568
|
-
warnings.warn("""The `application_id` attribute has been replaced by the `client_id` attribute and will be removed in version 3.0 of the AzureAD provider""", DeprecationWarning)
|
|
569
|
-
pulumi.log.warn("""application_id is deprecated: The `application_id` attribute has been replaced by the `client_id` attribute and will be removed in version 3.0 of the AzureAD provider""")
|
|
570
|
-
if application_id is not None:
|
|
571
|
-
pulumi.set(__self__, "application_id", application_id)
|
|
572
594
|
if client_id is not None:
|
|
573
595
|
pulumi.set(__self__, "client_id", client_id)
|
|
574
596
|
if description is not None:
|
|
@@ -605,6 +627,8 @@ class _ApplicationState:
|
|
|
605
627
|
pulumi.set(__self__, "optional_claims", optional_claims)
|
|
606
628
|
if owners is not None:
|
|
607
629
|
pulumi.set(__self__, "owners", owners)
|
|
630
|
+
if password is not None:
|
|
631
|
+
pulumi.set(__self__, "password", password)
|
|
608
632
|
if prevent_duplicate_names is not None:
|
|
609
633
|
pulumi.set(__self__, "prevent_duplicate_names", prevent_duplicate_names)
|
|
610
634
|
if privacy_statement_url is not None:
|
|
@@ -632,7 +656,7 @@ class _ApplicationState:
|
|
|
632
656
|
if web is not None:
|
|
633
657
|
pulumi.set(__self__, "web", web)
|
|
634
658
|
|
|
635
|
-
@property
|
|
659
|
+
@_builtins.property
|
|
636
660
|
@pulumi.getter
|
|
637
661
|
def api(self) -> Optional[pulumi.Input['ApplicationApiArgs']]:
|
|
638
662
|
"""
|
|
@@ -644,19 +668,19 @@ class _ApplicationState:
|
|
|
644
668
|
def api(self, value: Optional[pulumi.Input['ApplicationApiArgs']]):
|
|
645
669
|
pulumi.set(self, "api", value)
|
|
646
670
|
|
|
647
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
648
672
|
@pulumi.getter(name="appRoleIds")
|
|
649
|
-
def app_role_ids(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
673
|
+
def app_role_ids(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
650
674
|
"""
|
|
651
675
|
A mapping of app role values to app role IDs, intended to be useful when referencing app roles in other resources in your configuration.
|
|
652
676
|
"""
|
|
653
677
|
return pulumi.get(self, "app_role_ids")
|
|
654
678
|
|
|
655
679
|
@app_role_ids.setter
|
|
656
|
-
def app_role_ids(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
680
|
+
def app_role_ids(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
657
681
|
pulumi.set(self, "app_role_ids", value)
|
|
658
682
|
|
|
659
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
660
684
|
@pulumi.getter(name="appRoles")
|
|
661
685
|
def app_roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]]]:
|
|
662
686
|
"""
|
|
@@ -668,94 +692,79 @@ class _ApplicationState:
|
|
|
668
692
|
def app_roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationAppRoleArgs']]]]):
|
|
669
693
|
pulumi.set(self, "app_roles", value)
|
|
670
694
|
|
|
671
|
-
@property
|
|
672
|
-
@pulumi.getter(name="applicationId")
|
|
673
|
-
def application_id(self) -> Optional[pulumi.Input[str]]:
|
|
674
|
-
"""
|
|
675
|
-
The Application ID (also called Client ID)
|
|
676
|
-
"""
|
|
677
|
-
warnings.warn("""The `application_id` attribute has been replaced by the `client_id` attribute and will be removed in version 3.0 of the AzureAD provider""", DeprecationWarning)
|
|
678
|
-
pulumi.log.warn("""application_id is deprecated: The `application_id` attribute has been replaced by the `client_id` attribute and will be removed in version 3.0 of the AzureAD provider""")
|
|
679
|
-
|
|
680
|
-
return pulumi.get(self, "application_id")
|
|
681
|
-
|
|
682
|
-
@application_id.setter
|
|
683
|
-
def application_id(self, value: Optional[pulumi.Input[str]]):
|
|
684
|
-
pulumi.set(self, "application_id", value)
|
|
685
|
-
|
|
686
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
687
696
|
@pulumi.getter(name="clientId")
|
|
688
|
-
def client_id(self) -> Optional[pulumi.Input[str]]:
|
|
697
|
+
def client_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
689
698
|
"""
|
|
690
699
|
The Client ID for the application.
|
|
691
700
|
"""
|
|
692
701
|
return pulumi.get(self, "client_id")
|
|
693
702
|
|
|
694
703
|
@client_id.setter
|
|
695
|
-
def client_id(self, value: Optional[pulumi.Input[str]]):
|
|
704
|
+
def client_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
696
705
|
pulumi.set(self, "client_id", value)
|
|
697
706
|
|
|
698
|
-
@property
|
|
707
|
+
@_builtins.property
|
|
699
708
|
@pulumi.getter
|
|
700
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
709
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
701
710
|
"""
|
|
702
711
|
A description of the application, as shown to end users.
|
|
703
712
|
"""
|
|
704
713
|
return pulumi.get(self, "description")
|
|
705
714
|
|
|
706
715
|
@description.setter
|
|
707
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
716
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
708
717
|
pulumi.set(self, "description", value)
|
|
709
718
|
|
|
710
|
-
@property
|
|
719
|
+
@_builtins.property
|
|
711
720
|
@pulumi.getter(name="deviceOnlyAuthEnabled")
|
|
712
|
-
def device_only_auth_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
721
|
+
def device_only_auth_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
713
722
|
"""
|
|
714
723
|
Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
715
724
|
"""
|
|
716
725
|
return pulumi.get(self, "device_only_auth_enabled")
|
|
717
726
|
|
|
718
727
|
@device_only_auth_enabled.setter
|
|
719
|
-
def device_only_auth_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
728
|
+
def device_only_auth_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
720
729
|
pulumi.set(self, "device_only_auth_enabled", value)
|
|
721
730
|
|
|
722
|
-
@property
|
|
731
|
+
@_builtins.property
|
|
723
732
|
@pulumi.getter(name="disabledByMicrosoft")
|
|
724
|
-
def disabled_by_microsoft(self) -> Optional[pulumi.Input[str]]:
|
|
733
|
+
def disabled_by_microsoft(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
725
734
|
"""
|
|
726
735
|
Whether Microsoft has disabled the registered application. If the application is disabled, this will be a string indicating the status/reason, e.g. `DisabledDueToViolationOfServicesAgreement`
|
|
727
736
|
"""
|
|
728
737
|
return pulumi.get(self, "disabled_by_microsoft")
|
|
729
738
|
|
|
730
739
|
@disabled_by_microsoft.setter
|
|
731
|
-
def disabled_by_microsoft(self, value: Optional[pulumi.Input[str]]):
|
|
740
|
+
def disabled_by_microsoft(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
732
741
|
pulumi.set(self, "disabled_by_microsoft", value)
|
|
733
742
|
|
|
734
|
-
@property
|
|
743
|
+
@_builtins.property
|
|
735
744
|
@pulumi.getter(name="displayName")
|
|
736
|
-
def display_name(self) -> Optional[pulumi.Input[str]]:
|
|
745
|
+
def display_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
737
746
|
"""
|
|
738
747
|
The display name for the application.
|
|
739
748
|
"""
|
|
740
749
|
return pulumi.get(self, "display_name")
|
|
741
750
|
|
|
742
751
|
@display_name.setter
|
|
743
|
-
def display_name(self, value: Optional[pulumi.Input[str]]):
|
|
752
|
+
def display_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
744
753
|
pulumi.set(self, "display_name", value)
|
|
745
754
|
|
|
746
|
-
@property
|
|
755
|
+
@_builtins.property
|
|
747
756
|
@pulumi.getter(name="fallbackPublicClientEnabled")
|
|
748
|
-
def fallback_public_client_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
757
|
+
def fallback_public_client_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
749
758
|
"""
|
|
750
759
|
Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
751
760
|
"""
|
|
752
761
|
return pulumi.get(self, "fallback_public_client_enabled")
|
|
753
762
|
|
|
754
763
|
@fallback_public_client_enabled.setter
|
|
755
|
-
def fallback_public_client_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
764
|
+
def fallback_public_client_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
756
765
|
pulumi.set(self, "fallback_public_client_enabled", value)
|
|
757
766
|
|
|
758
|
-
@property
|
|
767
|
+
@_builtins.property
|
|
759
768
|
@pulumi.getter(name="featureTags")
|
|
760
769
|
def feature_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]]]:
|
|
761
770
|
"""
|
|
@@ -769,115 +778,115 @@ class _ApplicationState:
|
|
|
769
778
|
def feature_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationFeatureTagArgs']]]]):
|
|
770
779
|
pulumi.set(self, "feature_tags", value)
|
|
771
780
|
|
|
772
|
-
@property
|
|
781
|
+
@_builtins.property
|
|
773
782
|
@pulumi.getter(name="groupMembershipClaims")
|
|
774
|
-
def group_membership_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
783
|
+
def group_membership_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
775
784
|
"""
|
|
776
|
-
|
|
785
|
+
A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
777
786
|
"""
|
|
778
787
|
return pulumi.get(self, "group_membership_claims")
|
|
779
788
|
|
|
780
789
|
@group_membership_claims.setter
|
|
781
|
-
def group_membership_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
790
|
+
def group_membership_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
782
791
|
pulumi.set(self, "group_membership_claims", value)
|
|
783
792
|
|
|
784
|
-
@property
|
|
793
|
+
@_builtins.property
|
|
785
794
|
@pulumi.getter(name="identifierUris")
|
|
786
|
-
def identifier_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
795
|
+
def identifier_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
787
796
|
"""
|
|
788
797
|
A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
789
798
|
"""
|
|
790
799
|
return pulumi.get(self, "identifier_uris")
|
|
791
800
|
|
|
792
801
|
@identifier_uris.setter
|
|
793
|
-
def identifier_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
802
|
+
def identifier_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
794
803
|
pulumi.set(self, "identifier_uris", value)
|
|
795
804
|
|
|
796
|
-
@property
|
|
805
|
+
@_builtins.property
|
|
797
806
|
@pulumi.getter(name="logoImage")
|
|
798
|
-
def logo_image(self) -> Optional[pulumi.Input[str]]:
|
|
807
|
+
def logo_image(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
799
808
|
"""
|
|
800
809
|
A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
801
810
|
"""
|
|
802
811
|
return pulumi.get(self, "logo_image")
|
|
803
812
|
|
|
804
813
|
@logo_image.setter
|
|
805
|
-
def logo_image(self, value: Optional[pulumi.Input[str]]):
|
|
814
|
+
def logo_image(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
806
815
|
pulumi.set(self, "logo_image", value)
|
|
807
816
|
|
|
808
|
-
@property
|
|
817
|
+
@_builtins.property
|
|
809
818
|
@pulumi.getter(name="logoUrl")
|
|
810
|
-
def logo_url(self) -> Optional[pulumi.Input[str]]:
|
|
819
|
+
def logo_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
811
820
|
"""
|
|
812
821
|
CDN URL to the application's logo, as uploaded with the `logo_image` property.
|
|
813
822
|
"""
|
|
814
823
|
return pulumi.get(self, "logo_url")
|
|
815
824
|
|
|
816
825
|
@logo_url.setter
|
|
817
|
-
def logo_url(self, value: Optional[pulumi.Input[str]]):
|
|
826
|
+
def logo_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
818
827
|
pulumi.set(self, "logo_url", value)
|
|
819
828
|
|
|
820
|
-
@property
|
|
829
|
+
@_builtins.property
|
|
821
830
|
@pulumi.getter(name="marketingUrl")
|
|
822
|
-
def marketing_url(self) -> Optional[pulumi.Input[str]]:
|
|
831
|
+
def marketing_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
823
832
|
"""
|
|
824
833
|
URL of the application's marketing page.
|
|
825
834
|
"""
|
|
826
835
|
return pulumi.get(self, "marketing_url")
|
|
827
836
|
|
|
828
837
|
@marketing_url.setter
|
|
829
|
-
def marketing_url(self, value: Optional[pulumi.Input[str]]):
|
|
838
|
+
def marketing_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
830
839
|
pulumi.set(self, "marketing_url", value)
|
|
831
840
|
|
|
832
|
-
@property
|
|
841
|
+
@_builtins.property
|
|
833
842
|
@pulumi.getter
|
|
834
|
-
def notes(self) -> Optional[pulumi.Input[str]]:
|
|
843
|
+
def notes(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
835
844
|
"""
|
|
836
845
|
User-specified notes relevant for the management of the application.
|
|
837
846
|
"""
|
|
838
847
|
return pulumi.get(self, "notes")
|
|
839
848
|
|
|
840
849
|
@notes.setter
|
|
841
|
-
def notes(self, value: Optional[pulumi.Input[str]]):
|
|
850
|
+
def notes(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
842
851
|
pulumi.set(self, "notes", value)
|
|
843
852
|
|
|
844
|
-
@property
|
|
853
|
+
@_builtins.property
|
|
845
854
|
@pulumi.getter(name="oauth2PermissionScopeIds")
|
|
846
|
-
def oauth2_permission_scope_ids(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
855
|
+
def oauth2_permission_scope_ids(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
847
856
|
"""
|
|
848
857
|
A mapping of OAuth2.0 permission scope values to scope IDs, intended to be useful when referencing permission scopes in other resources in your configuration.
|
|
849
858
|
"""
|
|
850
859
|
return pulumi.get(self, "oauth2_permission_scope_ids")
|
|
851
860
|
|
|
852
861
|
@oauth2_permission_scope_ids.setter
|
|
853
|
-
def oauth2_permission_scope_ids(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
862
|
+
def oauth2_permission_scope_ids(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
854
863
|
pulumi.set(self, "oauth2_permission_scope_ids", value)
|
|
855
864
|
|
|
856
|
-
@property
|
|
865
|
+
@_builtins.property
|
|
857
866
|
@pulumi.getter(name="oauth2PostResponseRequired")
|
|
858
|
-
def oauth2_post_response_required(self) -> Optional[pulumi.Input[bool]]:
|
|
867
|
+
def oauth2_post_response_required(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
859
868
|
"""
|
|
860
869
|
Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
861
870
|
"""
|
|
862
871
|
return pulumi.get(self, "oauth2_post_response_required")
|
|
863
872
|
|
|
864
873
|
@oauth2_post_response_required.setter
|
|
865
|
-
def oauth2_post_response_required(self, value: Optional[pulumi.Input[bool]]):
|
|
874
|
+
def oauth2_post_response_required(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
866
875
|
pulumi.set(self, "oauth2_post_response_required", value)
|
|
867
876
|
|
|
868
|
-
@property
|
|
877
|
+
@_builtins.property
|
|
869
878
|
@pulumi.getter(name="objectId")
|
|
870
|
-
def object_id(self) -> Optional[pulumi.Input[str]]:
|
|
879
|
+
def object_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
871
880
|
"""
|
|
872
881
|
The application's object ID.
|
|
873
882
|
"""
|
|
874
883
|
return pulumi.get(self, "object_id")
|
|
875
884
|
|
|
876
885
|
@object_id.setter
|
|
877
|
-
def object_id(self, value: Optional[pulumi.Input[str]]):
|
|
886
|
+
def object_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
878
887
|
pulumi.set(self, "object_id", value)
|
|
879
888
|
|
|
880
|
-
@property
|
|
889
|
+
@_builtins.property
|
|
881
890
|
@pulumi.getter(name="optionalClaims")
|
|
882
891
|
def optional_claims(self) -> Optional[pulumi.Input['ApplicationOptionalClaimsArgs']]:
|
|
883
892
|
"""
|
|
@@ -889,43 +898,57 @@ class _ApplicationState:
|
|
|
889
898
|
def optional_claims(self, value: Optional[pulumi.Input['ApplicationOptionalClaimsArgs']]):
|
|
890
899
|
pulumi.set(self, "optional_claims", value)
|
|
891
900
|
|
|
892
|
-
@property
|
|
901
|
+
@_builtins.property
|
|
893
902
|
@pulumi.getter
|
|
894
|
-
def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
903
|
+
def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
895
904
|
"""
|
|
896
905
|
A list of object IDs of principals that will be granted ownership of the application
|
|
897
906
|
"""
|
|
898
907
|
return pulumi.get(self, "owners")
|
|
899
908
|
|
|
900
909
|
@owners.setter
|
|
901
|
-
def owners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
910
|
+
def owners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
902
911
|
pulumi.set(self, "owners", value)
|
|
903
912
|
|
|
904
|
-
@property
|
|
913
|
+
@_builtins.property
|
|
914
|
+
@pulumi.getter
|
|
915
|
+
def password(self) -> Optional[pulumi.Input['ApplicationPasswordArgs']]:
|
|
916
|
+
"""
|
|
917
|
+
A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
918
|
+
|
|
919
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
920
|
+
"""
|
|
921
|
+
return pulumi.get(self, "password")
|
|
922
|
+
|
|
923
|
+
@password.setter
|
|
924
|
+
def password(self, value: Optional[pulumi.Input['ApplicationPasswordArgs']]):
|
|
925
|
+
pulumi.set(self, "password", value)
|
|
926
|
+
|
|
927
|
+
@_builtins.property
|
|
905
928
|
@pulumi.getter(name="preventDuplicateNames")
|
|
906
|
-
def prevent_duplicate_names(self) -> Optional[pulumi.Input[bool]]:
|
|
929
|
+
def prevent_duplicate_names(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
907
930
|
"""
|
|
908
931
|
If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
909
932
|
"""
|
|
910
933
|
return pulumi.get(self, "prevent_duplicate_names")
|
|
911
934
|
|
|
912
935
|
@prevent_duplicate_names.setter
|
|
913
|
-
def prevent_duplicate_names(self, value: Optional[pulumi.Input[bool]]):
|
|
936
|
+
def prevent_duplicate_names(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
914
937
|
pulumi.set(self, "prevent_duplicate_names", value)
|
|
915
938
|
|
|
916
|
-
@property
|
|
939
|
+
@_builtins.property
|
|
917
940
|
@pulumi.getter(name="privacyStatementUrl")
|
|
918
|
-
def privacy_statement_url(self) -> Optional[pulumi.Input[str]]:
|
|
941
|
+
def privacy_statement_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
919
942
|
"""
|
|
920
943
|
URL of the application's privacy statement.
|
|
921
944
|
"""
|
|
922
945
|
return pulumi.get(self, "privacy_statement_url")
|
|
923
946
|
|
|
924
947
|
@privacy_statement_url.setter
|
|
925
|
-
def privacy_statement_url(self, value: Optional[pulumi.Input[str]]):
|
|
948
|
+
def privacy_statement_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
926
949
|
pulumi.set(self, "privacy_statement_url", value)
|
|
927
950
|
|
|
928
|
-
@property
|
|
951
|
+
@_builtins.property
|
|
929
952
|
@pulumi.getter(name="publicClient")
|
|
930
953
|
def public_client(self) -> Optional[pulumi.Input['ApplicationPublicClientArgs']]:
|
|
931
954
|
"""
|
|
@@ -937,19 +960,19 @@ class _ApplicationState:
|
|
|
937
960
|
def public_client(self, value: Optional[pulumi.Input['ApplicationPublicClientArgs']]):
|
|
938
961
|
pulumi.set(self, "public_client", value)
|
|
939
962
|
|
|
940
|
-
@property
|
|
963
|
+
@_builtins.property
|
|
941
964
|
@pulumi.getter(name="publisherDomain")
|
|
942
|
-
def publisher_domain(self) -> Optional[pulumi.Input[str]]:
|
|
965
|
+
def publisher_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
943
966
|
"""
|
|
944
967
|
The verified publisher domain for the application.
|
|
945
968
|
"""
|
|
946
969
|
return pulumi.get(self, "publisher_domain")
|
|
947
970
|
|
|
948
971
|
@publisher_domain.setter
|
|
949
|
-
def publisher_domain(self, value: Optional[pulumi.Input[str]]):
|
|
972
|
+
def publisher_domain(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
950
973
|
pulumi.set(self, "publisher_domain", value)
|
|
951
974
|
|
|
952
|
-
@property
|
|
975
|
+
@_builtins.property
|
|
953
976
|
@pulumi.getter(name="requiredResourceAccesses")
|
|
954
977
|
def required_resource_accesses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]]]:
|
|
955
978
|
"""
|
|
@@ -961,21 +984,21 @@ class _ApplicationState:
|
|
|
961
984
|
def required_resource_accesses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationRequiredResourceAccessArgs']]]]):
|
|
962
985
|
pulumi.set(self, "required_resource_accesses", value)
|
|
963
986
|
|
|
964
|
-
@property
|
|
987
|
+
@_builtins.property
|
|
965
988
|
@pulumi.getter(name="serviceManagementReference")
|
|
966
|
-
def service_management_reference(self) -> Optional[pulumi.Input[str]]:
|
|
989
|
+
def service_management_reference(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
967
990
|
"""
|
|
968
991
|
References application context information from a Service or Asset Management database.
|
|
969
992
|
"""
|
|
970
993
|
return pulumi.get(self, "service_management_reference")
|
|
971
994
|
|
|
972
995
|
@service_management_reference.setter
|
|
973
|
-
def service_management_reference(self, value: Optional[pulumi.Input[str]]):
|
|
996
|
+
def service_management_reference(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
974
997
|
pulumi.set(self, "service_management_reference", value)
|
|
975
998
|
|
|
976
|
-
@property
|
|
999
|
+
@_builtins.property
|
|
977
1000
|
@pulumi.getter(name="signInAudience")
|
|
978
|
-
def sign_in_audience(self) -> Optional[pulumi.Input[str]]:
|
|
1001
|
+
def sign_in_audience(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
979
1002
|
"""
|
|
980
1003
|
The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
981
1004
|
|
|
@@ -984,10 +1007,10 @@ class _ApplicationState:
|
|
|
984
1007
|
return pulumi.get(self, "sign_in_audience")
|
|
985
1008
|
|
|
986
1009
|
@sign_in_audience.setter
|
|
987
|
-
def sign_in_audience(self, value: Optional[pulumi.Input[str]]):
|
|
1010
|
+
def sign_in_audience(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
988
1011
|
pulumi.set(self, "sign_in_audience", value)
|
|
989
1012
|
|
|
990
|
-
@property
|
|
1013
|
+
@_builtins.property
|
|
991
1014
|
@pulumi.getter(name="singlePageApplication")
|
|
992
1015
|
def single_page_application(self) -> Optional[pulumi.Input['ApplicationSinglePageApplicationArgs']]:
|
|
993
1016
|
"""
|
|
@@ -999,21 +1022,21 @@ class _ApplicationState:
|
|
|
999
1022
|
def single_page_application(self, value: Optional[pulumi.Input['ApplicationSinglePageApplicationArgs']]):
|
|
1000
1023
|
pulumi.set(self, "single_page_application", value)
|
|
1001
1024
|
|
|
1002
|
-
@property
|
|
1025
|
+
@_builtins.property
|
|
1003
1026
|
@pulumi.getter(name="supportUrl")
|
|
1004
|
-
def support_url(self) -> Optional[pulumi.Input[str]]:
|
|
1027
|
+
def support_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1005
1028
|
"""
|
|
1006
1029
|
URL of the application's support page.
|
|
1007
1030
|
"""
|
|
1008
1031
|
return pulumi.get(self, "support_url")
|
|
1009
1032
|
|
|
1010
1033
|
@support_url.setter
|
|
1011
|
-
def support_url(self, value: Optional[pulumi.Input[str]]):
|
|
1034
|
+
def support_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1012
1035
|
pulumi.set(self, "support_url", value)
|
|
1013
1036
|
|
|
1014
|
-
@property
|
|
1037
|
+
@_builtins.property
|
|
1015
1038
|
@pulumi.getter
|
|
1016
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1039
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1017
1040
|
"""
|
|
1018
1041
|
A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
1019
1042
|
|
|
@@ -1022,12 +1045,12 @@ class _ApplicationState:
|
|
|
1022
1045
|
return pulumi.get(self, "tags")
|
|
1023
1046
|
|
|
1024
1047
|
@tags.setter
|
|
1025
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1048
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1026
1049
|
pulumi.set(self, "tags", value)
|
|
1027
1050
|
|
|
1028
|
-
@property
|
|
1051
|
+
@_builtins.property
|
|
1029
1052
|
@pulumi.getter(name="templateId")
|
|
1030
|
-
def template_id(self) -> Optional[pulumi.Input[str]]:
|
|
1053
|
+
def template_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1031
1054
|
"""
|
|
1032
1055
|
Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
1033
1056
|
|
|
@@ -1036,22 +1059,22 @@ class _ApplicationState:
|
|
|
1036
1059
|
return pulumi.get(self, "template_id")
|
|
1037
1060
|
|
|
1038
1061
|
@template_id.setter
|
|
1039
|
-
def template_id(self, value: Optional[pulumi.Input[str]]):
|
|
1062
|
+
def template_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1040
1063
|
pulumi.set(self, "template_id", value)
|
|
1041
1064
|
|
|
1042
|
-
@property
|
|
1065
|
+
@_builtins.property
|
|
1043
1066
|
@pulumi.getter(name="termsOfServiceUrl")
|
|
1044
|
-
def terms_of_service_url(self) -> Optional[pulumi.Input[str]]:
|
|
1067
|
+
def terms_of_service_url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1045
1068
|
"""
|
|
1046
1069
|
URL of the application's terms of service statement.
|
|
1047
1070
|
"""
|
|
1048
1071
|
return pulumi.get(self, "terms_of_service_url")
|
|
1049
1072
|
|
|
1050
1073
|
@terms_of_service_url.setter
|
|
1051
|
-
def terms_of_service_url(self, value: Optional[pulumi.Input[str]]):
|
|
1074
|
+
def terms_of_service_url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1052
1075
|
pulumi.set(self, "terms_of_service_url", value)
|
|
1053
1076
|
|
|
1054
|
-
@property
|
|
1077
|
+
@_builtins.property
|
|
1055
1078
|
@pulumi.getter
|
|
1056
1079
|
def web(self) -> Optional[pulumi.Input['ApplicationWebArgs']]:
|
|
1057
1080
|
"""
|
|
@@ -1066,38 +1089,40 @@ class _ApplicationState:
|
|
|
1066
1089
|
pulumi.set(self, "web", value)
|
|
1067
1090
|
|
|
1068
1091
|
|
|
1092
|
+
@pulumi.type_token("azuread:index/application:Application")
|
|
1069
1093
|
class Application(pulumi.CustomResource):
|
|
1070
1094
|
@overload
|
|
1071
1095
|
def __init__(__self__,
|
|
1072
1096
|
resource_name: str,
|
|
1073
1097
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1074
|
-
api: Optional[pulumi.Input[
|
|
1075
|
-
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1076
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1077
|
-
device_only_auth_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1078
|
-
display_name: Optional[pulumi.Input[str]] = None,
|
|
1079
|
-
fallback_public_client_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1080
|
-
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1081
|
-
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1082
|
-
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1083
|
-
logo_image: Optional[pulumi.Input[str]] = None,
|
|
1084
|
-
marketing_url: Optional[pulumi.Input[str]] = None,
|
|
1085
|
-
notes: Optional[pulumi.Input[str]] = None,
|
|
1086
|
-
oauth2_post_response_required: Optional[pulumi.Input[bool]] = None,
|
|
1087
|
-
optional_claims: Optional[pulumi.Input[
|
|
1088
|
-
owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
|
|
1098
|
+
api: Optional[pulumi.Input[Union['ApplicationApiArgs', 'ApplicationApiArgsDict']]] = None,
|
|
1099
|
+
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationAppRoleArgs', 'ApplicationAppRoleArgsDict']]]]] = None,
|
|
1100
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1101
|
+
device_only_auth_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1102
|
+
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1103
|
+
fallback_public_client_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1104
|
+
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationFeatureTagArgs', 'ApplicationFeatureTagArgsDict']]]]] = None,
|
|
1105
|
+
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1106
|
+
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1107
|
+
logo_image: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1108
|
+
marketing_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1109
|
+
notes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1110
|
+
oauth2_post_response_required: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1111
|
+
optional_claims: Optional[pulumi.Input[Union['ApplicationOptionalClaimsArgs', 'ApplicationOptionalClaimsArgsDict']]] = None,
|
|
1112
|
+
owners: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1113
|
+
password: Optional[pulumi.Input[Union['ApplicationPasswordArgs', 'ApplicationPasswordArgsDict']]] = None,
|
|
1114
|
+
prevent_duplicate_names: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1115
|
+
privacy_statement_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1116
|
+
public_client: Optional[pulumi.Input[Union['ApplicationPublicClientArgs', 'ApplicationPublicClientArgsDict']]] = None,
|
|
1117
|
+
required_resource_accesses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationRequiredResourceAccessArgs', 'ApplicationRequiredResourceAccessArgsDict']]]]] = None,
|
|
1118
|
+
service_management_reference: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1119
|
+
sign_in_audience: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1120
|
+
single_page_application: Optional[pulumi.Input[Union['ApplicationSinglePageApplicationArgs', 'ApplicationSinglePageApplicationArgsDict']]] = None,
|
|
1121
|
+
support_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1122
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1123
|
+
template_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1124
|
+
terms_of_service_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1125
|
+
web: Optional[pulumi.Input[Union['ApplicationWebArgs', 'ApplicationWebArgsDict']]] = None,
|
|
1101
1126
|
__props__=None):
|
|
1102
1127
|
"""
|
|
1103
1128
|
## Example Usage
|
|
@@ -1106,119 +1131,141 @@ class Application(pulumi.CustomResource):
|
|
|
1106
1131
|
|
|
1107
1132
|
```python
|
|
1108
1133
|
import pulumi
|
|
1109
|
-
import base64
|
|
1110
1134
|
import pulumi_azuread as azuread
|
|
1135
|
+
import pulumi_std as std
|
|
1111
1136
|
|
|
1112
1137
|
current = azuread.get_client_config()
|
|
1113
1138
|
example = azuread.Application("example",
|
|
1114
1139
|
display_name="example",
|
|
1115
1140
|
identifier_uris=["api://example-app"],
|
|
1116
|
-
logo_image=
|
|
1141
|
+
logo_image=std.filebase64(input="/path/to/logo.png").result,
|
|
1117
1142
|
owners=[current.object_id],
|
|
1118
1143
|
sign_in_audience="AzureADMultipleOrgs",
|
|
1119
|
-
api=
|
|
1120
|
-
mapped_claims_enabled
|
|
1121
|
-
requested_access_token_version
|
|
1122
|
-
known_client_applications
|
|
1123
|
-
|
|
1124
|
-
|
|
1144
|
+
api={
|
|
1145
|
+
"mapped_claims_enabled": True,
|
|
1146
|
+
"requested_access_token_version": 2,
|
|
1147
|
+
"known_client_applications": [
|
|
1148
|
+
known1["clientId"],
|
|
1149
|
+
known2["clientId"],
|
|
1125
1150
|
],
|
|
1126
|
-
oauth2_permission_scopes
|
|
1127
|
-
|
|
1128
|
-
admin_consent_description
|
|
1129
|
-
admin_consent_display_name
|
|
1130
|
-
enabled
|
|
1131
|
-
id
|
|
1132
|
-
type
|
|
1133
|
-
user_consent_description
|
|
1134
|
-
user_consent_display_name
|
|
1135
|
-
value
|
|
1136
|
-
|
|
1137
|
-
|
|
1138
|
-
admin_consent_description
|
|
1139
|
-
admin_consent_display_name
|
|
1140
|
-
enabled
|
|
1141
|
-
id
|
|
1142
|
-
type
|
|
1143
|
-
value
|
|
1144
|
-
|
|
1151
|
+
"oauth2_permission_scopes": [
|
|
1152
|
+
{
|
|
1153
|
+
"admin_consent_description": "Allow the application to access example on behalf of the signed-in user.",
|
|
1154
|
+
"admin_consent_display_name": "Access example",
|
|
1155
|
+
"enabled": True,
|
|
1156
|
+
"id": "96183846-204b-4b43-82e1-5d2222eb4b9b",
|
|
1157
|
+
"type": "User",
|
|
1158
|
+
"user_consent_description": "Allow the application to access example on your behalf.",
|
|
1159
|
+
"user_consent_display_name": "Access example",
|
|
1160
|
+
"value": "user_impersonation",
|
|
1161
|
+
},
|
|
1162
|
+
{
|
|
1163
|
+
"admin_consent_description": "Administer the example application",
|
|
1164
|
+
"admin_consent_display_name": "Administer",
|
|
1165
|
+
"enabled": True,
|
|
1166
|
+
"id": "be98fa3e-ab5b-4b11-83d9-04ba2b7946bc",
|
|
1167
|
+
"type": "Admin",
|
|
1168
|
+
"value": "administer",
|
|
1169
|
+
},
|
|
1145
1170
|
],
|
|
1146
|
-
|
|
1171
|
+
},
|
|
1147
1172
|
app_roles=[
|
|
1148
|
-
|
|
1149
|
-
allowed_member_types
|
|
1173
|
+
{
|
|
1174
|
+
"allowed_member_types": [
|
|
1150
1175
|
"User",
|
|
1151
1176
|
"Application",
|
|
1152
1177
|
],
|
|
1153
|
-
description
|
|
1154
|
-
display_name
|
|
1155
|
-
enabled
|
|
1156
|
-
id
|
|
1157
|
-
value
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
allowed_member_types
|
|
1161
|
-
description
|
|
1162
|
-
display_name
|
|
1163
|
-
enabled
|
|
1164
|
-
id
|
|
1165
|
-
value
|
|
1166
|
-
|
|
1178
|
+
"description": "Admins can manage roles and perform all task actions",
|
|
1179
|
+
"display_name": "Admin",
|
|
1180
|
+
"enabled": True,
|
|
1181
|
+
"id": "1b19509b-32b1-4e9f-b71d-4992aa991967",
|
|
1182
|
+
"value": "admin",
|
|
1183
|
+
},
|
|
1184
|
+
{
|
|
1185
|
+
"allowed_member_types": ["User"],
|
|
1186
|
+
"description": "ReadOnly roles have limited query access",
|
|
1187
|
+
"display_name": "ReadOnly",
|
|
1188
|
+
"enabled": True,
|
|
1189
|
+
"id": "497406e4-012a-4267-bf18-45a1cb148a01",
|
|
1190
|
+
"value": "User",
|
|
1191
|
+
},
|
|
1167
1192
|
],
|
|
1168
|
-
feature_tags=[
|
|
1169
|
-
enterprise
|
|
1170
|
-
gallery
|
|
1171
|
-
|
|
1172
|
-
optional_claims=
|
|
1173
|
-
access_tokens
|
|
1174
|
-
|
|
1175
|
-
name
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
name
|
|
1179
|
-
|
|
1193
|
+
feature_tags=[{
|
|
1194
|
+
"enterprise": True,
|
|
1195
|
+
"gallery": True,
|
|
1196
|
+
}],
|
|
1197
|
+
optional_claims={
|
|
1198
|
+
"access_tokens": [
|
|
1199
|
+
{
|
|
1200
|
+
"name": "myclaim",
|
|
1201
|
+
},
|
|
1202
|
+
{
|
|
1203
|
+
"name": "otherclaim",
|
|
1204
|
+
},
|
|
1180
1205
|
],
|
|
1181
|
-
id_tokens
|
|
1182
|
-
name
|
|
1183
|
-
source
|
|
1184
|
-
essential
|
|
1185
|
-
additional_properties
|
|
1186
|
-
|
|
1187
|
-
saml2_tokens
|
|
1188
|
-
name
|
|
1189
|
-
|
|
1190
|
-
|
|
1206
|
+
"id_tokens": [{
|
|
1207
|
+
"name": "userclaim",
|
|
1208
|
+
"source": "user",
|
|
1209
|
+
"essential": True,
|
|
1210
|
+
"additional_properties": ["emit_as_roles"],
|
|
1211
|
+
}],
|
|
1212
|
+
"saml2_tokens": [{
|
|
1213
|
+
"name": "samlexample",
|
|
1214
|
+
}],
|
|
1215
|
+
},
|
|
1191
1216
|
required_resource_accesses=[
|
|
1192
|
-
|
|
1193
|
-
resource_app_id
|
|
1194
|
-
resource_accesses
|
|
1195
|
-
|
|
1196
|
-
id
|
|
1197
|
-
type
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
id
|
|
1201
|
-
type
|
|
1202
|
-
|
|
1217
|
+
{
|
|
1218
|
+
"resource_app_id": "00000003-0000-0000-c000-000000000000",
|
|
1219
|
+
"resource_accesses": [
|
|
1220
|
+
{
|
|
1221
|
+
"id": "df021288-bdef-4463-88db-98f22de89214",
|
|
1222
|
+
"type": "Role",
|
|
1223
|
+
},
|
|
1224
|
+
{
|
|
1225
|
+
"id": "b4e74841-8e56-480b-be8b-910348b18b4c",
|
|
1226
|
+
"type": "Scope",
|
|
1227
|
+
},
|
|
1203
1228
|
],
|
|
1204
|
-
|
|
1205
|
-
|
|
1206
|
-
resource_app_id
|
|
1207
|
-
resource_accesses
|
|
1208
|
-
id
|
|
1209
|
-
type
|
|
1210
|
-
|
|
1211
|
-
|
|
1229
|
+
},
|
|
1230
|
+
{
|
|
1231
|
+
"resource_app_id": "c5393580-f805-4401-95e8-94b7a6ef2fc2",
|
|
1232
|
+
"resource_accesses": [{
|
|
1233
|
+
"id": "594c1fb6-4f81-4475-ae41-0c394909246c",
|
|
1234
|
+
"type": "Role",
|
|
1235
|
+
}],
|
|
1236
|
+
},
|
|
1212
1237
|
],
|
|
1213
|
-
web=
|
|
1214
|
-
homepage_url
|
|
1215
|
-
logout_url
|
|
1216
|
-
redirect_uris
|
|
1217
|
-
implicit_grant
|
|
1218
|
-
access_token_issuance_enabled
|
|
1219
|
-
id_token_issuance_enabled
|
|
1220
|
-
|
|
1221
|
-
)
|
|
1238
|
+
web={
|
|
1239
|
+
"homepage_url": "https://app.example.net",
|
|
1240
|
+
"logout_url": "https://app.example.net/logout",
|
|
1241
|
+
"redirect_uris": ["https://app.example.net/account"],
|
|
1242
|
+
"implicit_grant": {
|
|
1243
|
+
"access_token_issuance_enabled": True,
|
|
1244
|
+
"id_token_issuance_enabled": True,
|
|
1245
|
+
},
|
|
1246
|
+
})
|
|
1247
|
+
```
|
|
1248
|
+
|
|
1249
|
+
*Create application and generate a password*
|
|
1250
|
+
|
|
1251
|
+
```python
|
|
1252
|
+
import pulumi
|
|
1253
|
+
import pulumi_azuread as azuread
|
|
1254
|
+
import pulumi_std as std
|
|
1255
|
+
import pulumiverse_time as time
|
|
1256
|
+
|
|
1257
|
+
current = azuread.get_client_config()
|
|
1258
|
+
example = time.Rotating("example", rotation_days=180)
|
|
1259
|
+
example_application = azuread.Application("example",
|
|
1260
|
+
display_name="example",
|
|
1261
|
+
owners=[current.object_id],
|
|
1262
|
+
password={
|
|
1263
|
+
"display_name": "MySecret-1",
|
|
1264
|
+
"start_date": example.id,
|
|
1265
|
+
"end_date": std.timeadd_output(duration=example.id,
|
|
1266
|
+
timestamp="4320h").apply(lambda invoke: invoke.result),
|
|
1267
|
+
})
|
|
1268
|
+
pulumi.export("examplePassword", example_application.password[0]["value"])
|
|
1222
1269
|
```
|
|
1223
1270
|
|
|
1224
1271
|
*Create application from a gallery template*
|
|
@@ -1227,12 +1274,12 @@ class Application(pulumi.CustomResource):
|
|
|
1227
1274
|
import pulumi
|
|
1228
1275
|
import pulumi_azuread as azuread
|
|
1229
1276
|
|
|
1230
|
-
|
|
1231
|
-
example_application = azuread.Application("
|
|
1277
|
+
example = azuread.get_application_template(display_name="Marketo")
|
|
1278
|
+
example_application = azuread.Application("example",
|
|
1232
1279
|
display_name="example",
|
|
1233
|
-
template_id=
|
|
1234
|
-
example_service_principal = azuread.ServicePrincipal("
|
|
1235
|
-
|
|
1280
|
+
template_id=example.template_id)
|
|
1281
|
+
example_service_principal = azuread.ServicePrincipal("example",
|
|
1282
|
+
client_id=example_application.client_id,
|
|
1236
1283
|
use_existing=True)
|
|
1237
1284
|
```
|
|
1238
1285
|
|
|
@@ -1241,46 +1288,49 @@ class Application(pulumi.CustomResource):
|
|
|
1241
1288
|
Applications can be imported using the object ID of the application, in the following format.
|
|
1242
1289
|
|
|
1243
1290
|
```sh
|
|
1244
|
-
|
|
1291
|
+
$ pulumi import azuread:index/application:Application example /applications/00000000-0000-0000-0000-000000000000
|
|
1245
1292
|
```
|
|
1246
1293
|
|
|
1247
1294
|
:param str resource_name: The name of the resource.
|
|
1248
1295
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1249
|
-
:param pulumi.Input[
|
|
1250
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1251
|
-
:param pulumi.Input[str] description: A description of the application, as shown to end users.
|
|
1252
|
-
:param pulumi.Input[bool] device_only_auth_enabled: Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
1253
|
-
:param pulumi.Input[str] display_name: The display name for the application.
|
|
1254
|
-
:param pulumi.Input[bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
1255
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1296
|
+
:param pulumi.Input[Union['ApplicationApiArgs', 'ApplicationApiArgsDict']] api: An `api` block as documented below, which configures API related settings for this application.
|
|
1297
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationAppRoleArgs', 'ApplicationAppRoleArgsDict']]]] app_roles: A collection of `app_role` blocks as documented below. For more information see [official documentation on Application Roles](https://docs.microsoft.com/en-us/azure/architecture/multitenant-identity/app-roles).
|
|
1298
|
+
:param pulumi.Input[_builtins.str] description: A description of the application, as shown to end users.
|
|
1299
|
+
:param pulumi.Input[_builtins.bool] device_only_auth_enabled: Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
1300
|
+
:param pulumi.Input[_builtins.str] display_name: The display name for the application.
|
|
1301
|
+
:param pulumi.Input[_builtins.bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
1302
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationFeatureTagArgs', 'ApplicationFeatureTagArgsDict']]]] feature_tags: A `feature_tags` block as described below. Cannot be used together with the `tags` property.
|
|
1256
1303
|
|
|
1257
1304
|
> **Features and Tags** Features are configured for an application using tags, and are provided as a shortcut to set the corresponding magic tag value for each feature. You cannot configure `feature_tags` and `tags` for an application at the same time, so if you need to assign additional custom tags it's recommended to use the `tags` property instead. Tag values also propagate to any linked service principals.
|
|
1258
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_membership_claims:
|
|
1259
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
1260
|
-
:param pulumi.Input[str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
1261
|
-
:param pulumi.Input[str] marketing_url: URL of the application's marketing page.
|
|
1262
|
-
:param pulumi.Input[str] notes: User-specified notes relevant for the management of the application.
|
|
1263
|
-
:param pulumi.Input[bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
1264
|
-
:param pulumi.Input[
|
|
1265
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
1266
|
-
:param pulumi.Input[
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
:param pulumi.Input[
|
|
1270
|
-
:param pulumi.Input[str]
|
|
1271
|
-
:param pulumi.Input[
|
|
1305
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] group_membership_claims: A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
1306
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
1307
|
+
:param pulumi.Input[_builtins.str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
1308
|
+
:param pulumi.Input[_builtins.str] marketing_url: URL of the application's marketing page.
|
|
1309
|
+
:param pulumi.Input[_builtins.str] notes: User-specified notes relevant for the management of the application.
|
|
1310
|
+
:param pulumi.Input[_builtins.bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
1311
|
+
:param pulumi.Input[Union['ApplicationOptionalClaimsArgs', 'ApplicationOptionalClaimsArgsDict']] optional_claims: An `optional_claims` block as documented below.
|
|
1312
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
1313
|
+
:param pulumi.Input[Union['ApplicationPasswordArgs', 'ApplicationPasswordArgsDict']] password: A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
1314
|
+
|
|
1315
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
1316
|
+
:param pulumi.Input[_builtins.bool] prevent_duplicate_names: If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
1317
|
+
:param pulumi.Input[_builtins.str] privacy_statement_url: URL of the application's privacy statement.
|
|
1318
|
+
:param pulumi.Input[Union['ApplicationPublicClientArgs', 'ApplicationPublicClientArgsDict']] public_client: A `public_client` block as documented below, which configures non-web app or non-web API application settings, for example mobile or other public clients such as an installed application running on a desktop device.
|
|
1319
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationRequiredResourceAccessArgs', 'ApplicationRequiredResourceAccessArgsDict']]]] required_resource_accesses: A collection of `required_resource_access` blocks as documented below.
|
|
1320
|
+
:param pulumi.Input[_builtins.str] service_management_reference: References application context information from a Service or Asset Management database.
|
|
1321
|
+
:param pulumi.Input[_builtins.str] sign_in_audience: The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
1272
1322
|
|
|
1273
1323
|
> **Changing `sign_in_audience` for existing applications** When updating an existing application to use a `sign_in_audience` value of `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`, your configuration may no longer be valid. Refer to [official documentation](https://docs.microsoft.com/en-gb/azure/active-directory/develop/supported-accounts-validation) to understand the differences in supported configurations. Where possible, the provider will attempt to validate your configuration and try to avoid applying unsupported settings to your application.
|
|
1274
|
-
:param pulumi.Input[
|
|
1275
|
-
:param pulumi.Input[str] support_url: URL of the application's support page.
|
|
1276
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
1324
|
+
:param pulumi.Input[Union['ApplicationSinglePageApplicationArgs', 'ApplicationSinglePageApplicationArgsDict']] single_page_application: A `single_page_application` block as documented below, which configures single-page application (SPA) related settings for this application.
|
|
1325
|
+
:param pulumi.Input[_builtins.str] support_url: URL of the application's support page.
|
|
1326
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
1277
1327
|
|
|
1278
1328
|
> **Tags and Features** Azure Active Directory uses special tag values to configure the behavior of applications. These can be specified using either the `tags` property or with the `feature_tags` block. If you need to set any custom tag values not supported by the `feature_tags` block, it's recommended to use the `tags` property. Tag values also propagate to any linked service principals.
|
|
1279
|
-
:param pulumi.Input[str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
1329
|
+
:param pulumi.Input[_builtins.str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
1280
1330
|
|
|
1281
1331
|
> **Tip for Gallery Applications** This resource can be used to instantiate a gallery application, however it will also attempt to manage the properties of the resulting application. If this is not desired, consider using the ApplicationRegistration resource instead.
|
|
1282
|
-
:param pulumi.Input[str] terms_of_service_url: URL of the application's terms of service statement.
|
|
1283
|
-
:param pulumi.Input[
|
|
1332
|
+
:param pulumi.Input[_builtins.str] terms_of_service_url: URL of the application's terms of service statement.
|
|
1333
|
+
:param pulumi.Input[Union['ApplicationWebArgs', 'ApplicationWebArgsDict']] web: A `web` block as documented below, which configures web related settings for this application.
|
|
1284
1334
|
|
|
1285
1335
|
> **Application Name Uniqueness** Application names are not unique within Azure Active Directory. Use the `prevent_duplicate_names` argument to check for existing applications if you want to avoid name collisions.
|
|
1286
1336
|
"""
|
|
@@ -1297,119 +1347,141 @@ class Application(pulumi.CustomResource):
|
|
|
1297
1347
|
|
|
1298
1348
|
```python
|
|
1299
1349
|
import pulumi
|
|
1300
|
-
import base64
|
|
1301
1350
|
import pulumi_azuread as azuread
|
|
1351
|
+
import pulumi_std as std
|
|
1302
1352
|
|
|
1303
1353
|
current = azuread.get_client_config()
|
|
1304
1354
|
example = azuread.Application("example",
|
|
1305
1355
|
display_name="example",
|
|
1306
1356
|
identifier_uris=["api://example-app"],
|
|
1307
|
-
logo_image=
|
|
1357
|
+
logo_image=std.filebase64(input="/path/to/logo.png").result,
|
|
1308
1358
|
owners=[current.object_id],
|
|
1309
1359
|
sign_in_audience="AzureADMultipleOrgs",
|
|
1310
|
-
api=
|
|
1311
|
-
mapped_claims_enabled
|
|
1312
|
-
requested_access_token_version
|
|
1313
|
-
known_client_applications
|
|
1314
|
-
|
|
1315
|
-
|
|
1360
|
+
api={
|
|
1361
|
+
"mapped_claims_enabled": True,
|
|
1362
|
+
"requested_access_token_version": 2,
|
|
1363
|
+
"known_client_applications": [
|
|
1364
|
+
known1["clientId"],
|
|
1365
|
+
known2["clientId"],
|
|
1316
1366
|
],
|
|
1317
|
-
oauth2_permission_scopes
|
|
1318
|
-
|
|
1319
|
-
admin_consent_description
|
|
1320
|
-
admin_consent_display_name
|
|
1321
|
-
enabled
|
|
1322
|
-
id
|
|
1323
|
-
type
|
|
1324
|
-
user_consent_description
|
|
1325
|
-
user_consent_display_name
|
|
1326
|
-
value
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
admin_consent_description
|
|
1330
|
-
admin_consent_display_name
|
|
1331
|
-
enabled
|
|
1332
|
-
id
|
|
1333
|
-
type
|
|
1334
|
-
value
|
|
1335
|
-
|
|
1367
|
+
"oauth2_permission_scopes": [
|
|
1368
|
+
{
|
|
1369
|
+
"admin_consent_description": "Allow the application to access example on behalf of the signed-in user.",
|
|
1370
|
+
"admin_consent_display_name": "Access example",
|
|
1371
|
+
"enabled": True,
|
|
1372
|
+
"id": "96183846-204b-4b43-82e1-5d2222eb4b9b",
|
|
1373
|
+
"type": "User",
|
|
1374
|
+
"user_consent_description": "Allow the application to access example on your behalf.",
|
|
1375
|
+
"user_consent_display_name": "Access example",
|
|
1376
|
+
"value": "user_impersonation",
|
|
1377
|
+
},
|
|
1378
|
+
{
|
|
1379
|
+
"admin_consent_description": "Administer the example application",
|
|
1380
|
+
"admin_consent_display_name": "Administer",
|
|
1381
|
+
"enabled": True,
|
|
1382
|
+
"id": "be98fa3e-ab5b-4b11-83d9-04ba2b7946bc",
|
|
1383
|
+
"type": "Admin",
|
|
1384
|
+
"value": "administer",
|
|
1385
|
+
},
|
|
1336
1386
|
],
|
|
1337
|
-
|
|
1387
|
+
},
|
|
1338
1388
|
app_roles=[
|
|
1339
|
-
|
|
1340
|
-
allowed_member_types
|
|
1389
|
+
{
|
|
1390
|
+
"allowed_member_types": [
|
|
1341
1391
|
"User",
|
|
1342
1392
|
"Application",
|
|
1343
1393
|
],
|
|
1344
|
-
description
|
|
1345
|
-
display_name
|
|
1346
|
-
enabled
|
|
1347
|
-
id
|
|
1348
|
-
value
|
|
1349
|
-
|
|
1350
|
-
|
|
1351
|
-
allowed_member_types
|
|
1352
|
-
description
|
|
1353
|
-
display_name
|
|
1354
|
-
enabled
|
|
1355
|
-
id
|
|
1356
|
-
value
|
|
1357
|
-
|
|
1394
|
+
"description": "Admins can manage roles and perform all task actions",
|
|
1395
|
+
"display_name": "Admin",
|
|
1396
|
+
"enabled": True,
|
|
1397
|
+
"id": "1b19509b-32b1-4e9f-b71d-4992aa991967",
|
|
1398
|
+
"value": "admin",
|
|
1399
|
+
},
|
|
1400
|
+
{
|
|
1401
|
+
"allowed_member_types": ["User"],
|
|
1402
|
+
"description": "ReadOnly roles have limited query access",
|
|
1403
|
+
"display_name": "ReadOnly",
|
|
1404
|
+
"enabled": True,
|
|
1405
|
+
"id": "497406e4-012a-4267-bf18-45a1cb148a01",
|
|
1406
|
+
"value": "User",
|
|
1407
|
+
},
|
|
1358
1408
|
],
|
|
1359
|
-
feature_tags=[
|
|
1360
|
-
enterprise
|
|
1361
|
-
gallery
|
|
1362
|
-
|
|
1363
|
-
optional_claims=
|
|
1364
|
-
access_tokens
|
|
1365
|
-
|
|
1366
|
-
name
|
|
1367
|
-
|
|
1368
|
-
|
|
1369
|
-
name
|
|
1370
|
-
|
|
1409
|
+
feature_tags=[{
|
|
1410
|
+
"enterprise": True,
|
|
1411
|
+
"gallery": True,
|
|
1412
|
+
}],
|
|
1413
|
+
optional_claims={
|
|
1414
|
+
"access_tokens": [
|
|
1415
|
+
{
|
|
1416
|
+
"name": "myclaim",
|
|
1417
|
+
},
|
|
1418
|
+
{
|
|
1419
|
+
"name": "otherclaim",
|
|
1420
|
+
},
|
|
1371
1421
|
],
|
|
1372
|
-
id_tokens
|
|
1373
|
-
name
|
|
1374
|
-
source
|
|
1375
|
-
essential
|
|
1376
|
-
additional_properties
|
|
1377
|
-
|
|
1378
|
-
saml2_tokens
|
|
1379
|
-
name
|
|
1380
|
-
|
|
1381
|
-
|
|
1422
|
+
"id_tokens": [{
|
|
1423
|
+
"name": "userclaim",
|
|
1424
|
+
"source": "user",
|
|
1425
|
+
"essential": True,
|
|
1426
|
+
"additional_properties": ["emit_as_roles"],
|
|
1427
|
+
}],
|
|
1428
|
+
"saml2_tokens": [{
|
|
1429
|
+
"name": "samlexample",
|
|
1430
|
+
}],
|
|
1431
|
+
},
|
|
1382
1432
|
required_resource_accesses=[
|
|
1383
|
-
|
|
1384
|
-
resource_app_id
|
|
1385
|
-
resource_accesses
|
|
1386
|
-
|
|
1387
|
-
id
|
|
1388
|
-
type
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
id
|
|
1392
|
-
type
|
|
1393
|
-
|
|
1433
|
+
{
|
|
1434
|
+
"resource_app_id": "00000003-0000-0000-c000-000000000000",
|
|
1435
|
+
"resource_accesses": [
|
|
1436
|
+
{
|
|
1437
|
+
"id": "df021288-bdef-4463-88db-98f22de89214",
|
|
1438
|
+
"type": "Role",
|
|
1439
|
+
},
|
|
1440
|
+
{
|
|
1441
|
+
"id": "b4e74841-8e56-480b-be8b-910348b18b4c",
|
|
1442
|
+
"type": "Scope",
|
|
1443
|
+
},
|
|
1394
1444
|
],
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
resource_app_id
|
|
1398
|
-
resource_accesses
|
|
1399
|
-
id
|
|
1400
|
-
type
|
|
1401
|
-
|
|
1402
|
-
|
|
1445
|
+
},
|
|
1446
|
+
{
|
|
1447
|
+
"resource_app_id": "c5393580-f805-4401-95e8-94b7a6ef2fc2",
|
|
1448
|
+
"resource_accesses": [{
|
|
1449
|
+
"id": "594c1fb6-4f81-4475-ae41-0c394909246c",
|
|
1450
|
+
"type": "Role",
|
|
1451
|
+
}],
|
|
1452
|
+
},
|
|
1403
1453
|
],
|
|
1404
|
-
web=
|
|
1405
|
-
homepage_url
|
|
1406
|
-
logout_url
|
|
1407
|
-
redirect_uris
|
|
1408
|
-
implicit_grant
|
|
1409
|
-
access_token_issuance_enabled
|
|
1410
|
-
id_token_issuance_enabled
|
|
1411
|
-
|
|
1412
|
-
)
|
|
1454
|
+
web={
|
|
1455
|
+
"homepage_url": "https://app.example.net",
|
|
1456
|
+
"logout_url": "https://app.example.net/logout",
|
|
1457
|
+
"redirect_uris": ["https://app.example.net/account"],
|
|
1458
|
+
"implicit_grant": {
|
|
1459
|
+
"access_token_issuance_enabled": True,
|
|
1460
|
+
"id_token_issuance_enabled": True,
|
|
1461
|
+
},
|
|
1462
|
+
})
|
|
1463
|
+
```
|
|
1464
|
+
|
|
1465
|
+
*Create application and generate a password*
|
|
1466
|
+
|
|
1467
|
+
```python
|
|
1468
|
+
import pulumi
|
|
1469
|
+
import pulumi_azuread as azuread
|
|
1470
|
+
import pulumi_std as std
|
|
1471
|
+
import pulumiverse_time as time
|
|
1472
|
+
|
|
1473
|
+
current = azuread.get_client_config()
|
|
1474
|
+
example = time.Rotating("example", rotation_days=180)
|
|
1475
|
+
example_application = azuread.Application("example",
|
|
1476
|
+
display_name="example",
|
|
1477
|
+
owners=[current.object_id],
|
|
1478
|
+
password={
|
|
1479
|
+
"display_name": "MySecret-1",
|
|
1480
|
+
"start_date": example.id,
|
|
1481
|
+
"end_date": std.timeadd_output(duration=example.id,
|
|
1482
|
+
timestamp="4320h").apply(lambda invoke: invoke.result),
|
|
1483
|
+
})
|
|
1484
|
+
pulumi.export("examplePassword", example_application.password[0]["value"])
|
|
1413
1485
|
```
|
|
1414
1486
|
|
|
1415
1487
|
*Create application from a gallery template*
|
|
@@ -1418,12 +1490,12 @@ class Application(pulumi.CustomResource):
|
|
|
1418
1490
|
import pulumi
|
|
1419
1491
|
import pulumi_azuread as azuread
|
|
1420
1492
|
|
|
1421
|
-
|
|
1422
|
-
example_application = azuread.Application("
|
|
1493
|
+
example = azuread.get_application_template(display_name="Marketo")
|
|
1494
|
+
example_application = azuread.Application("example",
|
|
1423
1495
|
display_name="example",
|
|
1424
|
-
template_id=
|
|
1425
|
-
example_service_principal = azuread.ServicePrincipal("
|
|
1426
|
-
|
|
1496
|
+
template_id=example.template_id)
|
|
1497
|
+
example_service_principal = azuread.ServicePrincipal("example",
|
|
1498
|
+
client_id=example_application.client_id,
|
|
1427
1499
|
use_existing=True)
|
|
1428
1500
|
```
|
|
1429
1501
|
|
|
@@ -1432,7 +1504,7 @@ class Application(pulumi.CustomResource):
|
|
|
1432
1504
|
Applications can be imported using the object ID of the application, in the following format.
|
|
1433
1505
|
|
|
1434
1506
|
```sh
|
|
1435
|
-
|
|
1507
|
+
$ pulumi import azuread:index/application:Application example /applications/00000000-0000-0000-0000-000000000000
|
|
1436
1508
|
```
|
|
1437
1509
|
|
|
1438
1510
|
:param str resource_name: The name of the resource.
|
|
@@ -1450,33 +1522,34 @@ class Application(pulumi.CustomResource):
|
|
|
1450
1522
|
def _internal_init(__self__,
|
|
1451
1523
|
resource_name: str,
|
|
1452
1524
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1453
|
-
api: Optional[pulumi.Input[
|
|
1454
|
-
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1455
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1456
|
-
device_only_auth_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1457
|
-
display_name: Optional[pulumi.Input[str]] = None,
|
|
1458
|
-
fallback_public_client_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1459
|
-
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1460
|
-
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1461
|
-
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1462
|
-
logo_image: Optional[pulumi.Input[str]] = None,
|
|
1463
|
-
marketing_url: Optional[pulumi.Input[str]] = None,
|
|
1464
|
-
notes: Optional[pulumi.Input[str]] = None,
|
|
1465
|
-
oauth2_post_response_required: Optional[pulumi.Input[bool]] = None,
|
|
1466
|
-
optional_claims: Optional[pulumi.Input[
|
|
1467
|
-
owners: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
1472
|
-
|
|
1473
|
-
|
|
1474
|
-
|
|
1475
|
-
|
|
1476
|
-
|
|
1477
|
-
|
|
1478
|
-
|
|
1479
|
-
|
|
1525
|
+
api: Optional[pulumi.Input[Union['ApplicationApiArgs', 'ApplicationApiArgsDict']]] = None,
|
|
1526
|
+
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationAppRoleArgs', 'ApplicationAppRoleArgsDict']]]]] = None,
|
|
1527
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1528
|
+
device_only_auth_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1529
|
+
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1530
|
+
fallback_public_client_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1531
|
+
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationFeatureTagArgs', 'ApplicationFeatureTagArgsDict']]]]] = None,
|
|
1532
|
+
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1533
|
+
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1534
|
+
logo_image: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1535
|
+
marketing_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1536
|
+
notes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1537
|
+
oauth2_post_response_required: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1538
|
+
optional_claims: Optional[pulumi.Input[Union['ApplicationOptionalClaimsArgs', 'ApplicationOptionalClaimsArgsDict']]] = None,
|
|
1539
|
+
owners: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1540
|
+
password: Optional[pulumi.Input[Union['ApplicationPasswordArgs', 'ApplicationPasswordArgsDict']]] = None,
|
|
1541
|
+
prevent_duplicate_names: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1542
|
+
privacy_statement_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1543
|
+
public_client: Optional[pulumi.Input[Union['ApplicationPublicClientArgs', 'ApplicationPublicClientArgsDict']]] = None,
|
|
1544
|
+
required_resource_accesses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationRequiredResourceAccessArgs', 'ApplicationRequiredResourceAccessArgsDict']]]]] = None,
|
|
1545
|
+
service_management_reference: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1546
|
+
sign_in_audience: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1547
|
+
single_page_application: Optional[pulumi.Input[Union['ApplicationSinglePageApplicationArgs', 'ApplicationSinglePageApplicationArgsDict']]] = None,
|
|
1548
|
+
support_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1549
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1550
|
+
template_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1551
|
+
terms_of_service_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1552
|
+
web: Optional[pulumi.Input[Union['ApplicationWebArgs', 'ApplicationWebArgsDict']]] = None,
|
|
1480
1553
|
__props__=None):
|
|
1481
1554
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1482
1555
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1503,6 +1576,7 @@ class Application(pulumi.CustomResource):
|
|
|
1503
1576
|
__props__.__dict__["oauth2_post_response_required"] = oauth2_post_response_required
|
|
1504
1577
|
__props__.__dict__["optional_claims"] = optional_claims
|
|
1505
1578
|
__props__.__dict__["owners"] = owners
|
|
1579
|
+
__props__.__dict__["password"] = password
|
|
1506
1580
|
__props__.__dict__["prevent_duplicate_names"] = prevent_duplicate_names
|
|
1507
1581
|
__props__.__dict__["privacy_statement_url"] = privacy_statement_url
|
|
1508
1582
|
__props__.__dict__["public_client"] = public_client
|
|
@@ -1516,7 +1590,6 @@ class Application(pulumi.CustomResource):
|
|
|
1516
1590
|
__props__.__dict__["terms_of_service_url"] = terms_of_service_url
|
|
1517
1591
|
__props__.__dict__["web"] = web
|
|
1518
1592
|
__props__.__dict__["app_role_ids"] = None
|
|
1519
|
-
__props__.__dict__["application_id"] = None
|
|
1520
1593
|
__props__.__dict__["client_id"] = None
|
|
1521
1594
|
__props__.__dict__["disabled_by_microsoft"] = None
|
|
1522
1595
|
__props__.__dict__["logo_url"] = None
|
|
@@ -1533,41 +1606,41 @@ class Application(pulumi.CustomResource):
|
|
|
1533
1606
|
def get(resource_name: str,
|
|
1534
1607
|
id: pulumi.Input[str],
|
|
1535
1608
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1536
|
-
api: Optional[pulumi.Input[
|
|
1537
|
-
app_role_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1538
|
-
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1539
|
-
|
|
1540
|
-
|
|
1541
|
-
|
|
1542
|
-
|
|
1543
|
-
|
|
1544
|
-
|
|
1545
|
-
|
|
1546
|
-
|
|
1547
|
-
|
|
1548
|
-
|
|
1549
|
-
|
|
1550
|
-
|
|
1551
|
-
|
|
1552
|
-
|
|
1553
|
-
|
|
1554
|
-
|
|
1555
|
-
|
|
1556
|
-
|
|
1557
|
-
|
|
1558
|
-
prevent_duplicate_names: Optional[pulumi.Input[bool]] = None,
|
|
1559
|
-
privacy_statement_url: Optional[pulumi.Input[str]] = None,
|
|
1560
|
-
public_client: Optional[pulumi.Input[
|
|
1561
|
-
publisher_domain: Optional[pulumi.Input[str]] = None,
|
|
1562
|
-
required_resource_accesses: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1563
|
-
service_management_reference: Optional[pulumi.Input[str]] = None,
|
|
1564
|
-
sign_in_audience: Optional[pulumi.Input[str]] = None,
|
|
1565
|
-
single_page_application: Optional[pulumi.Input[
|
|
1566
|
-
support_url: Optional[pulumi.Input[str]] = None,
|
|
1567
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1568
|
-
template_id: Optional[pulumi.Input[str]] = None,
|
|
1569
|
-
terms_of_service_url: Optional[pulumi.Input[str]] = None,
|
|
1570
|
-
web: Optional[pulumi.Input[
|
|
1609
|
+
api: Optional[pulumi.Input[Union['ApplicationApiArgs', 'ApplicationApiArgsDict']]] = None,
|
|
1610
|
+
app_role_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1611
|
+
app_roles: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationAppRoleArgs', 'ApplicationAppRoleArgsDict']]]]] = None,
|
|
1612
|
+
client_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1613
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1614
|
+
device_only_auth_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1615
|
+
disabled_by_microsoft: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1616
|
+
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1617
|
+
fallback_public_client_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1618
|
+
feature_tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationFeatureTagArgs', 'ApplicationFeatureTagArgsDict']]]]] = None,
|
|
1619
|
+
group_membership_claims: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1620
|
+
identifier_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1621
|
+
logo_image: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1622
|
+
logo_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1623
|
+
marketing_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1624
|
+
notes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1625
|
+
oauth2_permission_scope_ids: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1626
|
+
oauth2_post_response_required: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1627
|
+
object_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1628
|
+
optional_claims: Optional[pulumi.Input[Union['ApplicationOptionalClaimsArgs', 'ApplicationOptionalClaimsArgsDict']]] = None,
|
|
1629
|
+
owners: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1630
|
+
password: Optional[pulumi.Input[Union['ApplicationPasswordArgs', 'ApplicationPasswordArgsDict']]] = None,
|
|
1631
|
+
prevent_duplicate_names: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1632
|
+
privacy_statement_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1633
|
+
public_client: Optional[pulumi.Input[Union['ApplicationPublicClientArgs', 'ApplicationPublicClientArgsDict']]] = None,
|
|
1634
|
+
publisher_domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1635
|
+
required_resource_accesses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ApplicationRequiredResourceAccessArgs', 'ApplicationRequiredResourceAccessArgsDict']]]]] = None,
|
|
1636
|
+
service_management_reference: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1637
|
+
sign_in_audience: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1638
|
+
single_page_application: Optional[pulumi.Input[Union['ApplicationSinglePageApplicationArgs', 'ApplicationSinglePageApplicationArgsDict']]] = None,
|
|
1639
|
+
support_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1640
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1641
|
+
template_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1642
|
+
terms_of_service_url: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1643
|
+
web: Optional[pulumi.Input[Union['ApplicationWebArgs', 'ApplicationWebArgsDict']]] = None) -> 'Application':
|
|
1571
1644
|
"""
|
|
1572
1645
|
Get an existing Application resource's state with the given name, id, and optional extra
|
|
1573
1646
|
properties used to qualify the lookup.
|
|
@@ -1575,49 +1648,51 @@ class Application(pulumi.CustomResource):
|
|
|
1575
1648
|
:param str resource_name: The unique name of the resulting resource.
|
|
1576
1649
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1577
1650
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1578
|
-
:param pulumi.Input[
|
|
1579
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] app_role_ids: A mapping of app role values to app role IDs, intended to be useful when referencing app roles in other resources in your configuration.
|
|
1580
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1581
|
-
:param pulumi.Input[str]
|
|
1582
|
-
:param pulumi.Input[str]
|
|
1583
|
-
:param pulumi.Input[
|
|
1584
|
-
:param pulumi.Input[
|
|
1585
|
-
:param pulumi.Input[str]
|
|
1586
|
-
:param pulumi.Input[
|
|
1587
|
-
:param pulumi.Input[
|
|
1588
|
-
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ApplicationFeatureTagArgs']]]] feature_tags: A `feature_tags` block as described below. Cannot be used together with the `tags` property.
|
|
1651
|
+
:param pulumi.Input[Union['ApplicationApiArgs', 'ApplicationApiArgsDict']] api: An `api` block as documented below, which configures API related settings for this application.
|
|
1652
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] app_role_ids: A mapping of app role values to app role IDs, intended to be useful when referencing app roles in other resources in your configuration.
|
|
1653
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationAppRoleArgs', 'ApplicationAppRoleArgsDict']]]] app_roles: A collection of `app_role` blocks as documented below. For more information see [official documentation on Application Roles](https://docs.microsoft.com/en-us/azure/architecture/multitenant-identity/app-roles).
|
|
1654
|
+
:param pulumi.Input[_builtins.str] client_id: The Client ID for the application.
|
|
1655
|
+
:param pulumi.Input[_builtins.str] description: A description of the application, as shown to end users.
|
|
1656
|
+
:param pulumi.Input[_builtins.bool] device_only_auth_enabled: Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
1657
|
+
:param pulumi.Input[_builtins.str] disabled_by_microsoft: Whether Microsoft has disabled the registered application. If the application is disabled, this will be a string indicating the status/reason, e.g. `DisabledDueToViolationOfServicesAgreement`
|
|
1658
|
+
:param pulumi.Input[_builtins.str] display_name: The display name for the application.
|
|
1659
|
+
:param pulumi.Input[_builtins.bool] fallback_public_client_enabled: Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
1660
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationFeatureTagArgs', 'ApplicationFeatureTagArgsDict']]]] feature_tags: A `feature_tags` block as described below. Cannot be used together with the `tags` property.
|
|
1589
1661
|
|
|
1590
1662
|
> **Features and Tags** Features are configured for an application using tags, and are provided as a shortcut to set the corresponding magic tag value for each feature. You cannot configure `feature_tags` and `tags` for an application at the same time, so if you need to assign additional custom tags it's recommended to use the `tags` property instead. Tag values also propagate to any linked service principals.
|
|
1591
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_membership_claims:
|
|
1592
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
1593
|
-
:param pulumi.Input[str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
1594
|
-
:param pulumi.Input[str] logo_url: CDN URL to the application's logo, as uploaded with the `logo_image` property.
|
|
1595
|
-
:param pulumi.Input[str] marketing_url: URL of the application's marketing page.
|
|
1596
|
-
:param pulumi.Input[str] notes: User-specified notes relevant for the management of the application.
|
|
1597
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] oauth2_permission_scope_ids: A mapping of OAuth2.0 permission scope values to scope IDs, intended to be useful when referencing permission scopes in other resources in your configuration.
|
|
1598
|
-
:param pulumi.Input[bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
1599
|
-
:param pulumi.Input[str] object_id: The application's object ID.
|
|
1600
|
-
:param pulumi.Input[
|
|
1601
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
1602
|
-
:param pulumi.Input[
|
|
1603
|
-
|
|
1604
|
-
|
|
1605
|
-
:param pulumi.Input[
|
|
1606
|
-
:param pulumi.Input[
|
|
1607
|
-
:param pulumi.Input[
|
|
1608
|
-
:param pulumi.Input[str]
|
|
1663
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] group_membership_claims: A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
1664
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] identifier_uris: A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
1665
|
+
:param pulumi.Input[_builtins.str] logo_image: A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
1666
|
+
:param pulumi.Input[_builtins.str] logo_url: CDN URL to the application's logo, as uploaded with the `logo_image` property.
|
|
1667
|
+
:param pulumi.Input[_builtins.str] marketing_url: URL of the application's marketing page.
|
|
1668
|
+
:param pulumi.Input[_builtins.str] notes: User-specified notes relevant for the management of the application.
|
|
1669
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] oauth2_permission_scope_ids: A mapping of OAuth2.0 permission scope values to scope IDs, intended to be useful when referencing permission scopes in other resources in your configuration.
|
|
1670
|
+
:param pulumi.Input[_builtins.bool] oauth2_post_response_required: Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
1671
|
+
:param pulumi.Input[_builtins.str] object_id: The application's object ID.
|
|
1672
|
+
:param pulumi.Input[Union['ApplicationOptionalClaimsArgs', 'ApplicationOptionalClaimsArgsDict']] optional_claims: An `optional_claims` block as documented below.
|
|
1673
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] owners: A list of object IDs of principals that will be granted ownership of the application
|
|
1674
|
+
:param pulumi.Input[Union['ApplicationPasswordArgs', 'ApplicationPasswordArgsDict']] password: A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
1675
|
+
|
|
1676
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
1677
|
+
:param pulumi.Input[_builtins.bool] prevent_duplicate_names: If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
1678
|
+
:param pulumi.Input[_builtins.str] privacy_statement_url: URL of the application's privacy statement.
|
|
1679
|
+
:param pulumi.Input[Union['ApplicationPublicClientArgs', 'ApplicationPublicClientArgsDict']] public_client: A `public_client` block as documented below, which configures non-web app or non-web API application settings, for example mobile or other public clients such as an installed application running on a desktop device.
|
|
1680
|
+
:param pulumi.Input[_builtins.str] publisher_domain: The verified publisher domain for the application.
|
|
1681
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ApplicationRequiredResourceAccessArgs', 'ApplicationRequiredResourceAccessArgsDict']]]] required_resource_accesses: A collection of `required_resource_access` blocks as documented below.
|
|
1682
|
+
:param pulumi.Input[_builtins.str] service_management_reference: References application context information from a Service or Asset Management database.
|
|
1683
|
+
:param pulumi.Input[_builtins.str] sign_in_audience: The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
1609
1684
|
|
|
1610
1685
|
> **Changing `sign_in_audience` for existing applications** When updating an existing application to use a `sign_in_audience` value of `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`, your configuration may no longer be valid. Refer to [official documentation](https://docs.microsoft.com/en-gb/azure/active-directory/develop/supported-accounts-validation) to understand the differences in supported configurations. Where possible, the provider will attempt to validate your configuration and try to avoid applying unsupported settings to your application.
|
|
1611
|
-
:param pulumi.Input[
|
|
1612
|
-
:param pulumi.Input[str] support_url: URL of the application's support page.
|
|
1613
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
1686
|
+
:param pulumi.Input[Union['ApplicationSinglePageApplicationArgs', 'ApplicationSinglePageApplicationArgsDict']] single_page_application: A `single_page_application` block as documented below, which configures single-page application (SPA) related settings for this application.
|
|
1687
|
+
:param pulumi.Input[_builtins.str] support_url: URL of the application's support page.
|
|
1688
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
1614
1689
|
|
|
1615
1690
|
> **Tags and Features** Azure Active Directory uses special tag values to configure the behavior of applications. These can be specified using either the `tags` property or with the `feature_tags` block. If you need to set any custom tag values not supported by the `feature_tags` block, it's recommended to use the `tags` property. Tag values also propagate to any linked service principals.
|
|
1616
|
-
:param pulumi.Input[str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
1691
|
+
:param pulumi.Input[_builtins.str] template_id: Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
1617
1692
|
|
|
1618
1693
|
> **Tip for Gallery Applications** This resource can be used to instantiate a gallery application, however it will also attempt to manage the properties of the resulting application. If this is not desired, consider using the ApplicationRegistration resource instead.
|
|
1619
|
-
:param pulumi.Input[str] terms_of_service_url: URL of the application's terms of service statement.
|
|
1620
|
-
:param pulumi.Input[
|
|
1694
|
+
:param pulumi.Input[_builtins.str] terms_of_service_url: URL of the application's terms of service statement.
|
|
1695
|
+
:param pulumi.Input[Union['ApplicationWebArgs', 'ApplicationWebArgsDict']] web: A `web` block as documented below, which configures web related settings for this application.
|
|
1621
1696
|
|
|
1622
1697
|
> **Application Name Uniqueness** Application names are not unique within Azure Active Directory. Use the `prevent_duplicate_names` argument to check for existing applications if you want to avoid name collisions.
|
|
1623
1698
|
"""
|
|
@@ -1628,7 +1703,6 @@ class Application(pulumi.CustomResource):
|
|
|
1628
1703
|
__props__.__dict__["api"] = api
|
|
1629
1704
|
__props__.__dict__["app_role_ids"] = app_role_ids
|
|
1630
1705
|
__props__.__dict__["app_roles"] = app_roles
|
|
1631
|
-
__props__.__dict__["application_id"] = application_id
|
|
1632
1706
|
__props__.__dict__["client_id"] = client_id
|
|
1633
1707
|
__props__.__dict__["description"] = description
|
|
1634
1708
|
__props__.__dict__["device_only_auth_enabled"] = device_only_auth_enabled
|
|
@@ -1647,6 +1721,7 @@ class Application(pulumi.CustomResource):
|
|
|
1647
1721
|
__props__.__dict__["object_id"] = object_id
|
|
1648
1722
|
__props__.__dict__["optional_claims"] = optional_claims
|
|
1649
1723
|
__props__.__dict__["owners"] = owners
|
|
1724
|
+
__props__.__dict__["password"] = password
|
|
1650
1725
|
__props__.__dict__["prevent_duplicate_names"] = prevent_duplicate_names
|
|
1651
1726
|
__props__.__dict__["privacy_statement_url"] = privacy_statement_url
|
|
1652
1727
|
__props__.__dict__["public_client"] = public_client
|
|
@@ -1662,7 +1737,7 @@ class Application(pulumi.CustomResource):
|
|
|
1662
1737
|
__props__.__dict__["web"] = web
|
|
1663
1738
|
return Application(resource_name, opts=opts, __props__=__props__)
|
|
1664
1739
|
|
|
1665
|
-
@property
|
|
1740
|
+
@_builtins.property
|
|
1666
1741
|
@pulumi.getter
|
|
1667
1742
|
def api(self) -> pulumi.Output[Optional['outputs.ApplicationApi']]:
|
|
1668
1743
|
"""
|
|
@@ -1670,15 +1745,15 @@ class Application(pulumi.CustomResource):
|
|
|
1670
1745
|
"""
|
|
1671
1746
|
return pulumi.get(self, "api")
|
|
1672
1747
|
|
|
1673
|
-
@property
|
|
1748
|
+
@_builtins.property
|
|
1674
1749
|
@pulumi.getter(name="appRoleIds")
|
|
1675
|
-
def app_role_ids(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1750
|
+
def app_role_ids(self) -> pulumi.Output[Mapping[str, _builtins.str]]:
|
|
1676
1751
|
"""
|
|
1677
1752
|
A mapping of app role values to app role IDs, intended to be useful when referencing app roles in other resources in your configuration.
|
|
1678
1753
|
"""
|
|
1679
1754
|
return pulumi.get(self, "app_role_ids")
|
|
1680
1755
|
|
|
1681
|
-
@property
|
|
1756
|
+
@_builtins.property
|
|
1682
1757
|
@pulumi.getter(name="appRoles")
|
|
1683
1758
|
def app_roles(self) -> pulumi.Output[Optional[Sequence['outputs.ApplicationAppRole']]]:
|
|
1684
1759
|
"""
|
|
@@ -1686,66 +1761,55 @@ class Application(pulumi.CustomResource):
|
|
|
1686
1761
|
"""
|
|
1687
1762
|
return pulumi.get(self, "app_roles")
|
|
1688
1763
|
|
|
1689
|
-
@property
|
|
1690
|
-
@pulumi.getter(name="applicationId")
|
|
1691
|
-
def application_id(self) -> pulumi.Output[str]:
|
|
1692
|
-
"""
|
|
1693
|
-
The Application ID (also called Client ID)
|
|
1694
|
-
"""
|
|
1695
|
-
warnings.warn("""The `application_id` attribute has been replaced by the `client_id` attribute and will be removed in version 3.0 of the AzureAD provider""", DeprecationWarning)
|
|
1696
|
-
pulumi.log.warn("""application_id is deprecated: The `application_id` attribute has been replaced by the `client_id` attribute and will be removed in version 3.0 of the AzureAD provider""")
|
|
1697
|
-
|
|
1698
|
-
return pulumi.get(self, "application_id")
|
|
1699
|
-
|
|
1700
|
-
@property
|
|
1764
|
+
@_builtins.property
|
|
1701
1765
|
@pulumi.getter(name="clientId")
|
|
1702
|
-
def client_id(self) -> pulumi.Output[str]:
|
|
1766
|
+
def client_id(self) -> pulumi.Output[_builtins.str]:
|
|
1703
1767
|
"""
|
|
1704
1768
|
The Client ID for the application.
|
|
1705
1769
|
"""
|
|
1706
1770
|
return pulumi.get(self, "client_id")
|
|
1707
1771
|
|
|
1708
|
-
@property
|
|
1772
|
+
@_builtins.property
|
|
1709
1773
|
@pulumi.getter
|
|
1710
|
-
def description(self) -> pulumi.Output[Optional[str]]:
|
|
1774
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1711
1775
|
"""
|
|
1712
1776
|
A description of the application, as shown to end users.
|
|
1713
1777
|
"""
|
|
1714
1778
|
return pulumi.get(self, "description")
|
|
1715
1779
|
|
|
1716
|
-
@property
|
|
1780
|
+
@_builtins.property
|
|
1717
1781
|
@pulumi.getter(name="deviceOnlyAuthEnabled")
|
|
1718
|
-
def device_only_auth_enabled(self) -> pulumi.Output[Optional[bool]]:
|
|
1782
|
+
def device_only_auth_enabled(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1719
1783
|
"""
|
|
1720
1784
|
Specifies whether this application supports device authentication without a user. Defaults to `false`.
|
|
1721
1785
|
"""
|
|
1722
1786
|
return pulumi.get(self, "device_only_auth_enabled")
|
|
1723
1787
|
|
|
1724
|
-
@property
|
|
1788
|
+
@_builtins.property
|
|
1725
1789
|
@pulumi.getter(name="disabledByMicrosoft")
|
|
1726
|
-
def disabled_by_microsoft(self) -> pulumi.Output[str]:
|
|
1790
|
+
def disabled_by_microsoft(self) -> pulumi.Output[_builtins.str]:
|
|
1727
1791
|
"""
|
|
1728
1792
|
Whether Microsoft has disabled the registered application. If the application is disabled, this will be a string indicating the status/reason, e.g. `DisabledDueToViolationOfServicesAgreement`
|
|
1729
1793
|
"""
|
|
1730
1794
|
return pulumi.get(self, "disabled_by_microsoft")
|
|
1731
1795
|
|
|
1732
|
-
@property
|
|
1796
|
+
@_builtins.property
|
|
1733
1797
|
@pulumi.getter(name="displayName")
|
|
1734
|
-
def display_name(self) -> pulumi.Output[str]:
|
|
1798
|
+
def display_name(self) -> pulumi.Output[_builtins.str]:
|
|
1735
1799
|
"""
|
|
1736
1800
|
The display name for the application.
|
|
1737
1801
|
"""
|
|
1738
1802
|
return pulumi.get(self, "display_name")
|
|
1739
1803
|
|
|
1740
|
-
@property
|
|
1804
|
+
@_builtins.property
|
|
1741
1805
|
@pulumi.getter(name="fallbackPublicClientEnabled")
|
|
1742
|
-
def fallback_public_client_enabled(self) -> pulumi.Output[Optional[bool]]:
|
|
1806
|
+
def fallback_public_client_enabled(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1743
1807
|
"""
|
|
1744
1808
|
Specifies whether the application is a public client. Appropriate for apps using token grant flows that don't use a redirect URI. Defaults to `false`.
|
|
1745
1809
|
"""
|
|
1746
1810
|
return pulumi.get(self, "fallback_public_client_enabled")
|
|
1747
1811
|
|
|
1748
|
-
@property
|
|
1812
|
+
@_builtins.property
|
|
1749
1813
|
@pulumi.getter(name="featureTags")
|
|
1750
1814
|
def feature_tags(self) -> pulumi.Output[Sequence['outputs.ApplicationFeatureTag']]:
|
|
1751
1815
|
"""
|
|
@@ -1755,79 +1819,79 @@ class Application(pulumi.CustomResource):
|
|
|
1755
1819
|
"""
|
|
1756
1820
|
return pulumi.get(self, "feature_tags")
|
|
1757
1821
|
|
|
1758
|
-
@property
|
|
1822
|
+
@_builtins.property
|
|
1759
1823
|
@pulumi.getter(name="groupMembershipClaims")
|
|
1760
|
-
def group_membership_claims(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1824
|
+
def group_membership_claims(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1761
1825
|
"""
|
|
1762
|
-
|
|
1826
|
+
A set of strings containing membership claims issued in a user or OAuth 2.0 access token that the app expects. Possible values are `None`, `SecurityGroup`, `DirectoryRole`, `ApplicationGroup` or `All`.
|
|
1763
1827
|
"""
|
|
1764
1828
|
return pulumi.get(self, "group_membership_claims")
|
|
1765
1829
|
|
|
1766
|
-
@property
|
|
1830
|
+
@_builtins.property
|
|
1767
1831
|
@pulumi.getter(name="identifierUris")
|
|
1768
|
-
def identifier_uris(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1832
|
+
def identifier_uris(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1769
1833
|
"""
|
|
1770
1834
|
A set of user-defined URI(s) that uniquely identify an application within its Azure AD tenant, or within a verified custom domain if the application is multi-tenant.
|
|
1771
1835
|
"""
|
|
1772
1836
|
return pulumi.get(self, "identifier_uris")
|
|
1773
1837
|
|
|
1774
|
-
@property
|
|
1838
|
+
@_builtins.property
|
|
1775
1839
|
@pulumi.getter(name="logoImage")
|
|
1776
|
-
def logo_image(self) -> pulumi.Output[Optional[str]]:
|
|
1840
|
+
def logo_image(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1777
1841
|
"""
|
|
1778
1842
|
A logo image to upload for the application, as a raw base64-encoded string. The image should be in gif, jpeg or png format. Note that once an image has been uploaded, it is not possible to remove it without replacing it with another image.
|
|
1779
1843
|
"""
|
|
1780
1844
|
return pulumi.get(self, "logo_image")
|
|
1781
1845
|
|
|
1782
|
-
@property
|
|
1846
|
+
@_builtins.property
|
|
1783
1847
|
@pulumi.getter(name="logoUrl")
|
|
1784
|
-
def logo_url(self) -> pulumi.Output[str]:
|
|
1848
|
+
def logo_url(self) -> pulumi.Output[_builtins.str]:
|
|
1785
1849
|
"""
|
|
1786
1850
|
CDN URL to the application's logo, as uploaded with the `logo_image` property.
|
|
1787
1851
|
"""
|
|
1788
1852
|
return pulumi.get(self, "logo_url")
|
|
1789
1853
|
|
|
1790
|
-
@property
|
|
1854
|
+
@_builtins.property
|
|
1791
1855
|
@pulumi.getter(name="marketingUrl")
|
|
1792
|
-
def marketing_url(self) -> pulumi.Output[Optional[str]]:
|
|
1856
|
+
def marketing_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1793
1857
|
"""
|
|
1794
1858
|
URL of the application's marketing page.
|
|
1795
1859
|
"""
|
|
1796
1860
|
return pulumi.get(self, "marketing_url")
|
|
1797
1861
|
|
|
1798
|
-
@property
|
|
1862
|
+
@_builtins.property
|
|
1799
1863
|
@pulumi.getter
|
|
1800
|
-
def notes(self) -> pulumi.Output[Optional[str]]:
|
|
1864
|
+
def notes(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1801
1865
|
"""
|
|
1802
1866
|
User-specified notes relevant for the management of the application.
|
|
1803
1867
|
"""
|
|
1804
1868
|
return pulumi.get(self, "notes")
|
|
1805
1869
|
|
|
1806
|
-
@property
|
|
1870
|
+
@_builtins.property
|
|
1807
1871
|
@pulumi.getter(name="oauth2PermissionScopeIds")
|
|
1808
|
-
def oauth2_permission_scope_ids(self) -> pulumi.Output[Mapping[str, str]]:
|
|
1872
|
+
def oauth2_permission_scope_ids(self) -> pulumi.Output[Mapping[str, _builtins.str]]:
|
|
1809
1873
|
"""
|
|
1810
1874
|
A mapping of OAuth2.0 permission scope values to scope IDs, intended to be useful when referencing permission scopes in other resources in your configuration.
|
|
1811
1875
|
"""
|
|
1812
1876
|
return pulumi.get(self, "oauth2_permission_scope_ids")
|
|
1813
1877
|
|
|
1814
|
-
@property
|
|
1878
|
+
@_builtins.property
|
|
1815
1879
|
@pulumi.getter(name="oauth2PostResponseRequired")
|
|
1816
|
-
def oauth2_post_response_required(self) -> pulumi.Output[Optional[bool]]:
|
|
1880
|
+
def oauth2_post_response_required(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1817
1881
|
"""
|
|
1818
1882
|
Specifies whether, as part of OAuth 2.0 token requests, Azure AD allows POST requests, as opposed to GET requests. Defaults to `false`, which specifies that only GET requests are allowed.
|
|
1819
1883
|
"""
|
|
1820
1884
|
return pulumi.get(self, "oauth2_post_response_required")
|
|
1821
1885
|
|
|
1822
|
-
@property
|
|
1886
|
+
@_builtins.property
|
|
1823
1887
|
@pulumi.getter(name="objectId")
|
|
1824
|
-
def object_id(self) -> pulumi.Output[str]:
|
|
1888
|
+
def object_id(self) -> pulumi.Output[_builtins.str]:
|
|
1825
1889
|
"""
|
|
1826
1890
|
The application's object ID.
|
|
1827
1891
|
"""
|
|
1828
1892
|
return pulumi.get(self, "object_id")
|
|
1829
1893
|
|
|
1830
|
-
@property
|
|
1894
|
+
@_builtins.property
|
|
1831
1895
|
@pulumi.getter(name="optionalClaims")
|
|
1832
1896
|
def optional_claims(self) -> pulumi.Output[Optional['outputs.ApplicationOptionalClaims']]:
|
|
1833
1897
|
"""
|
|
@@ -1835,31 +1899,41 @@ class Application(pulumi.CustomResource):
|
|
|
1835
1899
|
"""
|
|
1836
1900
|
return pulumi.get(self, "optional_claims")
|
|
1837
1901
|
|
|
1838
|
-
@property
|
|
1902
|
+
@_builtins.property
|
|
1839
1903
|
@pulumi.getter
|
|
1840
|
-
def owners(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1904
|
+
def owners(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1841
1905
|
"""
|
|
1842
1906
|
A list of object IDs of principals that will be granted ownership of the application
|
|
1843
1907
|
"""
|
|
1844
1908
|
return pulumi.get(self, "owners")
|
|
1845
1909
|
|
|
1846
|
-
@property
|
|
1910
|
+
@_builtins.property
|
|
1911
|
+
@pulumi.getter
|
|
1912
|
+
def password(self) -> pulumi.Output[Optional['outputs.ApplicationPassword']]:
|
|
1913
|
+
"""
|
|
1914
|
+
A single `password` block as documented below. The password is generated during creation. By default, no password is generated.
|
|
1915
|
+
|
|
1916
|
+
> **Creating a Password** The `password` block supports a single password for the application, and is provided so that a password can be generated when a new application is created. This helps to make new applications available for authentication more quickly. To add additional passwords to an application, see the ApplicationPassword resource.
|
|
1917
|
+
"""
|
|
1918
|
+
return pulumi.get(self, "password")
|
|
1919
|
+
|
|
1920
|
+
@_builtins.property
|
|
1847
1921
|
@pulumi.getter(name="preventDuplicateNames")
|
|
1848
|
-
def prevent_duplicate_names(self) -> pulumi.Output[Optional[bool]]:
|
|
1922
|
+
def prevent_duplicate_names(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1849
1923
|
"""
|
|
1850
1924
|
If `true`, will return an error if an existing application is found with the same name. Defaults to `false`.
|
|
1851
1925
|
"""
|
|
1852
1926
|
return pulumi.get(self, "prevent_duplicate_names")
|
|
1853
1927
|
|
|
1854
|
-
@property
|
|
1928
|
+
@_builtins.property
|
|
1855
1929
|
@pulumi.getter(name="privacyStatementUrl")
|
|
1856
|
-
def privacy_statement_url(self) -> pulumi.Output[Optional[str]]:
|
|
1930
|
+
def privacy_statement_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1857
1931
|
"""
|
|
1858
1932
|
URL of the application's privacy statement.
|
|
1859
1933
|
"""
|
|
1860
1934
|
return pulumi.get(self, "privacy_statement_url")
|
|
1861
1935
|
|
|
1862
|
-
@property
|
|
1936
|
+
@_builtins.property
|
|
1863
1937
|
@pulumi.getter(name="publicClient")
|
|
1864
1938
|
def public_client(self) -> pulumi.Output[Optional['outputs.ApplicationPublicClient']]:
|
|
1865
1939
|
"""
|
|
@@ -1867,15 +1941,15 @@ class Application(pulumi.CustomResource):
|
|
|
1867
1941
|
"""
|
|
1868
1942
|
return pulumi.get(self, "public_client")
|
|
1869
1943
|
|
|
1870
|
-
@property
|
|
1944
|
+
@_builtins.property
|
|
1871
1945
|
@pulumi.getter(name="publisherDomain")
|
|
1872
|
-
def publisher_domain(self) -> pulumi.Output[str]:
|
|
1946
|
+
def publisher_domain(self) -> pulumi.Output[_builtins.str]:
|
|
1873
1947
|
"""
|
|
1874
1948
|
The verified publisher domain for the application.
|
|
1875
1949
|
"""
|
|
1876
1950
|
return pulumi.get(self, "publisher_domain")
|
|
1877
1951
|
|
|
1878
|
-
@property
|
|
1952
|
+
@_builtins.property
|
|
1879
1953
|
@pulumi.getter(name="requiredResourceAccesses")
|
|
1880
1954
|
def required_resource_accesses(self) -> pulumi.Output[Optional[Sequence['outputs.ApplicationRequiredResourceAccess']]]:
|
|
1881
1955
|
"""
|
|
@@ -1883,17 +1957,17 @@ class Application(pulumi.CustomResource):
|
|
|
1883
1957
|
"""
|
|
1884
1958
|
return pulumi.get(self, "required_resource_accesses")
|
|
1885
1959
|
|
|
1886
|
-
@property
|
|
1960
|
+
@_builtins.property
|
|
1887
1961
|
@pulumi.getter(name="serviceManagementReference")
|
|
1888
|
-
def service_management_reference(self) -> pulumi.Output[Optional[str]]:
|
|
1962
|
+
def service_management_reference(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1889
1963
|
"""
|
|
1890
1964
|
References application context information from a Service or Asset Management database.
|
|
1891
1965
|
"""
|
|
1892
1966
|
return pulumi.get(self, "service_management_reference")
|
|
1893
1967
|
|
|
1894
|
-
@property
|
|
1968
|
+
@_builtins.property
|
|
1895
1969
|
@pulumi.getter(name="signInAudience")
|
|
1896
|
-
def sign_in_audience(self) -> pulumi.Output[Optional[str]]:
|
|
1970
|
+
def sign_in_audience(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1897
1971
|
"""
|
|
1898
1972
|
The Microsoft account types that are supported for the current application. Must be one of `AzureADMyOrg`, `AzureADMultipleOrgs`, `AzureADandPersonalMicrosoftAccount` or `PersonalMicrosoftAccount`. Defaults to `AzureADMyOrg`.
|
|
1899
1973
|
|
|
@@ -1901,7 +1975,7 @@ class Application(pulumi.CustomResource):
|
|
|
1901
1975
|
"""
|
|
1902
1976
|
return pulumi.get(self, "sign_in_audience")
|
|
1903
1977
|
|
|
1904
|
-
@property
|
|
1978
|
+
@_builtins.property
|
|
1905
1979
|
@pulumi.getter(name="singlePageApplication")
|
|
1906
1980
|
def single_page_application(self) -> pulumi.Output[Optional['outputs.ApplicationSinglePageApplication']]:
|
|
1907
1981
|
"""
|
|
@@ -1909,17 +1983,17 @@ class Application(pulumi.CustomResource):
|
|
|
1909
1983
|
"""
|
|
1910
1984
|
return pulumi.get(self, "single_page_application")
|
|
1911
1985
|
|
|
1912
|
-
@property
|
|
1986
|
+
@_builtins.property
|
|
1913
1987
|
@pulumi.getter(name="supportUrl")
|
|
1914
|
-
def support_url(self) -> pulumi.Output[Optional[str]]:
|
|
1988
|
+
def support_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1915
1989
|
"""
|
|
1916
1990
|
URL of the application's support page.
|
|
1917
1991
|
"""
|
|
1918
1992
|
return pulumi.get(self, "support_url")
|
|
1919
1993
|
|
|
1920
|
-
@property
|
|
1994
|
+
@_builtins.property
|
|
1921
1995
|
@pulumi.getter
|
|
1922
|
-
def tags(self) -> pulumi.Output[Sequence[str]]:
|
|
1996
|
+
def tags(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1923
1997
|
"""
|
|
1924
1998
|
A set of tags to apply to the application for configuring specific behaviours of the application and linked service principals. Note that these are not provided for use by practitioners. Cannot be used together with the `feature_tags` block.
|
|
1925
1999
|
|
|
@@ -1927,9 +2001,9 @@ class Application(pulumi.CustomResource):
|
|
|
1927
2001
|
"""
|
|
1928
2002
|
return pulumi.get(self, "tags")
|
|
1929
2003
|
|
|
1930
|
-
@property
|
|
2004
|
+
@_builtins.property
|
|
1931
2005
|
@pulumi.getter(name="templateId")
|
|
1932
|
-
def template_id(self) -> pulumi.Output[str]:
|
|
2006
|
+
def template_id(self) -> pulumi.Output[_builtins.str]:
|
|
1933
2007
|
"""
|
|
1934
2008
|
Unique ID for a templated application in the Azure AD App Gallery, from which to create the application. Changing this forces a new resource to be created.
|
|
1935
2009
|
|
|
@@ -1937,15 +2011,15 @@ class Application(pulumi.CustomResource):
|
|
|
1937
2011
|
"""
|
|
1938
2012
|
return pulumi.get(self, "template_id")
|
|
1939
2013
|
|
|
1940
|
-
@property
|
|
2014
|
+
@_builtins.property
|
|
1941
2015
|
@pulumi.getter(name="termsOfServiceUrl")
|
|
1942
|
-
def terms_of_service_url(self) -> pulumi.Output[Optional[str]]:
|
|
2016
|
+
def terms_of_service_url(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1943
2017
|
"""
|
|
1944
2018
|
URL of the application's terms of service statement.
|
|
1945
2019
|
"""
|
|
1946
2020
|
return pulumi.get(self, "terms_of_service_url")
|
|
1947
2021
|
|
|
1948
|
-
@property
|
|
2022
|
+
@_builtins.property
|
|
1949
2023
|
@pulumi.getter
|
|
1950
2024
|
def web(self) -> pulumi.Output[Optional['outputs.ApplicationWeb']]:
|
|
1951
2025
|
"""
|