pulumi-aws-apigateway 2.7.0a1741843485__py3-none-any.whl → 3.1.0a1762981340__py3-none-any.whl

pulumi_aws_apigateway/_inputs.py

@@ -2,7 +2,7 @@
 # *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -36,21 +36,21 @@ if not MYPY:
         """
         LambdaAuthorizer provides the definition for a custom Authorizer for API Gateway.
         """
-        parameter_name: str
+        parameter_name: _builtins.str
         """
         parameterName is the name of the header or query parameter containing the authorization
         token. Must be "Unused" for multiple identity sources.
         """
-        auth_type: NotRequired[str]
+        auth_type: NotRequired[_builtins.str]
         """
         Specifies the authorization mechanism for the client. Typical values are "oauth2" or "custom".
         """
-        authorizer_name: NotRequired[str]
+        authorizer_name: NotRequired[_builtins.str]
         """
         The name for the Authorizer to be referenced as. This must be unique for each unique
         authorizer within the API. If no name if specified, a name will be generated for you.
         """
-        authorizer_result_ttl_in_seconds: NotRequired[float]
+        authorizer_result_ttl_in_seconds: NotRequired[_builtins.float]
         """
         The number of seconds during which the resulting IAM policy is cached. Default is 300s. You
         can set this value to 0 to disable caching. Max value is 3600s. Note - if you are sharing an
@@ -61,20 +61,20 @@ if not MYPY:
         """
         The authorizerHandler specifies information about the authorizing Lambda.
         """
-        identity_source: NotRequired[Sequence[str]]
+        identity_source: NotRequired[Sequence[_builtins.str]]
         """
         List of mapping expressions of the request parameters as the identity source. This indicates
         where in the request identity information is expected. Applicable for the authorizer of the
         "request" type only. Example: ["method.request.header.HeaderAuth1",
         "method.request.querystring.QueryString1"]
         """
-        identity_validation_expression: NotRequired[str]
+        identity_validation_expression: NotRequired[_builtins.str]
         """
         A regular expression for validating the token as the incoming identity. It only invokes the
         authorizer's lambda if there is a match, else it will return a 401. This does not apply to
         REQUEST Lambda Authorizers. Example: "^x-[a-z]+".
         """
-        methods_to_authorize: NotRequired[Sequence[str]]
+        methods_to_authorize: NotRequired[Sequence[_builtins.str]]
         """
         For method authorization, you can define resource servers and custom scopes by specifying the
         "resource-server/scope". e.g. ["com.hamuta.movies/drama.view",
@@ -82,16 +82,16 @@ if not MYPY:
         scopes visit the AWS documentation -
         https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html
         """
-        parameter_location: NotRequired[str]
+        parameter_location: NotRequired[_builtins.str]
         """
         Defines where in the request API Gateway should look for identity information. The value must
         be "header" or "query". If there are multiple identity sources, the value must be "header".
         """
-        provider_arns: NotRequired[Sequence[pulumi.Input[str]]]
+        provider_arns: NotRequired[Sequence[pulumi.Input[_builtins.str]]]
         """
         The ARNs of the Cognito User Pools to use.
         """
-        type: NotRequired[str]
+        type: NotRequired[_builtins.str]
         """
         The type of the authorizer. This value must be one of the following:
         - "token", for an authorizer with the caller identity embedded in an authorization token
@@ -103,46 +103,46 @@ elif False:
 @pulumi.input_type
 class AuthorizerArgs:
     def __init__(__self__, *,
-                 parameter_name: str,
-                 auth_type: Optional[str] = None,
-                 authorizer_name: Optional[str] = None,
-                 authorizer_result_ttl_in_seconds: Optional[float] = None,
+                 parameter_name: _builtins.str,
+                 auth_type: Optional[_builtins.str] = None,
+                 authorizer_name: Optional[_builtins.str] = None,
+                 authorizer_result_ttl_in_seconds: Optional[_builtins.float] = None,
                  handler: Optional[pulumi.Input['pulumi_aws.lambda_.Function']] = None,
-                 identity_source: Optional[Sequence[str]] = None,
-                 identity_validation_expression: Optional[str] = None,
-                 methods_to_authorize: Optional[Sequence[str]] = None,
-                 parameter_location: Optional[str] = None,
-                 provider_arns: Optional[Sequence[pulumi.Input[str]]] = None,
-                 type: Optional[str] = None):
+                 identity_source: Optional[Sequence[_builtins.str]] = None,
+                 identity_validation_expression: Optional[_builtins.str] = None,
+                 methods_to_authorize: Optional[Sequence[_builtins.str]] = None,
+                 parameter_location: Optional[_builtins.str] = None,
+                 provider_arns: Optional[Sequence[pulumi.Input[_builtins.str]]] = None,
+                 type: Optional[_builtins.str] = None):
         """
         LambdaAuthorizer provides the definition for a custom Authorizer for API Gateway.
 
-        :param str parameter_name: parameterName is the name of the header or query parameter containing the authorization
+        :param _builtins.str parameter_name: parameterName is the name of the header or query parameter containing the authorization
                token. Must be "Unused" for multiple identity sources.
-        :param str auth_type: Specifies the authorization mechanism for the client. Typical values are "oauth2" or "custom".
-        :param str authorizer_name: The name for the Authorizer to be referenced as. This must be unique for each unique
+        :param _builtins.str auth_type: Specifies the authorization mechanism for the client. Typical values are "oauth2" or "custom".
+        :param _builtins.str authorizer_name: The name for the Authorizer to be referenced as. This must be unique for each unique
                authorizer within the API. If no name if specified, a name will be generated for you.
-        :param float authorizer_result_ttl_in_seconds: The number of seconds during which the resulting IAM policy is cached. Default is 300s. You
+        :param _builtins.float authorizer_result_ttl_in_seconds: The number of seconds during which the resulting IAM policy is cached. Default is 300s. You
                can set this value to 0 to disable caching. Max value is 3600s. Note - if you are sharing an
                authorizer across more than one route you will want to disable the cache or else it will
                cause problems for you.
         :param pulumi.Input['pulumi_aws.lambda_.Function'] handler: The authorizerHandler specifies information about the authorizing Lambda.
-        :param Sequence[str] identity_source: List of mapping expressions of the request parameters as the identity source. This indicates
+        :param Sequence[_builtins.str] identity_source: List of mapping expressions of the request parameters as the identity source. This indicates
                where in the request identity information is expected. Applicable for the authorizer of the
                "request" type only. Example: ["method.request.header.HeaderAuth1",
                "method.request.querystring.QueryString1"]
-        :param str identity_validation_expression: A regular expression for validating the token as the incoming identity. It only invokes the
+        :param _builtins.str identity_validation_expression: A regular expression for validating the token as the incoming identity. It only invokes the
                authorizer's lambda if there is a match, else it will return a 401. This does not apply to
                REQUEST Lambda Authorizers. Example: "^x-[a-z]+".
-        :param Sequence[str] methods_to_authorize: For method authorization, you can define resource servers and custom scopes by specifying the
+        :param Sequence[_builtins.str] methods_to_authorize: For method authorization, you can define resource servers and custom scopes by specifying the
                "resource-server/scope". e.g. ["com.hamuta.movies/drama.view",
                "http://my.resource.com/file.read"] For more information on resource servers and custom
                scopes visit the AWS documentation -
                https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html
-        :param str parameter_location: Defines where in the request API Gateway should look for identity information. The value must
+        :param _builtins.str parameter_location: Defines where in the request API Gateway should look for identity information. The value must
                be "header" or "query". If there are multiple identity sources, the value must be "header".
-        :param Sequence[pulumi.Input[str]] provider_arns: The ARNs of the Cognito User Pools to use.
-        :param str type: The type of the authorizer. This value must be one of the following:
+        :param Sequence[pulumi.Input[_builtins.str]] provider_arns: The ARNs of the Cognito User Pools to use.
+        :param _builtins.str type: The type of the authorizer. This value must be one of the following:
                - "token", for an authorizer with the caller identity embedded in an authorization token
                - "request", for an authorizer with the caller identity contained in request parameters
         """
