github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/apigateway/methodResponse.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package apigateway

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Provides an HTTP Method Response for an API Gateway Resource. More information about API Gateway method responses can be found in the [Amazon API Gateway Developer Guide](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-settings-method-response.html).
//
// ## Example Usage
//
// ### Basic Response
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigateway"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			myDemoAPI, err := apigateway.NewRestApi(ctx, "MyDemoAPI", &apigateway.RestApiArgs{
//				Name:        pulumi.String("MyDemoAPI"),
//				Description: pulumi.String("This is my API for demonstration purposes"),
//			})
//			if err != nil {
//				return err
//			}
//			myDemoResource, err := apigateway.NewResource(ctx, "MyDemoResource", &apigateway.ResourceArgs{
//				RestApi:  myDemoAPI.ID(),
//				ParentId: myDemoAPI.RootResourceId,
//				PathPart: pulumi.String("mydemoresource"),
//			})
//			if err != nil {
//				return err
//			}
//			myDemoMethod, err := apigateway.NewMethod(ctx, "MyDemoMethod", &apigateway.MethodArgs{
//				RestApi:       myDemoAPI.ID(),
//				ResourceId:    myDemoResource.ID(),
//				HttpMethod:    pulumi.String("GET"),
//				Authorization: pulumi.String("NONE"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = apigateway.NewIntegration(ctx, "MyDemoIntegration", &apigateway.IntegrationArgs{
//				RestApi:    myDemoAPI.ID(),
//				ResourceId: myDemoResource.ID(),
//				HttpMethod: myDemoMethod.HttpMethod,
//				Type:       pulumi.String("MOCK"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = apigateway.NewMethodResponse(ctx, "response_200", &apigateway.MethodResponseArgs{
//				RestApi:    myDemoAPI.ID(),
//				ResourceId: myDemoResource.ID(),
//				HttpMethod: myDemoMethod.HttpMethod,
//				StatusCode: pulumi.String("200"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### Response with Custom Header and Model
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"encoding/json"
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/apigateway"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			myDemoAPI, err := apigateway.NewRestApi(ctx, "MyDemoAPI", &apigateway.RestApiArgs{
//				Name:        pulumi.String("MyDemoAPI"),
//				Description: pulumi.String("This is my API for demonstration purposes"),
//			})
//			if err != nil {
//				return err
//			}
//			myDemoResource, err := apigateway.NewResource(ctx, "MyDemoResource", &apigateway.ResourceArgs{
//				RestApi:  myDemoAPI.ID(),
//				ParentId: myDemoAPI.RootResourceId,
//				PathPart: pulumi.String("mydemoresource"),
//			})
//			if err != nil {
//				return err
//			}
//			myDemoMethod, err := apigateway.NewMethod(ctx, "MyDemoMethod", &apigateway.MethodArgs{
//				RestApi:       myDemoAPI.ID(),
//				ResourceId:    myDemoResource.ID(),
//				HttpMethod:    pulumi.String("GET"),
//				Authorization: pulumi.String("NONE"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = apigateway.NewIntegration(ctx, "MyDemoIntegration", &apigateway.IntegrationArgs{
//				RestApi:    myDemoAPI.ID(),
//				ResourceId: myDemoResource.ID(),
//				HttpMethod: myDemoMethod.HttpMethod,
//				Type:       pulumi.String("MOCK"),
//			})
//			if err != nil {
//				return err
//			}
//			tmpJSON0, err := json.Marshal(map[string]interface{}{
//				"$schema": "http://json-schema.org/draft-04/schema#",
//				"title":   "MyDemoResponse",
//				"type":    "object",
//				"properties": map[string]interface{}{
//					"Message": map[string]interface{}{
//						"type": "string",
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			json0 := string(tmpJSON0)
//			_, err = apigateway.NewModel(ctx, "MyDemoResponseModel", &apigateway.ModelArgs{
//				RestApi:     myDemoAPI.ID(),
//				Name:        pulumi.String("MyDemoResponseModel"),
//				Description: pulumi.String("API response for MyDemoMethod"),
//				ContentType: pulumi.String("application/json"),
//				Schema:      pulumi.String(json0),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = apigateway.NewMethodResponse(ctx, "response_200", &apigateway.MethodResponseArgs{
//				RestApi:    myDemoAPI.ID(),
//				ResourceId: myDemoResource.ID(),
//				HttpMethod: myDemoMethod.HttpMethod,
//				StatusCode: pulumi.String("200"),
//				ResponseModels: pulumi.StringMap{
//					"application/json": pulumi.String("MyDemoResponseModel"),
//				},
//				ResponseParameters: pulumi.BoolMap{
//					"method.response.header.Content-Type":     pulumi.Bool(false),
//					"method-response-header.X-My-Demo-Header": pulumi.Bool(false),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import `aws_api_gateway_method_response` using `REST-API-ID/RESOURCE-ID/HTTP-METHOD/STATUS-CODE`. For example:
//
// ```sh
// $ pulumi import aws:apigateway/methodResponse:MethodResponse example 12345abcde/67890fghij/GET/200
// ```
type MethodResponse struct {
	pulumi.CustomResourceState

	// The HTTP verb of the method resource (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`, `OPTIONS`, `ANY`).
	HttpMethod pulumi.StringOutput `pulumi:"httpMethod"`
	// The Resource identifier for the method resource.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
	// A map specifying the model resources used for the response's content type. Response models are represented as a key/value map, with a content type as the key and a Model name as the value.
	ResponseModels pulumi.StringMapOutput `pulumi:"responseModels"`
	// A map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header name and the associated value is a boolean flag indicating whether the method response parameter is required. The method response header names must match the pattern of `method.response.header.{name}`, where `name` is a valid and unique header name.
	//
	// The response parameter names defined here are available in the integration response to be mapped from an integration response header expressed in `integration.response.header.{name}`, a static value enclosed within a pair of single quotes (e.g., '`application/json'`), or a JSON expression from the back-end response payload in the form of `integration.response.body.{JSON-expression}`, where `JSON-expression` is a valid JSON expression without the `$` prefix.)
	ResponseParameters pulumi.BoolMapOutput `pulumi:"responseParameters"`
	// The string identifier of the associated REST API.
	RestApi pulumi.StringOutput `pulumi:"restApi"`
	// The method response's status code.
	StatusCode pulumi.StringOutput `pulumi:"statusCode"`
}

