create_verified_access_trust_provider async ¶

async def create_verified_access_trust_provider(
    self,
    *,
    config_overrides: Optional[AsyncEC2ClientConfig] = None,
    trust_provider_type: Optional[
        "capo_ec2.types.trust_provider_type.TrustProviderType"
    ] = None,
    user_trust_provider_type: Optional[
        "capo_ec2.types.user_trust_provider_type.UserTrustProviderType"
    ] = None,
    device_trust_provider_type: Optional[
        "capo_ec2.types.device_trust_provider_type.DeviceTrustProviderType"
    ] = None,
    oidc_options: Optional[
        "capo_ec2.types.create_verified_access_trust_provider_oidc_options.CreateVerifiedAccessTrustProviderOidcOptions"
    ] = None,
    device_options: Optional[
        "capo_ec2.types.create_verified_access_trust_provider_device_options.CreateVerifiedAccessTrustProviderDeviceOptions"
    ] = None,
    policy_reference_name: Optional["capo_ec2.types.string.String"] = None,
    description: Optional["capo_ec2.types.string.String"] = None,
    tag_specifications: Optional[
        "capo_ec2.types.tag_specification_list.TagSpecificationList"
    ] = None,
    client_token: Optional["capo_ec2.types.string.String"] = None,
    dry_run: Optional["capo_ec2.types.boolean.Boolean"] = None,
    sse_specification: Optional[
        "capo_ec2.types.verified_access_sse_specification_request.VerifiedAccessSseSpecificationRequest"
    ] = None,
    native_application_oidc_options: Optional[
        "capo_ec2.types.create_verified_access_native_application_oidc_options.CreateVerifiedAccessNativeApplicationOidcOptions"
    ] = None,
) -> "capo_ec2.types.create_verified_access_trust_provider_result.CreateVerifiedAccessTrustProviderResult":
    """<p>A trust provider is a third-party entity that creates, maintains, and manages identity information for users and devices. When an application request is made, the identity information sent by the trust provider is evaluated by Verified Access before allowing or denying the application request.</p>

    Args:
        trust_provider_type: <p>The type of trust provider.</p>
        user_trust_provider_type: <p>The type of user-based trust provider. This parameter is required when the provider type is <code>user</code>.</p>
        device_trust_provider_type: <p>The type of device-based trust provider. This parameter is required when the provider type is <code>device</code>.</p>
        oidc_options: <p>The options for a OpenID Connect-compatible user-identity trust provider. This parameter is required when the provider type is <code>user</code>.</p>
        device_options: <p>The options for a device-based trust provider. This parameter is required when the provider type is <code>device</code>.</p>
        policy_reference_name: <p>The identifier to be used when working with policy rules.</p>
        description: <p>A description for the Verified Access trust provider.</p>
        tag_specifications: <p>The tags to assign to the Verified Access trust provider.</p>
        client_token: <p>A unique, case-sensitive token that you provide to ensure idempotency of your modification request. For more information, see <a href="https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html">Ensuring idempotency</a>.</p>
        dry_run: <p>Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>
        sse_specification: <p>The options for server side encryption.</p>
        native_application_oidc_options: <p>The OpenID Connect (OIDC) options.</p>

    Raises:
        capo_ec2.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_ec2.types.create_verified_access_trust_provider_request.CreateVerifiedAccessTrustProviderRequest]",
    ) -> AsyncOperationResponse[
        "capo_ec2.types.create_verified_access_trust_provider_result.CreateVerifiedAccessTrustProviderResult"
    ]:
        import capo_ec2._operations.amazon_ec2.create_verified_access_trust_provider

        (
            output,
            http_response,
        ) = await capo_ec2._operations.amazon_ec2.create_verified_access_trust_provider.async_create_verified_access_trust_provider(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_ec2.types.create_verified_access_trust_provider_request.CreateVerifiedAccessTrustProviderRequest",
    ) -> dict[str, Any]:
        import capo_ec2.types.create_verified_access_trust_provider_request

        return capo_ec2.types.create_verified_access_trust_provider_request.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_ec2.types.create_verified_access_trust_provider_result.CreateVerifiedAccessTrustProviderResult",
    ) -> dict[str, Any]:
        import capo_ec2.types.create_verified_access_trust_provider_result

        return capo_ec2.types.create_verified_access_trust_provider_result.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "CreateVerifiedAccessTrustProvider",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_ec2.types.create_verified_access_trust_provider_request.CreateVerifiedAccessTrustProviderRequest = {}
    if trust_provider_type is not None:
        input_["trust_provider_type"] = trust_provider_type
    if user_trust_provider_type is not None:
        input_["user_trust_provider_type"] = user_trust_provider_type
    if device_trust_provider_type is not None:
        input_["device_trust_provider_type"] = device_trust_provider_type
    if oidc_options is not None:
        input_["oidc_options"] = oidc_options
    if device_options is not None:
        input_["device_options"] = device_options
    if policy_reference_name is not None:
        input_["policy_reference_name"] = policy_reference_name
    if description is not None:
        input_["description"] = description
    if tag_specifications is not None:
        input_["tag_specifications"] = tag_specifications
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token
    if dry_run is not None:
        input_["dry_run"] = dry_run
    if sse_specification is not None:
        input_["sse_specification"] = sse_specification
    if native_application_oidc_options is not None:
        input_["native_application_oidc_options"] = native_application_oidc_options

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