@@ -168,9 +168,9 @@ class AuthorizerArgs:
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="parameterName")
-    def parameter_name(self) -> str:
+    def parameter_name(self) -> _builtins.str:
         """
         parameterName is the name of the header or query parameter containing the authorization
         token. Must be "Unused" for multiple identity sources.
@@ -178,24 +178,24 @@ class AuthorizerArgs:
         return pulumi.get(self, "parameter_name")
 
     @parameter_name.setter
-    def parameter_name(self, value: str):
+    def parameter_name(self, value: _builtins.str):
         pulumi.set(self, "parameter_name", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="authType")
-    def auth_type(self) -> Optional[str]:
+    def auth_type(self) -> Optional[_builtins.str]:
         """
         Specifies the authorization mechanism for the client. Typical values are "oauth2" or "custom".
         """
         return pulumi.get(self, "auth_type")
 
     @auth_type.setter
-    def auth_type(self, value: Optional[str]):
+    def auth_type(self, value: Optional[_builtins.str]):
         pulumi.set(self, "auth_type", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="authorizerName")
-    def authorizer_name(self) -> Optional[str]:
+    def authorizer_name(self) -> Optional[_builtins.str]:
         """
         The name for the Authorizer to be referenced as. This must be unique for each unique
         authorizer within the API. If no name if specified, a name will be generated for you.