// NewMethodResponse registers a new resource with the given unique name, arguments, and options.
func NewMethodResponse(ctx *pulumi.Context,
	name string, args *MethodResponseArgs, opts ...pulumi.ResourceOption) (*MethodResponse, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.HttpMethod == nil {
		return nil, errors.New("invalid value for required argument 'HttpMethod'")
	}
	if args.ResourceId == nil {
		return nil, errors.New("invalid value for required argument 'ResourceId'")
	}
	if args.RestApi == nil {
		return nil, errors.New("invalid value for required argument 'RestApi'")
	}
	if args.StatusCode == nil {
		return nil, errors.New("invalid value for required argument 'StatusCode'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource MethodResponse
	err := ctx.RegisterResource("aws:apigateway/methodResponse:MethodResponse", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetMethodResponse gets an existing MethodResponse resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetMethodResponse(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *MethodResponseState, opts ...pulumi.ResourceOption) (*MethodResponse, error) {
	var resource MethodResponse
	err := ctx.ReadResource("aws:apigateway/methodResponse:MethodResponse", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering MethodResponse resources.
type methodResponseState struct {
	// The HTTP verb of the method resource (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`, `OPTIONS`, `ANY`).
	HttpMethod *string `pulumi:"httpMethod"`
	// The Resource identifier for the method resource.
	ResourceId *string `pulumi:"resourceId"`
	// A map specifying the model resources used for the response's content type. Response models are represented as a key/value map, with a content type as the key and a Model name as the value.
	ResponseModels map[string]string `pulumi:"responseModels"`
	// A map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header name and the associated value is a boolean flag indicating whether the method response parameter is required. The method response header names must match the pattern of `method.response.header.{name}`, where `name` is a valid and unique header name.
	//
	// The response parameter names defined here are available in the integration response to be mapped from an integration response header expressed in `integration.response.header.{name}`, a static value enclosed within a pair of single quotes (e.g., '`application/json'`), or a JSON expression from the back-end response payload in the form of `integration.response.body.{JSON-expression}`, where `JSON-expression` is a valid JSON expression without the `$` prefix.)
	ResponseParameters map[string]bool `pulumi:"responseParameters"`
	// The string identifier of the associated REST API.
	RestApi interface{} `pulumi:"restApi"`
	// The method response's status code.
	StatusCode *string `pulumi:"statusCode"`
}

type MethodResponseState struct {
	// The HTTP verb of the method resource (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`, `OPTIONS`, `ANY`).
	HttpMethod pulumi.StringPtrInput
	// The Resource identifier for the method resource.
	ResourceId pulumi.StringPtrInput
	// A map specifying the model resources used for the response's content type. Response models are represented as a key/value map, with a content type as the key and a Model name as the value.
	ResponseModels pulumi.StringMapInput
	// A map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header name and the associated value is a boolean flag indicating whether the method response parameter is required. The method response header names must match the pattern of `method.response.header.{name}`, where `name` is a valid and unique header name.
	//
	// The response parameter names defined here are available in the integration response to be mapped from an integration response header expressed in `integration.response.header.{name}`, a static value enclosed within a pair of single quotes (e.g., '`application/json'`), or a JSON expression from the back-end response payload in the form of `integration.response.body.{JSON-expression}`, where `JSON-expression` is a valid JSON expression without the `$` prefix.)
	ResponseParameters pulumi.BoolMapInput
	// The string identifier of the associated REST API.
	RestApi pulumi.Input
	// The method response's status code.
	StatusCode pulumi.StringPtrInput
}

func (MethodResponseState) ElementType() reflect.Type {
	return reflect.TypeOf((*methodResponseState)(nil)).Elem()
}

type methodResponseArgs struct {
	// The HTTP verb of the method resource (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`, `OPTIONS`, `ANY`).
	HttpMethod string `pulumi:"httpMethod"`
	// The Resource identifier for the method resource.
	ResourceId string `pulumi:"resourceId"`
	// A map specifying the model resources used for the response's content type. Response models are represented as a key/value map, with a content type as the key and a Model name as the value.
	ResponseModels map[string]string `pulumi:"responseModels"`
	// A map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header name and the associated value is a boolean flag indicating whether the method response parameter is required. The method response header names must match the pattern of `method.response.header.{name}`, where `name` is a valid and unique header name.
	//
	// The response parameter names defined here are available in the integration response to be mapped from an integration response header expressed in `integration.response.header.{name}`, a static value enclosed within a pair of single quotes (e.g., '`application/json'`), or a JSON expression from the back-end response payload in the form of `integration.response.body.{JSON-expression}`, where `JSON-expression` is a valid JSON expression without the `$` prefix.)
	ResponseParameters map[string]bool `pulumi:"responseParameters"`
	// The string identifier of the associated REST API.
	RestApi interface{} `pulumi:"restApi"`
	// The method response's status code.
	StatusCode string `pulumi:"statusCode"`
}

// The set of arguments for constructing a MethodResponse resource.
type MethodResponseArgs struct {
	// The HTTP verb of the method resource (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`, `OPTIONS`, `ANY`).
	HttpMethod pulumi.StringInput
	// The Resource identifier for the method resource.
	ResourceId pulumi.StringInput
	// A map specifying the model resources used for the response's content type. Response models are represented as a key/value map, with a content type as the key and a Model name as the value.
	ResponseModels pulumi.StringMapInput
	// A map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header name and the associated value is a boolean flag indicating whether the method response parameter is required. The method response header names must match the pattern of `method.response.header.{name}`, where `name` is a valid and unique header name.
	//
	// The response parameter names defined here are available in the integration response to be mapped from an integration response header expressed in `integration.response.header.{name}`, a static value enclosed within a pair of single quotes (e.g., '`application/json'`), or a JSON expression from the back-end response payload in the form of `integration.response.body.{JSON-expression}`, where `JSON-expression` is a valid JSON expression without the `$` prefix.)
	ResponseParameters pulumi.BoolMapInput
	// The string identifier of the associated REST API.
	RestApi pulumi.Input
	// The method response's status code.
	StatusCode pulumi.StringInput
}

func (MethodResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*methodResponseArgs)(nil)).Elem()
}

type MethodResponseInput interface {
	pulumi.Input

	ToMethodResponseOutput() MethodResponseOutput
	ToMethodResponseOutputWithContext(ctx context.Context) MethodResponseOutput
}

func (*MethodResponse) ElementType() reflect.Type {
	return reflect.TypeOf((**MethodResponse)(nil)).Elem()
}

func (i *MethodResponse) ToMethodResponseOutput() MethodResponseOutput {
	return i.ToMethodResponseOutputWithContext(context.Background())
}

func (i *MethodResponse) ToMethodResponseOutputWithContext(ctx context.Context) MethodResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MethodResponseOutput)
}

// MethodResponseArrayInput is an input type that accepts MethodResponseArray and MethodResponseArrayOutput values.
// You can construct a concrete instance of `MethodResponseArrayInput` via:
//
//	MethodResponseArray{ MethodResponseArgs{...} }
type MethodResponseArrayInput interface {
	pulumi.Input

	ToMethodResponseArrayOutput() MethodResponseArrayOutput
	ToMethodResponseArrayOutputWithContext(context.Context) MethodResponseArrayOutput
}

type MethodResponseArray []MethodResponseInput

func (MethodResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*MethodResponse)(nil)).Elem()
}

