Api class

Manages an AWS AppSync Event API. Event APIs enable real-time subscriptions and event-driven communication in AppSync applications.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.appsync.Api("example", {
    eventConfig: {
        authProviders: [{
            authType: "API_KEY",
        }],
        connectionAuthModes: [{
            authType: "API_KEY",
        }],
        defaultPublishAuthModes: [{
            authType: "API_KEY",
        }],
        defaultSubscribeAuthModes: [{
            authType: "API_KEY",
        }],
    },
    name: "example-event-api",
});

import pulumi
import pulumi_aws as aws

example = aws.appsync.Api("example",
    event_config={
        "auth_providers": [{
            "auth_type": "API_KEY",
        }],
        "connection_auth_modes": [{
            "auth_type": "API_KEY",
        }],
        "default_publish_auth_modes": [{
            "auth_type": "API_KEY",
        }],
        "default_subscribe_auth_modes": [{
            "auth_type": "API_KEY",
        }],
    },
    name="example-event-api")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.AppSync.Api("example", new()
    {
        EventConfig = new Aws.AppSync.Inputs.ApiEventConfigArgs
        {
            AuthProviders = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigAuthProviderArgs
                {
                    AuthType = "API_KEY",
                },
            },
            ConnectionAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigConnectionAuthModeArgs
                {
                    AuthType = "API_KEY",
                },
            },
            DefaultPublishAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigDefaultPublishAuthModeArgs
                {
                    AuthType = "API_KEY",
                },
            },
            DefaultSubscribeAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigDefaultSubscribeAuthModeArgs
                {
                    AuthType = "API_KEY",
                },
            },
        },
        Name = "example-event-api",
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/appsync"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := appsync.NewApi(ctx, "example", &appsync.ApiArgs{
			EventConfig: &appsync.ApiEventConfigArgs{
				AuthProviders: appsync.ApiEventConfigAuthProviderArray{
					&appsync.ApiEventConfigAuthProviderArgs{
						AuthType: pulumi.String("API_KEY"),
					},
				},
				ConnectionAuthModes: appsync.ApiEventConfigConnectionAuthModeArray{
					&appsync.ApiEventConfigConnectionAuthModeArgs{
						AuthType: pulumi.String("API_KEY"),
					},
				},
				DefaultPublishAuthModes: appsync.ApiEventConfigDefaultPublishAuthModeArray{
					&appsync.ApiEventConfigDefaultPublishAuthModeArgs{
						AuthType: pulumi.String("API_KEY"),
					},
				},
				DefaultSubscribeAuthModes: appsync.ApiEventConfigDefaultSubscribeAuthModeArray{
					&appsync.ApiEventConfigDefaultSubscribeAuthModeArgs{
						AuthType: pulumi.String("API_KEY"),
					},
				},
			},
			Name: pulumi.String("example-event-api"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_appsync_api" "example" {
  event_config = {
    auth_providers = [{
      "authType" = "API_KEY"
    }]
    connection_auth_modes = [{
      "authType" = "API_KEY"
    }]
    default_publish_auth_modes = [{
      "authType" = "API_KEY"
    }]
    default_subscribe_auth_modes = [{
      "authType" = "API_KEY"
    }]
  }
  name = "example-event-api"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appsync.Api;
import com.pulumi.aws.appsync.ApiArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigAuthProviderArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigConnectionAuthModeArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigDefaultPublishAuthModeArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigDefaultSubscribeAuthModeArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Api("example", ApiArgs.builder()
            .eventConfig(ApiEventConfigArgs.builder()
                .authProviders(ApiEventConfigAuthProviderArgs.builder()
                    .authType("API_KEY")
                    .build())
                .connectionAuthModes(ApiEventConfigConnectionAuthModeArgs.builder()
                    .authType("API_KEY")
                    .build())
                .defaultPublishAuthModes(ApiEventConfigDefaultPublishAuthModeArgs.builder()
                    .authType("API_KEY")
                    .build())
                .defaultSubscribeAuthModes(ApiEventConfigDefaultSubscribeAuthModeArgs.builder()
                    .authType("API_KEY")
                    .build())
                .build())
            .name("example-event-api")
            .build());

    }
}