@@ -203,12 +203,12 @@ class AuthorizerArgs:
         return pulumi.get(self, "authorizer_name")
 
     @authorizer_name.setter
-    def authorizer_name(self, value: Optional[str]):
+    def authorizer_name(self, value: Optional[_builtins.str]):
         pulumi.set(self, "authorizer_name", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="authorizerResultTtlInSeconds")
-    def authorizer_result_ttl_in_seconds(self) -> Optional[float]:
+    def authorizer_result_ttl_in_seconds(self) -> Optional[_builtins.float]:
         """
         The number of seconds during which the resulting IAM policy is cached. Default is 300s. You
         can set this value to 0 to disable caching. Max value is 3600s. Note - if you are sharing an
@@ -218,10 +218,10 @@ class AuthorizerArgs:
         return pulumi.get(self, "authorizer_result_ttl_in_seconds")
 
     @authorizer_result_ttl_in_seconds.setter
-    def authorizer_result_ttl_in_seconds(self, value: Optional[float]):
+    def authorizer_result_ttl_in_seconds(self, value: Optional[_builtins.float]):
         pulumi.set(self, "authorizer_result_ttl_in_seconds", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def handler(self) -> Optional[pulumi.Input['pulumi_aws.lambda_.Function']]:
         """
@@ -233,9 +233,9 @@ class AuthorizerArgs:
     def handler(self, value: Optional[pulumi.Input['pulumi_aws.lambda_.Function']]):
         pulumi.set(self, "handler", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="identitySource")
-    def identity_source(self) -> Optional[Sequence[str]]:
+    def identity_source(self) -> Optional[Sequence[_builtins.str]]:
         """
         List of mapping expressions of the request parameters as the identity source. This indicates
         where in the request identity information is expected. Applicable for the authorizer of the
@@ -245,12 +245,12 @@ class AuthorizerArgs:
         return pulumi.get(self, "identity_source")
 
     @identity_source.setter
-    def identity_source(self, value: Optional[Sequence[str]]):
+    def identity_source(self, value: Optional[Sequence[_builtins.str]]):
         pulumi.set(self, "identity_source", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="identityValidationExpression")
-    def identity_validation_expression(self) -> Optional[str]:
+    def identity_validation_expression(self) -> Optional[_builtins.str]:
         """
         A regular expression for validating the token as the incoming identity. It only invokes the
         authorizer's lambda if there is a match, else it will return a 401. This does not apply to
@@ -259,12 +259,12 @@ class AuthorizerArgs:
         return pulumi.get(self, "identity_validation_expression")
 
     @identity_validation_expression.setter
-    def identity_validation_expression(self, value: Optional[str]):
+    def identity_validation_expression(self, value: Optional[_builtins.str]):
         pulumi.set(self, "identity_validation_expression", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="methodsToAuthorize")
-    def methods_to_authorize(self) -> Optional[Sequence[str]]:
+    def methods_to_authorize(self) -> Optional[Sequence[_builtins.str]]:
         """
         For method authorization, you can define resource servers and custom scopes by specifying the
         "resource-server/scope". e.g. ["com.hamuta.movies/drama.view",
@@ -275,12 +275,12 @@ class AuthorizerArgs:
         return pulumi.get(self, "methods_to_authorize")
 
     @methods_to_authorize.setter
-    def methods_to_authorize(self, value: Optional[Sequence[str]]):
+    def methods_to_authorize(self, value: Optional[Sequence[_builtins.str]]):
         pulumi.set(self, "methods_to_authorize", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="parameterLocation")
-    def parameter_location(self) -> Optional[str]:
+    def parameter_location(self) -> Optional[_builtins.str]:
         """
         Defines where in the request API Gateway should look for identity information. The value must
         be "header" or "query". If there are multiple identity sources, the value must be "header".