func (i MethodResponseArray) ToMethodResponseArrayOutput() MethodResponseArrayOutput {
	return i.ToMethodResponseArrayOutputWithContext(context.Background())
}

func (i MethodResponseArray) ToMethodResponseArrayOutputWithContext(ctx context.Context) MethodResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MethodResponseArrayOutput)
}

// MethodResponseMapInput is an input type that accepts MethodResponseMap and MethodResponseMapOutput values.
// You can construct a concrete instance of `MethodResponseMapInput` via:
//
//	MethodResponseMap{ "key": MethodResponseArgs{...} }
type MethodResponseMapInput interface {
	pulumi.Input

	ToMethodResponseMapOutput() MethodResponseMapOutput
	ToMethodResponseMapOutputWithContext(context.Context) MethodResponseMapOutput
}

type MethodResponseMap map[string]MethodResponseInput

func (MethodResponseMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*MethodResponse)(nil)).Elem()
}

func (i MethodResponseMap) ToMethodResponseMapOutput() MethodResponseMapOutput {
	return i.ToMethodResponseMapOutputWithContext(context.Background())
}

func (i MethodResponseMap) ToMethodResponseMapOutputWithContext(ctx context.Context) MethodResponseMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MethodResponseMapOutput)
}

type MethodResponseOutput struct{ *pulumi.OutputState }