resources:
  example:
    type: aws:appsync:Api
    properties:
      eventConfig:
        authProviders:
          - authType: API_KEY
        connectionAuthModes:
          - authType: API_KEY
        defaultPublishAuthModes:
          - authType: API_KEY
        defaultSubscribeAuthModes:
          - authType: API_KEY
      name: example-event-api

With Cognito Authentication

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.cognito.UserPool("example", {name: "example-user-pool"});
const current = aws.getRegion({});
const exampleApi = new aws.appsync.Api("example", {
    eventConfig: {
        authProviders: [{
            cognitoConfig: {
                userPoolId: example.id,
                awsRegion: current.then(current => current.region),
            },
            authType: "AMAZON_COGNITO_USER_POOLS",
        }],
        connectionAuthModes: [{
            authType: "AMAZON_COGNITO_USER_POOLS",
        }],
        defaultPublishAuthModes: [{
            authType: "AMAZON_COGNITO_USER_POOLS",
        }],
        defaultSubscribeAuthModes: [{
            authType: "AMAZON_COGNITO_USER_POOLS",
        }],
    },
    name: "example-event-api",
});

import pulumi
import pulumi_aws as aws

example = aws.cognito.UserPool("example", name="example-user-pool")
current = aws.get_region()
example_api = aws.appsync.Api("example",
    event_config={
        "auth_providers": [{
            "cognito_config": {
                "user_pool_id": example.id,
                "aws_region": current.region,
            },
            "auth_type": "AMAZON_COGNITO_USER_POOLS",
        }],
        "connection_auth_modes": [{
            "auth_type": "AMAZON_COGNITO_USER_POOLS",
        }],
        "default_publish_auth_modes": [{
            "auth_type": "AMAZON_COGNITO_USER_POOLS",
        }],
        "default_subscribe_auth_modes": [{
            "auth_type": "AMAZON_COGNITO_USER_POOLS",
        }],
    },
    name="example-event-api")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Cognito.UserPool("example", new()
    {
        Name = "example-user-pool",
    });

    var current = Aws.GetRegion.Invoke();

    var exampleApi = new Aws.AppSync.Api("example", new()
    {
        EventConfig = new Aws.AppSync.Inputs.ApiEventConfigArgs
        {
            AuthProviders = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigAuthProviderArgs
                {
                    CognitoConfig = new Aws.AppSync.Inputs.ApiEventConfigAuthProviderCognitoConfigArgs
                    {
                        UserPoolId = example.Id,
                        AwsRegion = current.Apply(getRegionResult => getRegionResult.Region),
                    },
                    AuthType = "AMAZON_COGNITO_USER_POOLS",
                },
            },
            ConnectionAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigConnectionAuthModeArgs
                {
                    AuthType = "AMAZON_COGNITO_USER_POOLS",
                },
            },
            DefaultPublishAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigDefaultPublishAuthModeArgs
                {
                    AuthType = "AMAZON_COGNITO_USER_POOLS",
                },
            },
            DefaultSubscribeAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigDefaultSubscribeAuthModeArgs
                {
                    AuthType = "AMAZON_COGNITO_USER_POOLS",
                },
            },
        },
        Name = "example-event-api",
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/appsync"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cognito"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := cognito.NewUserPool(ctx, "example", &cognito.UserPoolArgs{
			Name: pulumi.String("example-user-pool"),
		})
		if err != nil {
			return err
		}
		current, err := aws.GetRegion(ctx, &aws.GetRegionArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = appsync.NewApi(ctx, "example", &appsync.ApiArgs{
			EventConfig: &appsync.ApiEventConfigArgs{
				AuthProviders: appsync.ApiEventConfigAuthProviderArray{
					&appsync.ApiEventConfigAuthProviderArgs{
						CognitoConfig: &appsync.ApiEventConfigAuthProviderCognitoConfigArgs{
							UserPoolId: example.ID().ToIDOutput().ToStringOutput(),
							AwsRegion:  pulumi.String(current.Region),
						},
						AuthType: pulumi.String("AMAZON_COGNITO_USER_POOLS"),
					},
				},
				ConnectionAuthModes: appsync.ApiEventConfigConnectionAuthModeArray{
					&appsync.ApiEventConfigConnectionAuthModeArgs{
						AuthType: pulumi.String("AMAZON_COGNITO_USER_POOLS"),
					},
				},
				DefaultPublishAuthModes: appsync.ApiEventConfigDefaultPublishAuthModeArray{
					&appsync.ApiEventConfigDefaultPublishAuthModeArgs{
						AuthType: pulumi.String("AMAZON_COGNITO_USER_POOLS"),
					},
				},
				DefaultSubscribeAuthModes: appsync.ApiEventConfigDefaultSubscribeAuthModeArray{
					&appsync.ApiEventConfigDefaultSubscribeAuthModeArgs{
						AuthType: pulumi.String("AMAZON_COGNITO_USER_POOLS"),
					},
				},
			},
			Name: pulumi.String("example-event-api"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_getregion" "current" {
}

resource "aws_cognito_userpool" "example" {
  name = "example-user-pool"
}
resource "aws_appsync_api" "example" {
  event_config = {
    auth_providers = [{
      "cognitoConfig" = {
        "userPoolId" = aws_cognito_userpool.example.id
        "awsRegion"  = data.aws_getregion.current.region
      }
      "authType" = "AMAZON_COGNITO_USER_POOLS"
    }]
    connection_auth_modes = [{
      "authType" = "AMAZON_COGNITO_USER_POOLS"
    }]
    default_publish_auth_modes = [{
      "authType" = "AMAZON_COGNITO_USER_POOLS"
    }]
    default_subscribe_auth_modes = [{
      "authType" = "AMAZON_COGNITO_USER_POOLS"
    }]
  }
  name = "example-event-api"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cognito.UserPool;
import com.pulumi.aws.cognito.UserPoolArgs;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetRegionArgs;
import com.pulumi.aws.appsync.Api;
import com.pulumi.aws.appsync.ApiArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigAuthProviderArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigAuthProviderCognitoConfigArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigConnectionAuthModeArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigDefaultPublishAuthModeArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigDefaultSubscribeAuthModeArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new UserPool("example", UserPoolArgs.builder()
            .name("example-user-pool")
            .build());

        final var current = AwsFunctions.getRegion(GetRegionArgs.builder()
            .build());

        var exampleApi = new Api("exampleApi", ApiArgs.builder()
            .eventConfig(ApiEventConfigArgs.builder()
                .authProviders(ApiEventConfigAuthProviderArgs.builder()
                    .cognitoConfig(ApiEventConfigAuthProviderCognitoConfigArgs.builder()
                        .userPoolId(example.id())
                        .awsRegion(current.region())
                        .build())
                    .authType("AMAZON_COGNITO_USER_POOLS")
                    .build())
                .connectionAuthModes(ApiEventConfigConnectionAuthModeArgs.builder()
                    .authType("AMAZON_COGNITO_USER_POOLS")
                    .build())
                .defaultPublishAuthModes(ApiEventConfigDefaultPublishAuthModeArgs.builder()
                    .authType("AMAZON_COGNITO_USER_POOLS")
                    .build())
                .defaultSubscribeAuthModes(ApiEventConfigDefaultSubscribeAuthModeArgs.builder()
                    .authType("AMAZON_COGNITO_USER_POOLS")
                    .build())
                .build())
            .name("example-event-api")
            .build());

    }
}

resources:
  example:
    type: aws:cognito:UserPool
    properties:
      name: example-user-pool
  exampleApi:
    type: aws:appsync:Api
    name: example
    properties:
      eventConfig:
        authProviders:
          - cognitoConfig:
              userPoolId: ${example.id}
              awsRegion: ${current.region}
            authType: AMAZON_COGNITO_USER_POOLS
        connectionAuthModes:
          - authType: AMAZON_COGNITO_USER_POOLS
        defaultPublishAuthModes:
          - authType: AMAZON_COGNITO_USER_POOLS
        defaultSubscribeAuthModes:
          - authType: AMAZON_COGNITO_USER_POOLS
      name: example-event-api
variables:
  current:
    fn::invoke:
      function: aws:getRegion
      arguments: {}

With Lambda Authorizer

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.appsync.Api("example", {
    eventConfig: {
        authProviders: [{
            lambdaAuthorizerConfig: {
                authorizerUri: exampleAwsLambdaFunction.arn,
                authorizerResultTtlInSeconds: 300,
            },
            authType: "AWS_LAMBDA",
        }],
        connectionAuthModes: [{
            authType: "AWS_LAMBDA",
        }],
        defaultPublishAuthModes: [{
            authType: "AWS_LAMBDA",
        }],
        defaultSubscribeAuthModes: [{
            authType: "AWS_LAMBDA",
        }],
    },
    name: "example-event-api",
});

import pulumi
import pulumi_aws as aws

example = aws.appsync.Api("example",
    event_config={
        "auth_providers": [{
            "lambda_authorizer_config": {
                "authorizer_uri": example_aws_lambda_function["arn"],
                "authorizer_result_ttl_in_seconds": 300,
            },
            "auth_type": "AWS_LAMBDA",
        }],
        "connection_auth_modes": [{
            "auth_type": "AWS_LAMBDA",
        }],
        "default_publish_auth_modes": [{
            "auth_type": "AWS_LAMBDA",
        }],
        "default_subscribe_auth_modes": [{
            "auth_type": "AWS_LAMBDA",
        }],
    },
    name="example-event-api")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.AppSync.Api("example", new()
    {
        EventConfig = new Aws.AppSync.Inputs.ApiEventConfigArgs
        {
            AuthProviders = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigAuthProviderArgs
                {
                    LambdaAuthorizerConfig = new Aws.AppSync.Inputs.ApiEventConfigAuthProviderLambdaAuthorizerConfigArgs
                    {
                        AuthorizerUri = exampleAwsLambdaFunction.Arn,
                        AuthorizerResultTtlInSeconds = 300,
                    },
                    AuthType = "AWS_LAMBDA",
                },
            },
            ConnectionAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigConnectionAuthModeArgs
                {
                    AuthType = "AWS_LAMBDA",
                },
            },
            DefaultPublishAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigDefaultPublishAuthModeArgs
                {
                    AuthType = "AWS_LAMBDA",
                },
            },
            DefaultSubscribeAuthModes = new[]
            {
                new Aws.AppSync.Inputs.ApiEventConfigDefaultSubscribeAuthModeArgs
                {
                    AuthType = "AWS_LAMBDA",
                },
            },
        },
        Name = "example-event-api",
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/appsync"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := appsync.NewApi(ctx, "example", &appsync.ApiArgs{
			EventConfig: &appsync.ApiEventConfigArgs{
				AuthProviders: appsync.ApiEventConfigAuthProviderArray{
					&appsync.ApiEventConfigAuthProviderArgs{
						LambdaAuthorizerConfig: &appsync.ApiEventConfigAuthProviderLambdaAuthorizerConfigArgs{
							AuthorizerUri:                pulumi.Any(exampleAwsLambdaFunction.Arn),
							AuthorizerResultTtlInSeconds: pulumi.Int(300),
						},
						AuthType: pulumi.String("AWS_LAMBDA"),
					},
				},
				ConnectionAuthModes: appsync.ApiEventConfigConnectionAuthModeArray{
					&appsync.ApiEventConfigConnectionAuthModeArgs{
						AuthType: pulumi.String("AWS_LAMBDA"),
					},
				},
				DefaultPublishAuthModes: appsync.ApiEventConfigDefaultPublishAuthModeArray{
					&appsync.ApiEventConfigDefaultPublishAuthModeArgs{
						AuthType: pulumi.String("AWS_LAMBDA"),
					},
				},
				DefaultSubscribeAuthModes: appsync.ApiEventConfigDefaultSubscribeAuthModeArray{
					&appsync.ApiEventConfigDefaultSubscribeAuthModeArgs{
						AuthType: pulumi.String("AWS_LAMBDA"),
					},
				},
			},
			Name: pulumi.String("example-event-api"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_appsync_api" "example" {
  event_config = {
    auth_providers = [{
      "lambdaAuthorizerConfig" = {
        "authorizerUri"                = exampleAwsLambdaFunction.arn
        "authorizerResultTtlInSeconds" = 300
      }
      "authType" = "AWS_LAMBDA"
    }]
    connection_auth_modes = [{
      "authType" = "AWS_LAMBDA"
    }]
    default_publish_auth_modes = [{
      "authType" = "AWS_LAMBDA"
    }]
    default_subscribe_auth_modes = [{
      "authType" = "AWS_LAMBDA"
    }]
  }
  name = "example-event-api"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appsync.Api;
import com.pulumi.aws.appsync.ApiArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigAuthProviderArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigAuthProviderLambdaAuthorizerConfigArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigConnectionAuthModeArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigDefaultPublishAuthModeArgs;
import com.pulumi.aws.appsync.inputs.ApiEventConfigDefaultSubscribeAuthModeArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Api("example", ApiArgs.builder()
            .eventConfig(ApiEventConfigArgs.builder()
                .authProviders(ApiEventConfigAuthProviderArgs.builder()
                    .lambdaAuthorizerConfig(ApiEventConfigAuthProviderLambdaAuthorizerConfigArgs.builder()
                        .authorizerUri(exampleAwsLambdaFunction.arn())
                        .authorizerResultTtlInSeconds(300)
                        .build())
                    .authType("AWS_LAMBDA")
                    .build())
                .connectionAuthModes(ApiEventConfigConnectionAuthModeArgs.builder()
                    .authType("AWS_LAMBDA")
                    .build())
                .defaultPublishAuthModes(ApiEventConfigDefaultPublishAuthModeArgs.builder()
                    .authType("AWS_LAMBDA")
                    .build())
                .defaultSubscribeAuthModes(ApiEventConfigDefaultSubscribeAuthModeArgs.builder()
                    .authType("AWS_LAMBDA")
                    .build())
                .build())
            .name("example-event-api")
            .build());

    }
}