@@ -288,24 +288,24 @@ class AuthorizerArgs:
         return pulumi.get(self, "parameter_location")
 
     @parameter_location.setter
-    def parameter_location(self, value: Optional[str]):
+    def parameter_location(self, value: Optional[_builtins.str]):
         pulumi.set(self, "parameter_location", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="providerARNs")
-    def provider_arns(self) -> Optional[Sequence[pulumi.Input[str]]]:
+    def provider_arns(self) -> Optional[Sequence[pulumi.Input[_builtins.str]]]:
         """
         The ARNs of the Cognito User Pools to use.
         """
         return pulumi.get(self, "provider_arns")
 
     @provider_arns.setter
-    def provider_arns(self, value: Optional[Sequence[pulumi.Input[str]]]):
+    def provider_arns(self, value: Optional[Sequence[pulumi.Input[_builtins.str]]]):
         pulumi.set(self, "provider_arns", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         The type of the authorizer. This value must be one of the following:
         - "token", for an authorizer with the caller identity embedded in an authorization token
@@ -314,43 +314,43 @@ class AuthorizerArgs:
         return pulumi.get(self, "type")
 
     @type.setter
-    def type(self, value: Optional[str]):
+    def type(self, value: Optional[_builtins.str]):
         pulumi.set(self, "type", value)
 
 
 if not MYPY:
     class RequiredParameterArgsDict(TypedDict):
-        in_: NotRequired[pulumi.Input[str]]
-        name: NotRequired[pulumi.Input[str]]
+        in_: NotRequired[pulumi.Input[_builtins.str]]
+        name: NotRequired[pulumi.Input[_builtins.str]]
 elif False:
     RequiredParameterArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class RequiredParameterArgs:
     def __init__(__self__, *,
-                 in_: Optional[pulumi.Input[str]] = None,
-                 name: Optional[pulumi.Input[str]] = None):
+                 in_: Optional[pulumi.Input[_builtins.str]] = None,
+                 name: Optional[pulumi.Input[_builtins.str]] = None):
         if in_ is not None:
             pulumi.set(__self__, "in_", in_)
         if name is not None:
             pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="in")
-    def in_(self) -> Optional[pulumi.Input[str]]:
+    def in_(self) -> Optional[pulumi.Input[_builtins.str]]:
         return pulumi.get(self, "in_")
 
     @in_.setter
-    def in_(self, value: Optional[pulumi.Input[str]]):
+    def in_(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "in_", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[pulumi.Input[str]]:
+    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
         return pulumi.get(self, "name")
 
     @name.setter
-    def name(self, value: Optional[pulumi.Input[str]]):
+    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "name", value)
 
 
@@ -361,12 +361,12 @@ if not MYPY:
         have an incoming path that they match against.  However, destinations are determined by the kind
         of the route.
         """
-        path: str
+        path: _builtins.str
         """
         The path on the API that will serve this route.  If not prefixed with `/`,
         then a `/` will be added automatically to the beginning.
         """
-        api_key_required: NotRequired[bool]
+        api_key_required: NotRequired[_builtins.bool]
         """
         If true, an API key will be required for this route. The source for the API Key can be set at
         the API level and by default, the source will be the HEADER.
@@ -376,7 +376,7 @@ if not MYPY:
         Authorizers allows you to define Lambda authorizers be applied for authorization when the
         the route is called.
         """
-        content_type: NotRequired[str]
+        content_type: NotRequired[_builtins.str]
         """
         The `content-type` to serve the file as.  Only valid when `localPath` points to a file.  If
         `localPath` points to a directory, the content types for all files will be inferred.
@@ -389,17 +389,17 @@ if not MYPY:
         """
         A Lambda function which will handle the route for the given path and method.
         """
-        iam_auth_enabled: NotRequired[bool]
+        iam_auth_enabled: NotRequired[_builtins.bool]
         """
         By default, the route method auth type is set to `NONE`. If true, the auth type will be
         set to `AWS_IAM`.
         """
