update_identity_provider_settings async ¶

async def update_identity_provider_settings(
    self,
    update_settings: "capo_license_manager_user_subscriptions.types.update_settings.UpdateSettings",
    *,
    config_overrides: Optional[
        AsyncLicenseManagerUserSubscriptionsClientConfig
    ] = None,
    identity_provider: Optional[
        "capo_license_manager_user_subscriptions.types.identity_provider.IdentityProvider"
    ] = None,
    product: Optional[str] = None,
    identity_provider_arn: Optional[
        "capo_license_manager_user_subscriptions.types.arn.Arn"
    ] = None,
) -> "capo_license_manager_user_subscriptions.types.update_identity_provider_settings_response.UpdateIdentityProviderSettingsResponse":
    """<p>Updates additional product configuration settings for the registered identity provider.</p>

    Args:
        product: <p>The name of the user-based subscription product.</p> <p>Valid values: <code>VISUAL_STUDIO_ENTERPRISE</code> | <code>VISUAL_STUDIO_PROFESSIONAL</code> | <code>OFFICE_PROFESSIONAL_PLUS</code> | <code>OFFICE_STANDARD</code> | <code>REMOTE_DESKTOP_SERVICES</code> </p>
        identity_provider_arn: <p>The Amazon Resource Name (ARN) of the identity provider to update.</p>
        update_settings: <p>Updates the registered identity provider’s product related configuration settings. You can update any combination of settings in a single operation such as the:</p> <ul> <li> <p>Subnets which you want to add to provision VPC endpoints.</p> </li> <li> <p>Subnets which you want to remove the VPC endpoints from.</p> </li> <li> <p>Security group ID which permits traffic to the VPC endpoints.</p> </li> </ul>

    Raises:
        capo_license_manager_user_subscriptions.errors.access_denied_exception.AccessDeniedException: <p>You don't have sufficient access to perform this action.</p>
        capo_license_manager_user_subscriptions.errors.internal_server_exception.InternalServerException: <p>An exception occurred with the service.</p>
        capo_license_manager_user_subscriptions.errors.throttling_exception.ThrottlingException: <p>The request was denied because of request throttling. Retry the request.</p>
        capo_license_manager_user_subscriptions.errors.validation_exception.ValidationException: <p>A parameter is not valid.</p>
        capo_license_manager_user_subscriptions.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_license_manager_user_subscriptions.types.update_identity_provider_settings_request.UpdateIdentityProviderSettingsRequest]",
    ) -> AsyncOperationResponse[
        "capo_license_manager_user_subscriptions.types.update_identity_provider_settings_response.UpdateIdentityProviderSettingsResponse"
    ]:
        import capo_license_manager_user_subscriptions._operations.license_manager_user_subscriptions.update_identity_provider_settings

        (
            output,
            http_response,
        ) = await capo_license_manager_user_subscriptions._operations.license_manager_user_subscriptions.update_identity_provider_settings.async_update_identity_provider_settings(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("UpdateIdentityProviderSettings")
    )
    input_: capo_license_manager_user_subscriptions.types.update_identity_provider_settings_request.UpdateIdentityProviderSettingsRequest = {
        "update_settings": update_settings
    }
    if identity_provider is not None:
        input_["identity_provider"] = identity_provider
    if product is not None:
        input_["product"] = product
    if identity_provider_arn is not None:
        input_["identity_provider_arn"] = identity_provider_arn

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output