resources:
  example:
    type: aws:appsync:Api
    properties:
      eventConfig:
        authProviders:
          - lambdaAuthorizerConfig:
              authorizerUri: ${exampleAwsLambdaFunction.arn}
              authorizerResultTtlInSeconds: 300
            authType: AWS_LAMBDA
        connectionAuthModes:
          - authType: AWS_LAMBDA
        defaultPublishAuthModes:
          - authType: AWS_LAMBDA
        defaultSubscribeAuthModes:
          - authType: AWS_LAMBDA
      name: example-event-api

Import

Using pulumi import, import AppSync Event API using the apiId. For example:

$ pulumi import aws:appsync/api:Api example example-api-id

Constructors

Api(String name, {ApiArgs? args, CustomResourceOptions? options})
Creates a new Api. name The Pulumi resource name. args Arguments used to configure this Api. The set of arguments for Api. options Resource options controlling this resource's behavior.
Api.reference(String urn)
Creates a typed reference to an existing Api resource.

Properties

apiArn ↔ Output<String>
ARN of the Event API.
latefinal
apiId ↔ Output<String>
ID of the Event API.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
dns ↔ Output<Map<String, String>>
DNS configuration for the Event API.
latefinal
eventConfig ↔ Output<ApiEventConfig>
Configuration for the Event API. See eventConfig Block below.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<String>
Name of the Event API.
latefinal
ownerContact ↔ Output<String?>
Contact information for the owner of the Event API.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
wafWebAclArn ↔ Output<String>
ARN of the associated WAF web ACL.
latefinal
xrayEnabled ↔ Output<bool>
Whether X-Ray tracing is enabled for the Event API.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ApiState? state, CustomResourceOptions? options}) → Api
Gets an existing Api resource's state with the given name and id.