-        index: NotRequired[Union[str, bool]]
+        index: NotRequired[Union[_builtins.str, _builtins.bool]]
         """
         By default a `localPath` hosting static content will also serve 'index.html' in response to a request on a directory.
         To disable this pass `false` or supply a new index document name.
         """
-        local_path: NotRequired[str]
+        local_path: NotRequired[_builtins.str]
         """
         The local path on disk to create static S3 resources for.  Files will be uploaded into S3
         objects, and directories will be recursively walked into.
@@ -428,15 +428,15 @@ elif False:
 @pulumi.input_type
 class RouteArgs:
     def __init__(__self__, *,
-                 path: str,
-                 api_key_required: Optional[bool] = None,
+                 path: _builtins.str,
+                 api_key_required: Optional[_builtins.bool] = None,
                  authorizers: Optional[Sequence['AuthorizerArgs']] = None,
-                 content_type: Optional[str] = None,
+                 content_type: Optional[_builtins.str] = None,
                  data: Optional[Any] = None,
                  event_handler: Optional[pulumi.Input['pulumi_aws.lambda_.Function']] = None,
-                 iam_auth_enabled: Optional[bool] = None,
-                 index: Optional[Union[str, bool]] = None,
-                 local_path: Optional[str] = None,
+                 iam_auth_enabled: Optional[_builtins.bool] = None,
+                 index: Optional[Union[_builtins.str, _builtins.bool]] = None,
+                 local_path: Optional[_builtins.str] = None,
                  method: Optional['Method'] = None,
                  request_validator: Optional['RequestValidator'] = None,
                  required_parameters: Optional[Sequence['RequiredParameterArgs']] = None,
@@ -446,21 +446,21 @@ class RouteArgs:
         have an incoming path that they match against.  However, destinations are determined by the kind
         of the route.
 
-        :param str path: The path on the API that will serve this route.  If not prefixed with `/`,
+        :param _builtins.str path: The path on the API that will serve this route.  If not prefixed with `/`,
                then a `/` will be added automatically to the beginning.
-        :param bool api_key_required: If true, an API key will be required for this route. The source for the API Key can be set at
+        :param _builtins.bool api_key_required: If true, an API key will be required for this route. The source for the API Key can be set at
                the API level and by default, the source will be the HEADER.
         :param Sequence['AuthorizerArgs'] authorizers: Authorizers allows you to define Lambda authorizers be applied for authorization when the
                the route is called.
-        :param str content_type: The `content-type` to serve the file as.  Only valid when `localPath` points to a file.  If
+        :param _builtins.str content_type: The `content-type` to serve the file as.  Only valid when `localPath` points to a file.  If
                `localPath` points to a directory, the content types for all files will be inferred.
         :param Any data: A raw Swagger object to include verbatim in the integration for this path.
         :param pulumi.Input['pulumi_aws.lambda_.Function'] event_handler: A Lambda function which will handle the route for the given path and method.
-        :param bool iam_auth_enabled: By default, the route method auth type is set to `NONE`. If true, the auth type will be
+        :param _builtins.bool iam_auth_enabled: By default, the route method auth type is set to `NONE`. If true, the auth type will be
                set to `AWS_IAM`.
-        :param Union[str, bool] index: By default a `localPath` hosting static content will also serve 'index.html' in response to a request on a directory.
+        :param Union[_builtins.str, _builtins.bool] index: By default a `localPath` hosting static content will also serve 'index.html' in response to a request on a directory.
                To disable this pass `false` or supply a new index document name.
-        :param str local_path: The local path on disk to create static S3 resources for.  Files will be uploaded into S3
+        :param _builtins.str local_path: The local path on disk to create static S3 resources for.  Files will be uploaded into S3
                objects, and directories will be recursively walked into.
         :param 'Method' method: The REST method of the route to match.  Only valid with `eventHandler` or `data` routes.
         :param 'RequestValidator' request_validator: Request Validator specifies the validator to use at the method level. This will override anything
@@ -495,9 +495,9 @@ class RouteArgs:
         if target is not None:
             pulumi.set(__self__, "target", target)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def path(self) -> str:
+    def path(self) -> _builtins.str:
         """
         The path on the API that will serve this route.  If not prefixed with `/`,
         then a `/` will be added automatically to the beginning.