func (MethodResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**MethodResponse)(nil)).Elem()
}

func (o MethodResponseOutput) ToMethodResponseOutput() MethodResponseOutput {
	return o
}

func (o MethodResponseOutput) ToMethodResponseOutputWithContext(ctx context.Context) MethodResponseOutput {
	return o
}

// The HTTP verb of the method resource (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`, `OPTIONS`, `ANY`).
func (o MethodResponseOutput) HttpMethod() pulumi.StringOutput {
	return o.ApplyT(func(v *MethodResponse) pulumi.StringOutput { return v.HttpMethod }).(pulumi.StringOutput)
}

// The Resource identifier for the method resource.
func (o MethodResponseOutput) ResourceId() pulumi.StringOutput {
	return o.ApplyT(func(v *MethodResponse) pulumi.StringOutput { return v.ResourceId }).(pulumi.StringOutput)
}

// A map specifying the model resources used for the response's content type. Response models are represented as a key/value map, with a content type as the key and a Model name as the value.
func (o MethodResponseOutput) ResponseModels() pulumi.StringMapOutput {
	return o.ApplyT(func(v *MethodResponse) pulumi.StringMapOutput { return v.ResponseModels }).(pulumi.StringMapOutput)
}

// A map specifying required or optional response parameters that API Gateway can send back to the caller. A key defines a method response header name and the associated value is a boolean flag indicating whether the method response parameter is required. The method response header names must match the pattern of `method.response.header.{name}`, where `name` is a valid and unique header name.
//
// The response parameter names defined here are available in the integration response to be mapped from an integration response header expressed in `integration.response.header.{name}`, a static value enclosed within a pair of single quotes (e.g., '`application/json'`), or a JSON expression from the back-end response payload in the form of `integration.response.body.{JSON-expression}`, where `JSON-expression` is a valid JSON expression without the `$` prefix.)
func (o MethodResponseOutput) ResponseParameters() pulumi.BoolMapOutput {
	return o.ApplyT(func(v *MethodResponse) pulumi.BoolMapOutput { return v.ResponseParameters }).(pulumi.BoolMapOutput)
}