@@ -505,12 +505,12 @@ class RouteArgs:
         return pulumi.get(self, "path")
 
     @path.setter
-    def path(self, value: str):
+    def path(self, value: _builtins.str):
         pulumi.set(self, "path", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="apiKeyRequired")
-    def api_key_required(self) -> Optional[bool]:
+    def api_key_required(self) -> Optional[_builtins.bool]:
         """
         If true, an API key will be required for this route. The source for the API Key can be set at
         the API level and by default, the source will be the HEADER.
@@ -518,10 +518,10 @@ class RouteArgs:
         return pulumi.get(self, "api_key_required")
 
     @api_key_required.setter
-    def api_key_required(self, value: Optional[bool]):
+    def api_key_required(self, value: Optional[_builtins.bool]):
         pulumi.set(self, "api_key_required", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def authorizers(self) -> Optional[Sequence['AuthorizerArgs']]:
         """
@@ -534,9 +534,9 @@ class RouteArgs:
     def authorizers(self, value: Optional[Sequence['AuthorizerArgs']]):
         pulumi.set(self, "authorizers", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="contentType")
-    def content_type(self) -> Optional[str]:
+    def content_type(self) -> Optional[_builtins.str]:
         """
         The `content-type` to serve the file as.  Only valid when `localPath` points to a file.  If
         `localPath` points to a directory, the content types for all files will be inferred.
@@ -544,10 +544,10 @@ class RouteArgs:
         return pulumi.get(self, "content_type")
 
     @content_type.setter
-    def content_type(self, value: Optional[str]):
+    def content_type(self, value: Optional[_builtins.str]):
         pulumi.set(self, "content_type", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def data(self) -> Optional[Any]:
         """
@@ -559,7 +559,7 @@ class RouteArgs:
     def data(self, value: Optional[Any]):
         pulumi.set(self, "data", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="eventHandler")
     def event_handler(self) -> Optional[pulumi.Input['pulumi_aws.lambda_.Function']]:
         """
@@ -571,9 +571,9 @@ class RouteArgs:
     def event_handler(self, value: Optional[pulumi.Input['pulumi_aws.lambda_.Function']]):
         pulumi.set(self, "event_handler", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="iamAuthEnabled")
-    def iam_auth_enabled(self) -> Optional[bool]:
+    def iam_auth_enabled(self) -> Optional[_builtins.bool]:
         """
         By default, the route method auth type is set to `NONE`. If true, the auth type will be
         set to `AWS_IAM`.
@@ -581,12 +581,12 @@ class RouteArgs:
         return pulumi.get(self, "iam_auth_enabled")
 
     @iam_auth_enabled.setter
-    def iam_auth_enabled(self, value: Optional[bool]):
+    def iam_auth_enabled(self, value: Optional[_builtins.bool]):
         pulumi.set(self, "iam_auth_enabled", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def index(self) -> Optional[Union[str, bool]]:
+    def index(self) -> Optional[Union[_builtins.str, _builtins.bool]]:
         """
         By default a `localPath` hosting static content will also serve 'index.html' in response to a request on a directory.
         To disable this pass `false` or supply a new index document name.
@@ -594,12 +594,12 @@ class RouteArgs:
         return pulumi.get(self, "index")
 
     @index.setter
-    def index(self, value: Optional[Union[str, bool]]):
+    def index(self, value: Optional[Union[_builtins.str, _builtins.bool]]):
         pulumi.set(self, "index", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="localPath")
-    def local_path(self) -> Optional[str]:
+    def local_path(self) -> Optional[_builtins.str]:
         """
         The local path on disk to create static S3 resources for.  Files will be uploaded into S3
         objects, and directories will be recursively walked into.
@@ -607,10 +607,10 @@ class RouteArgs:
         return pulumi.get(self, "local_path")
 
     @local_path.setter
-    def local_path(self, value: Optional[str]):
+    def local_path(self, value: Optional[_builtins.str]):
         pulumi.set(self, "local_path", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def method(self) -> Optional['Method']:
         """
@@ -622,7 +622,7 @@ class RouteArgs:
     def method(self, value: Optional['Method']):
         pulumi.set(self, "method", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="requestValidator")
     def request_validator(self) -> Optional['RequestValidator']:
         """
@@ -635,7 +635,7 @@ class RouteArgs:
     def request_validator(self, value: Optional['RequestValidator']):
         pulumi.set(self, "request_validator", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="requiredParameters")
     def required_parameters(self) -> Optional[Sequence['RequiredParameterArgs']]:
         """
@@ -648,7 +648,7 @@ class RouteArgs:
     def required_parameters(self, value: Optional[Sequence['RequiredParameterArgs']]):
         pulumi.set(self, "required_parameters", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def target(self) -> Optional[pulumi.Input['TargetArgs']]:
         """
@@ -663,18 +663,18 @@ class RouteArgs:
 
 if not MYPY:
     class SwaggerGatewayResponseArgsDict(TypedDict):
-        response_parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        response_templates: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        status_code: NotRequired[pulumi.Input[float]]
+        response_parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
+        response_templates: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
+        status_code: NotRequired[pulumi.Input[_builtins.float]]
 elif False:
     SwaggerGatewayResponseArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class SwaggerGatewayResponseArgs:
     def __init__(__self__, *,
-                 response_parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 response_templates: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 status_code: Optional[pulumi.Input[float]] = None):
+                 response_parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
+                 response_templates: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
+                 status_code: Optional[pulumi.Input[_builtins.float]] = None):
         if response_parameters is not None:
             pulumi.set(__self__, "response_parameters", response_parameters)
         if response_templates is not None:
@@ -682,31 +682,31 @@ class SwaggerGatewayResponseArgs:
         if status_code is not None:
             pulumi.set(__self__, "status_code", status_code)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="responseParameters")
-    def response_parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+    def response_parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
         return pulumi.get(self, "response_parameters")
 
     @response_parameters.setter
-    def response_parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+    def response_parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "response_parameters", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="responseTemplates")
-    def response_templates(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+    def response_templates(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
         return pulumi.get(self, "response_templates")
 
     @response_templates.setter
-    def response_templates(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+    def response_templates(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "response_templates", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="statusCode")
-    def status_code(self) -> Optional[pulumi.Input[float]]:
+    def status_code(self) -> Optional[pulumi.Input[_builtins.float]]:
         return pulumi.get(self, "status_code")
 
     @status_code.setter
-    def status_code(self, value: Optional[pulumi.Input[float]]):
+    def status_code(self, value: Optional[pulumi.Input[_builtins.float]]):
         pulumi.set(self, "status_code", value)
 
 
@@ -735,7 +735,7 @@ if not MYPY:
         * `mock`: for integrating the API method request with API Gateway as a "loop-back" endpoint
         without invoking any backend.
         """
-        connection_id: NotRequired[pulumi.Input[str]]
+        connection_id: NotRequired[pulumi.Input[_builtins.str]]
         """
         The (id) of the VpcLink used for the integration when connectionType=VPC_LINK and undefined,
         otherwise.
@@ -746,7 +746,7 @@ if not MYPY:
         for connections through the public routable internet or `VPC_LINK` for private connections
         between API Gateway and a network load balancer in a VPC. The default value is `INTERNET`.
         """
-        http_method: NotRequired[pulumi.Input[str]]
+        http_method: NotRequired[pulumi.Input[_builtins.str]]
         """
         Specifies the integration's HTTP method type.  Currently, the only supported type is 'ANY'.
         """
@@ -773,7 +773,7 @@ if not MYPY:
 
         Defaults to `WHEN_NO_MATCH` if unspecified.
         """
-        uri: NotRequired[pulumi.Input[str]]
+        uri: NotRequired[pulumi.Input[_builtins.str]]
         """
         Specifies Uniform Resource Identifier (URI) of the integration endpoint.
 
@@ -802,11 +802,11 @@ elif False:
 class TargetArgs:
     def __init__(__self__, *,
                  type: pulumi.Input['IntegrationType'],
-                 connection_id: Optional[pulumi.Input[str]] = None,
+                 connection_id: Optional[pulumi.Input[_builtins.str]] = None,
                  connection_type: Optional[pulumi.Input['IntegrationConnectionType']] = None,
-                 http_method: Optional[pulumi.Input[str]] = None,
+                 http_method: Optional[pulumi.Input[_builtins.str]] = None,
                  passthrough_behaviour: Optional[pulumi.Input['IntegrationPassthroughBehavior']] = None,
-                 uri: Optional[pulumi.Input[str]] = None):
+                 uri: Optional[pulumi.Input[_builtins.str]] = None):
         """
         :param pulumi.Input['IntegrationType'] type: Specifies an API method integration type. The valid value is one of the following:
                
@@ -828,12 +828,12 @@ class TargetArgs:
                
                * `mock`: for integrating the API method request with API Gateway as a "loop-back" endpoint
                without invoking any backend.
-        :param pulumi.Input[str] connection_id: The (id) of the VpcLink used for the integration when connectionType=VPC_LINK and undefined,
+        :param pulumi.Input[_builtins.str] connection_id: The (id) of the VpcLink used for the integration when connectionType=VPC_LINK and undefined,
                otherwise.
         :param pulumi.Input['IntegrationConnectionType'] connection_type: The type of the network connection to the integration endpoint. The valid value is `INTERNET`
                for connections through the public routable internet or `VPC_LINK` for private connections
                between API Gateway and a network load balancer in a VPC. The default value is `INTERNET`.
-        :param pulumi.Input[str] http_method: Specifies the integration's HTTP method type.  Currently, the only supported type is 'ANY'.
+        :param pulumi.Input[_builtins.str] http_method: Specifies the integration's HTTP method type.  Currently, the only supported type is 'ANY'.
         :param pulumi.Input['IntegrationPassthroughBehavior'] passthrough_behaviour: Specifies how the method request body of an unmapped content type will be passed through the
                integration request to the back end without transformation.
                
@@ -854,7 +854,7 @@ class TargetArgs:
                integration request.
                
                Defaults to `WHEN_NO_MATCH` if unspecified.
-        :param pulumi.Input[str] uri: Specifies Uniform Resource Identifier (URI) of the integration endpoint.
+        :param pulumi.Input[_builtins.str] uri: Specifies Uniform Resource Identifier (URI) of the integration endpoint.
                
                For HTTP or HTTP_PROXY integrations, the URI must be a fully formed, encoded HTTP(S) URL
                according to the RFC-3986 specification, for either standard integration, where
@@ -886,7 +886,7 @@ class TargetArgs:
         if uri is not None:
             pulumi.set(__self__, "uri", uri)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def type(self) -> pulumi.Input['IntegrationType']:
         """
@@ -917,9 +917,9 @@ class TargetArgs:
     def type(self, value: pulumi.Input['IntegrationType']):
         pulumi.set(self, "type", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="connectionId")
-    def connection_id(self) -> Optional[pulumi.Input[str]]:
+    def connection_id(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
         The (id) of the VpcLink used for the integration when connectionType=VPC_LINK and undefined,
         otherwise.
@@ -927,10 +927,10 @@ class TargetArgs:
         return pulumi.get(self, "connection_id")
 
     @connection_id.setter
-    def connection_id(self, value: Optional[pulumi.Input[str]]):
+    def connection_id(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "connection_id", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="connectionType")
     def connection_type(self) -> Optional[pulumi.Input['IntegrationConnectionType']]:
         """
@@ -944,19 +944,19 @@ class TargetArgs:
     def connection_type(self, value: Optional[pulumi.Input['IntegrationConnectionType']]):
         pulumi.set(self, "connection_type", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpMethod")
-    def http_method(self) -> Optional[pulumi.Input[str]]:
+    def http_method(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
         Specifies the integration's HTTP method type.  Currently, the only supported type is 'ANY'.
         """
         return pulumi.get(self, "http_method")
 
     @http_method.setter
-    def http_method(self, value: Optional[pulumi.Input[str]]):
+    def http_method(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "http_method", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="passthroughBehaviour")
     def passthrough_behaviour(self) -> Optional[pulumi.Input['IntegrationPassthroughBehavior']]:
         """
@@ -987,9 +987,9 @@ class TargetArgs:
     def passthrough_behaviour(self, value: Optional[pulumi.Input['IntegrationPassthroughBehavior']]):
         pulumi.set(self, "passthrough_behaviour", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> Optional[pulumi.Input[str]]:
+    def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
         Specifies Uniform Resource Identifier (URI) of the integration endpoint.
 
@@ -1014,7 +1014,7 @@ class TargetArgs:
         return pulumi.get(self, "uri")
 
     @uri.setter
-    def uri(self, value: Optional[pulumi.Input[str]]):
+    def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "uri", value)