// The string identifier of the associated REST API.
func (o MethodResponseOutput) RestApi() pulumi.StringOutput {
	return o.ApplyT(func(v *MethodResponse) pulumi.StringOutput { return v.RestApi }).(pulumi.StringOutput)
}

// The method response's status code.
func (o MethodResponseOutput) StatusCode() pulumi.StringOutput {
	return o.ApplyT(func(v *MethodResponse) pulumi.StringOutput { return v.StatusCode }).(pulumi.StringOutput)
}

type MethodResponseArrayOutput struct{ *pulumi.OutputState }

func (MethodResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*MethodResponse)(nil)).Elem()
}

func (o MethodResponseArrayOutput) ToMethodResponseArrayOutput() MethodResponseArrayOutput {
	return o
}

func (o MethodResponseArrayOutput) ToMethodResponseArrayOutputWithContext(ctx context.Context) MethodResponseArrayOutput {
	return o
}

func (o MethodResponseArrayOutput) Index(i pulumi.IntInput) MethodResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MethodResponse {
		return vs[0].([]*MethodResponse)[vs[1].(int)]
	}).(MethodResponseOutput)
}

type MethodResponseMapOutput struct{ *pulumi.OutputState }

func (MethodResponseMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*MethodResponse)(nil)).Elem()
}

func (o MethodResponseMapOutput) ToMethodResponseMapOutput() MethodResponseMapOutput {
	return o
}

func (o MethodResponseMapOutput) ToMethodResponseMapOutputWithContext(ctx context.Context) MethodResponseMapOutput {
	return o
}

func (o MethodResponseMapOutput) MapIndex(k pulumi.StringInput) MethodResponseOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MethodResponse {
		return vs[0].(map[string]*MethodResponse)[vs[1].(string)]
	}).(MethodResponseOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*MethodResponseInput)(nil)).Elem(), &MethodResponse{})
	pulumi.RegisterInputType(reflect.TypeOf((*MethodResponseArrayInput)(nil)).Elem(), MethodResponseArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*MethodResponseMapInput)(nil)).Elem(), MethodResponseMap{})
	pulumi.RegisterOutputType(MethodResponseOutput{})
	pulumi.RegisterOutputType(MethodResponseArrayOutput{})
	pulumi.RegisterOutputType(MethodResponseMapOutput{})
}