From d4190f8fb829476c1466a2cfc2126bd5b92d9f4e Mon Sep 17 00:00:00 2001 From: Giovanni Grano Date: Fri, 29 Nov 2024 10:46:38 -0500 Subject: [PATCH 1/3] v0.0.4 --- VERSION | 2 +- .../.openapi-generator/FILES | 1 + .../localstack/sdk/api/aws_api.py | 515 ++++++++++++++++++ .../localstack/sdk/api/pro_api.py | 515 ++++++++++++++++++ .../localstack/sdk/api_client.py | 2 +- .../localstack/sdk/configuration.py | 2 +- .../localstack/sdk/models/__init__.py | 1 + .../localstack/sdk/models/iam_config.py | 106 ++++ .../localstack/sdk/models/pod_remote.py | 11 +- .../localstack-sdk-generated/pyproject.toml | 2 +- pyproject.toml | 2 +- 11 files changed, 1145 insertions(+), 14 deletions(-) create mode 100644 packages/localstack-sdk-generated/localstack/sdk/models/iam_config.py diff --git a/VERSION b/VERSION index bcab45a..81340c7 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.0.3 +0.0.4 diff --git a/packages/localstack-sdk-generated/.openapi-generator/FILES b/packages/localstack-sdk-generated/.openapi-generator/FILES index f26d40c..aa0c001 100644 --- a/packages/localstack-sdk-generated/.openapi-generator/FILES +++ b/packages/localstack-sdk-generated/.openapi-generator/FILES @@ -33,6 +33,7 @@ localstack/sdk/models/get_features_and_services200_response.py localstack/sdk/models/get_lambda_runtimes200_response.py localstack/sdk/models/get_ses_messages200_response.py localstack/sdk/models/get_sns_subscription_token200_response.py +localstack/sdk/models/iam_config.py localstack/sdk/models/init_scripts.py localstack/sdk/models/init_scripts_completed.py localstack/sdk/models/init_scripts_scripts_inner.py diff --git a/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py b/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py index 03327c3..d42bb13 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py @@ -26,6 +26,7 @@ from localstack.sdk.models.get_lambda_runtimes200_response import GetLambdaRuntimes200Response from localstack.sdk.models.get_ses_messages200_response import GetSesMessages200Response from localstack.sdk.models.get_sns_subscription_token200_response import GetSnsSubscriptionToken200Response +from localstack.sdk.models.iam_config import IamConfig from localstack.sdk.models.receive_message_result import ReceiveMessageResult from localstack.sdk.models.sns_platform_endpoint_response import SNSPlatformEndpointResponse from localstack.sdk.models.snssms_messages_response import SNSSMSMessagesResponse @@ -3338,6 +3339,520 @@ def _aws_cognito_idp_signup_post_0_serialize( + @validate_call + def aws_iam_config_get_0( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> IamConfig: + """aws_iam_config_get_0 + + IAM config endpoint + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_get_0_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "IamConfig", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def aws_iam_config_get_0_with_http_info( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[IamConfig]: + """aws_iam_config_get_0 + + IAM config endpoint + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_get_0_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "IamConfig", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def aws_iam_config_get_0_without_preload_content( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """aws_iam_config_get_0 + + IAM config endpoint + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_get_0_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "IamConfig", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _aws_iam_config_get_0_serialize( + self, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + + # authentication setting + _auth_settings: List[str] = [ + ] + + return self.api_client.param_serialize( + method='GET', + resource_path='/_aws/iam/config', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def aws_iam_config_post_0( + self, + iam_config: IamConfig, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """aws_iam_config_post_0 + + IAM config endpoint + + :param iam_config: (required) + :type iam_config: IamConfig + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_post_0_serialize( + iam_config=iam_config, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': None, + '400': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def aws_iam_config_post_0_with_http_info( + self, + iam_config: IamConfig, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """aws_iam_config_post_0 + + IAM config endpoint + + :param iam_config: (required) + :type iam_config: IamConfig + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_post_0_serialize( + iam_config=iam_config, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': None, + '400': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def aws_iam_config_post_0_without_preload_content( + self, + iam_config: IamConfig, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """aws_iam_config_post_0 + + IAM config endpoint + + :param iam_config: (required) + :type iam_config: IamConfig + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_post_0_serialize( + iam_config=iam_config, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': None, + '400': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _aws_iam_config_post_0_serialize( + self, + iam_config, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if iam_config is not None: + _body_params = iam_config + + + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/_aws/iam/config', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + @validate_call def aws_iot_local_stack_io_t_root_ca_pem_get_0( self, diff --git a/packages/localstack-sdk-generated/localstack/sdk/api/pro_api.py b/packages/localstack-sdk-generated/localstack/sdk/api/pro_api.py index c71bd21..26d9c96 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api/pro_api.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api/pro_api.py @@ -23,6 +23,7 @@ from localstack.sdk.models.aws_pinpoint_application_id_reference_id_get200_response import AwsPinpointApplicationIdReferenceIdGet200Response from localstack.sdk.models.create_remote_request import CreateRemoteRequest from localstack.sdk.models.fault_rule import FaultRule +from localstack.sdk.models.iam_config import IamConfig from localstack.sdk.models.list_remotes200_response import ListRemotes200Response from localstack.sdk.models.localstack_pods_environment_get200_response import LocalstackPodsEnvironmentGet200Response from localstack.sdk.models.localstack_stackinfo_get200_response import LocalstackStackinfoGet200Response @@ -3616,6 +3617,520 @@ def _aws_cognito_idp_signup_post_serialize( + @validate_call + def aws_iam_config_get( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> IamConfig: + """aws_iam_config_get + + IAM config endpoint + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "IamConfig", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def aws_iam_config_get_with_http_info( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[IamConfig]: + """aws_iam_config_get + + IAM config endpoint + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "IamConfig", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def aws_iam_config_get_without_preload_content( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """aws_iam_config_get + + IAM config endpoint + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "IamConfig", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _aws_iam_config_get_serialize( + self, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + + # authentication setting + _auth_settings: List[str] = [ + ] + + return self.api_client.param_serialize( + method='GET', + resource_path='/_aws/iam/config', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def aws_iam_config_post( + self, + iam_config: IamConfig, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """aws_iam_config_post + + IAM config endpoint + + :param iam_config: (required) + :type iam_config: IamConfig + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_post_serialize( + iam_config=iam_config, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': None, + '400': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def aws_iam_config_post_with_http_info( + self, + iam_config: IamConfig, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """aws_iam_config_post + + IAM config endpoint + + :param iam_config: (required) + :type iam_config: IamConfig + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_post_serialize( + iam_config=iam_config, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': None, + '400': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def aws_iam_config_post_without_preload_content( + self, + iam_config: IamConfig, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """aws_iam_config_post + + IAM config endpoint + + :param iam_config: (required) + :type iam_config: IamConfig + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._aws_iam_config_post_serialize( + iam_config=iam_config, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': None, + '400': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _aws_iam_config_post_serialize( + self, + iam_config, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if iam_config is not None: + _body_params = iam_config + + + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/_aws/iam/config', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + @validate_call def aws_iot_local_stack_io_t_root_ca_pem_get( self, diff --git a/packages/localstack-sdk-generated/localstack/sdk/api_client.py b/packages/localstack-sdk-generated/localstack/sdk/api_client.py index a866955..16fe354 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api_client.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api_client.py @@ -91,7 +91,7 @@ def __init__( self.default_headers[header_name] = header_value self.cookie = cookie # Set default User-Agent. - self.user_agent = 'OpenAPI-Generator/0.0.3/python' + self.user_agent = 'OpenAPI-Generator/0.0.4/python' self.client_side_validation = configuration.client_side_validation def __enter__(self): diff --git a/packages/localstack-sdk-generated/localstack/sdk/configuration.py b/packages/localstack-sdk-generated/localstack/sdk/configuration.py index 76cf59a..b7a018f 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/configuration.py +++ b/packages/localstack-sdk-generated/localstack/sdk/configuration.py @@ -385,7 +385,7 @@ def to_debug_report(self): "OS: {env}\n"\ "Python Version: {pyversion}\n"\ "Version of the API: latest\n"\ - "SDK Package Version: 0.0.3".\ + "SDK Package Version: 0.0.4".\ format(env=sys.platform, pyversion=sys.version) def get_host_settings(self): diff --git a/packages/localstack-sdk-generated/localstack/sdk/models/__init__.py b/packages/localstack-sdk-generated/localstack/sdk/models/__init__.py index b4021ea..24de1dd 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/models/__init__.py +++ b/packages/localstack-sdk-generated/localstack/sdk/models/__init__.py @@ -36,6 +36,7 @@ from localstack.sdk.models.get_lambda_runtimes200_response import GetLambdaRuntimes200Response from localstack.sdk.models.get_ses_messages200_response import GetSesMessages200Response from localstack.sdk.models.get_sns_subscription_token200_response import GetSnsSubscriptionToken200Response +from localstack.sdk.models.iam_config import IamConfig from localstack.sdk.models.init_scripts import InitScripts from localstack.sdk.models.init_scripts_completed import InitScriptsCompleted from localstack.sdk.models.init_scripts_scripts_inner import InitScriptsScriptsInner diff --git a/packages/localstack-sdk-generated/localstack/sdk/models/iam_config.py b/packages/localstack-sdk-generated/localstack/sdk/models/iam_config.py new file mode 100644 index 0000000..f2f23ab --- /dev/null +++ b/packages/localstack-sdk-generated/localstack/sdk/models/iam_config.py @@ -0,0 +1,106 @@ +# coding: utf-8 + +""" + LocalStack REST API + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) + + The version of the OpenAPI document: latest + Contact: info@localstack.cloud + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class IamConfig(BaseModel): + """ + IAM Config + """ # noqa: E501 + state: Optional[StrictStr] = Field(default=None, description="Engine state") + config_enforce_iam: Optional[StrictBool] = Field(default=None, description="Whether the ENFORCE_IAM flag was set on startup of LocalStack.") + config_iam_soft_mode: Optional[StrictBool] = Field(default=None, description="Supported protocols of the remote.") + __properties: ClassVar[List[str]] = ["state", "config_enforce_iam", "config_iam_soft_mode"] + + @field_validator('state') + def state_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['DISABLED', 'ENGINE_ONLY', 'SOFT_MODE', 'ENFORCED']): + raise ValueError("must be one of enum values ('DISABLED', 'ENGINE_ONLY', 'SOFT_MODE', 'ENFORCED')") + return value + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of IamConfig from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + * OpenAPI `readOnly` fields are excluded. + * OpenAPI `readOnly` fields are excluded. + """ + excluded_fields: Set[str] = set([ + "config_enforce_iam", + "config_iam_soft_mode", + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of IamConfig from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "state": obj.get("state"), + "config_enforce_iam": obj.get("config_enforce_iam"), + "config_iam_soft_mode": obj.get("config_iam_soft_mode") + }) + return _obj + + diff --git a/packages/localstack-sdk-generated/localstack/sdk/models/pod_remote.py b/packages/localstack-sdk-generated/localstack/sdk/models/pod_remote.py index 6c00377..29802b1 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/models/pod_remote.py +++ b/packages/localstack-sdk-generated/localstack/sdk/models/pod_remote.py @@ -31,8 +31,7 @@ class PodRemote(BaseModel): protocols: Optional[List[StrictStr]] = Field(default=None, description="Supported protocols of the remote.") token: Optional[Dict[str, Any]] = Field(default=None, description="The token for this remote.") url: Optional[StrictStr] = Field(default=None, description="URL of the remote server.") - example: Optional[Any] = None - __properties: ClassVar[List[str]] = ["name", "protocols", "token", "url", "example"] + __properties: ClassVar[List[str]] = ["name", "protocols", "token", "url"] model_config = ConfigDict( populate_by_name=True, @@ -73,11 +72,6 @@ def to_dict(self) -> Dict[str, Any]: exclude=excluded_fields, exclude_none=True, ) - # set to None if example (nullable) is None - # and model_fields_set contains the field - if self.example is None and "example" in self.model_fields_set: - _dict['example'] = None - return _dict @classmethod @@ -93,8 +87,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "name": obj.get("name"), "protocols": obj.get("protocols"), "token": obj.get("token"), - "url": obj.get("url"), - "example": obj.get("example") + "url": obj.get("url") }) return _obj diff --git a/packages/localstack-sdk-generated/pyproject.toml b/packages/localstack-sdk-generated/pyproject.toml index f442f87..49bb53e 100644 --- a/packages/localstack-sdk-generated/pyproject.toml +++ b/packages/localstack-sdk-generated/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "localstack-sdk-generated" -version = "0.0.3" +version = "0.0.4" description = "LocalStack REST API - Generated Code" authors = [ { name = "LocalStack Contributors", email = "info@localstack.cloud" } diff --git a/pyproject.toml b/pyproject.toml index e9f5001..a81248b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ description = "Python SDK for LocalStack" authors = [ { name = "LocalStack Team", email = "info@localstack.cloud"} ] -version = "0.0.3" +version = "0.0.4" dependencies = [ "localstack-sdk-generated" ] From 24fc1c2392c55c438560efff96668dcc573022af Mon Sep 17 00:00:00 2001 From: Giovanni Grano Date: Fri, 29 Nov 2024 11:22:56 -0500 Subject: [PATCH 2/3] bump openapi-generator-cli to 7.10.0 --- bin/generate.sh | 2 +- .../localstack/sdk/chaos/client.py | 12 +- .../localstack/sdk/pods/client.py | 8 +- .../localstack/sdk/state/client.py | 2 +- .../.openapi-generator/VERSION | 2 +- .../localstack/sdk/api/aws_api.py | 360 +++++++++--------- .../localstack/sdk/api/chaos_api.py | 84 ++-- .../localstack/sdk/api/pods_api.py | 242 ++++++------ .../localstack/sdk/api/state_api.py | 120 +++--- .../localstack/sdk/configuration.py | 189 +++++++-- 10 files changed, 568 insertions(+), 453 deletions(-) diff --git a/bin/generate.sh b/bin/generate.sh index df180a4..083804a 100755 --- a/bin/generate.sh +++ b/bin/generate.sh @@ -2,7 +2,7 @@ version=$(cat VERSION) -docker run --rm -v "${PWD}:/local" openapitools/openapi-generator-cli:v7.9.0 generate \ +docker run --rm -v "${PWD}:/local" openapitools/openapi-generator-cli:v7.10.0 generate \ -i https://raw.githubusercontent.com/localstack/openapi/refs/heads/main/openapi/emulators/localstack-spec-latest.yml \ --skip-validate-spec \ -g python \ diff --git a/localstack-sdk-python/localstack/sdk/chaos/client.py b/localstack-sdk-python/localstack/sdk/chaos/client.py index 9b1bb07..44d5717 100644 --- a/localstack-sdk-python/localstack/sdk/chaos/client.py +++ b/localstack-sdk-python/localstack/sdk/chaos/client.py @@ -18,7 +18,7 @@ def set_fault_rules(self, fault_rules: list[FaultRule]) -> list[FaultRule]: :param fault_rules: the list of FaultRule we want to set :return: the list of FaultRule currently in place """ - return self._client.set_fault_rules_0(fault_rule=fault_rules) + return self._client.set_fault_rules(fault_rule=fault_rules) def add_fault_rules(self, fault_rules: list[FaultRule]) -> list[FaultRule]: """ @@ -26,7 +26,7 @@ def add_fault_rules(self, fault_rules: list[FaultRule]) -> list[FaultRule]: :param fault_rules: the FaultRule rules to add :return: the list of FaultRule currently in place """ - return self._client.add_fault_rules_0(fault_rule=fault_rules) + return self._client.add_fault_rules(fault_rule=fault_rules) def delete_fault_rules(self, fault_rules: list[FaultRule]) -> list[FaultRule]: """ @@ -34,21 +34,21 @@ def delete_fault_rules(self, fault_rules: list[FaultRule]) -> list[FaultRule]: :param fault_rules: the FaultRule to delete :return: the list of FaultRule currently in place """ - return self._client.delete_fault_rules_0(fault_rule=fault_rules) + return self._client.delete_fault_rules(fault_rule=fault_rules) def get_fault_rules(self) -> list[FaultRule]: """ Gets the current fault configuration. :return: the list of FaultRule of the current configuration """ - return self._client.get_fault_rules_0() + return self._client.get_fault_rules() def get_network_effects(self) -> NetworkEffectsConfig: """ Gets the current network effect configuration. :return: the current NetworkEffectsConfig """ - return self._client.get_network_effects_0() + return self._client.get_network_effects() def set_network_effects( self, network_effects_config: NetworkEffectsConfig @@ -58,7 +58,7 @@ def set_network_effects( :param network_effects_config: the network config to be set :return: the current configuration of network effects """ - return self._client.set_network_effects_0(network_effects_config=network_effects_config) + return self._client.set_network_effects(network_effects_config=network_effects_config) def get_default(**args) -> ChaosClient: diff --git a/localstack-sdk-python/localstack/sdk/pods/client.py b/localstack-sdk-python/localstack/sdk/pods/client.py index 4a338df..87703a6 100644 --- a/localstack-sdk-python/localstack/sdk/pods/client.py +++ b/localstack-sdk-python/localstack/sdk/pods/client.py @@ -60,7 +60,7 @@ def save_pod(self, pod_name: str) -> None: :return: None :raises PodSaveException: if the save operation returns an error """ - response = self._client.save_pod_0_with_http_info( + response = self._client.save_pod_with_http_info( name=pod_name, pod_save_request=PodSaveRequest() ) if response.status_code != 200: @@ -77,7 +77,7 @@ def load_pod(self, pod_name: str) -> None: :return: None :raises PodLoadException: if the load operation returns an error """ - response = self._client.load_pod_0_with_http_info( + response = self._client.load_pod_with_http_info( name=pod_name, remote_config=_empty_remote_config() ) if response.status_code != 200: @@ -93,14 +93,14 @@ def delete_pod(self, pod_name: str) -> None: :param pod_name: the name of the Cloud Pod to be deleted. :return: None """ - return self._client.delete_pod_0(name=pod_name, remote_config=_empty_remote_config()) + return self._client.delete_pod(name=pod_name, remote_config=_empty_remote_config()) def list_pods(self) -> PodList: """ Returns the list of the Cloud Pods visible in the organization. :return: a PodList object """ - pods = self._client.list_pods_0(remote_config=_empty_remote_config()) + pods = self._client.list_pods(remote_config=_empty_remote_config()) return pods diff --git a/localstack-sdk-python/localstack/sdk/state/client.py b/localstack-sdk-python/localstack/sdk/state/client.py index 8c55e80..9c9af95 100644 --- a/localstack-sdk-python/localstack/sdk/state/client.py +++ b/localstack-sdk-python/localstack/sdk/state/client.py @@ -16,4 +16,4 @@ def reset_state(self) -> None: Resets the state of LocalStack for all running services. :return: None """ - self._client.localstack_state_reset_post_0() + self._client.localstack_state_reset_post() diff --git a/packages/localstack-sdk-generated/.openapi-generator/VERSION b/packages/localstack-sdk-generated/.openapi-generator/VERSION index 4bc5d61..758bb9c 100644 --- a/packages/localstack-sdk-generated/.openapi-generator/VERSION +++ b/packages/localstack-sdk-generated/.openapi-generator/VERSION @@ -1 +1 @@ -7.9.0 +7.10.0 diff --git a/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py b/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py index d42bb13..e18fbf4 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api/aws_api.py @@ -50,7 +50,7 @@ def __init__(self, api_client=None) -> None: @validate_call - def aws_cognito_idp_forgot_password_get_0( + def aws_cognito_idp_forgot_password_get( self, _request_timeout: Union[ None, @@ -65,7 +65,7 @@ def aws_cognito_idp_forgot_password_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_forgot_password_get_0 + """aws_cognito_idp_forgot_password_get Cognito forgot password endpoint @@ -91,7 +91,7 @@ def aws_cognito_idp_forgot_password_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_forgot_password_get_0_serialize( + _param = self._aws_cognito_idp_forgot_password_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -112,7 +112,7 @@ def aws_cognito_idp_forgot_password_get_0( @validate_call - def aws_cognito_idp_forgot_password_get_0_with_http_info( + def aws_cognito_idp_forgot_password_get_with_http_info( self, _request_timeout: Union[ None, @@ -127,7 +127,7 @@ def aws_cognito_idp_forgot_password_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_forgot_password_get_0 + """aws_cognito_idp_forgot_password_get Cognito forgot password endpoint @@ -153,7 +153,7 @@ def aws_cognito_idp_forgot_password_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_forgot_password_get_0_serialize( + _param = self._aws_cognito_idp_forgot_password_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -174,7 +174,7 @@ def aws_cognito_idp_forgot_password_get_0_with_http_info( @validate_call - def aws_cognito_idp_forgot_password_get_0_without_preload_content( + def aws_cognito_idp_forgot_password_get_without_preload_content( self, _request_timeout: Union[ None, @@ -189,7 +189,7 @@ def aws_cognito_idp_forgot_password_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_forgot_password_get_0 + """aws_cognito_idp_forgot_password_get Cognito forgot password endpoint @@ -215,7 +215,7 @@ def aws_cognito_idp_forgot_password_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_forgot_password_get_0_serialize( + _param = self._aws_cognito_idp_forgot_password_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -231,7 +231,7 @@ def aws_cognito_idp_forgot_password_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_forgot_password_get_0_serialize( + def _aws_cognito_idp_forgot_password_get_serialize( self, _request_auth, _content_type, @@ -285,7 +285,7 @@ def _aws_cognito_idp_forgot_password_get_0_serialize( @validate_call - def aws_cognito_idp_forgot_password_post_0( + def aws_cognito_idp_forgot_password_post( self, _request_timeout: Union[ None, @@ -300,7 +300,7 @@ def aws_cognito_idp_forgot_password_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_forgot_password_post_0 + """aws_cognito_idp_forgot_password_post Cognito forgot password endpoint @@ -326,7 +326,7 @@ def aws_cognito_idp_forgot_password_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_forgot_password_post_0_serialize( + _param = self._aws_cognito_idp_forgot_password_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -347,7 +347,7 @@ def aws_cognito_idp_forgot_password_post_0( @validate_call - def aws_cognito_idp_forgot_password_post_0_with_http_info( + def aws_cognito_idp_forgot_password_post_with_http_info( self, _request_timeout: Union[ None, @@ -362,7 +362,7 @@ def aws_cognito_idp_forgot_password_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_forgot_password_post_0 + """aws_cognito_idp_forgot_password_post Cognito forgot password endpoint @@ -388,7 +388,7 @@ def aws_cognito_idp_forgot_password_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_forgot_password_post_0_serialize( + _param = self._aws_cognito_idp_forgot_password_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -409,7 +409,7 @@ def aws_cognito_idp_forgot_password_post_0_with_http_info( @validate_call - def aws_cognito_idp_forgot_password_post_0_without_preload_content( + def aws_cognito_idp_forgot_password_post_without_preload_content( self, _request_timeout: Union[ None, @@ -424,7 +424,7 @@ def aws_cognito_idp_forgot_password_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_forgot_password_post_0 + """aws_cognito_idp_forgot_password_post Cognito forgot password endpoint @@ -450,7 +450,7 @@ def aws_cognito_idp_forgot_password_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_forgot_password_post_0_serialize( + _param = self._aws_cognito_idp_forgot_password_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -466,7 +466,7 @@ def aws_cognito_idp_forgot_password_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_forgot_password_post_0_serialize( + def _aws_cognito_idp_forgot_password_post_serialize( self, _request_auth, _content_type, @@ -520,7 +520,7 @@ def _aws_cognito_idp_forgot_password_post_0_serialize( @validate_call - def aws_cognito_idp_login_get_0( + def aws_cognito_idp_login_get( self, _request_timeout: Union[ None, @@ -535,7 +535,7 @@ def aws_cognito_idp_login_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_login_get_0 + """aws_cognito_idp_login_get Cognito login endpoint @@ -561,7 +561,7 @@ def aws_cognito_idp_login_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_login_get_0_serialize( + _param = self._aws_cognito_idp_login_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -582,7 +582,7 @@ def aws_cognito_idp_login_get_0( @validate_call - def aws_cognito_idp_login_get_0_with_http_info( + def aws_cognito_idp_login_get_with_http_info( self, _request_timeout: Union[ None, @@ -597,7 +597,7 @@ def aws_cognito_idp_login_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_login_get_0 + """aws_cognito_idp_login_get Cognito login endpoint @@ -623,7 +623,7 @@ def aws_cognito_idp_login_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_login_get_0_serialize( + _param = self._aws_cognito_idp_login_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -644,7 +644,7 @@ def aws_cognito_idp_login_get_0_with_http_info( @validate_call - def aws_cognito_idp_login_get_0_without_preload_content( + def aws_cognito_idp_login_get_without_preload_content( self, _request_timeout: Union[ None, @@ -659,7 +659,7 @@ def aws_cognito_idp_login_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_login_get_0 + """aws_cognito_idp_login_get Cognito login endpoint @@ -685,7 +685,7 @@ def aws_cognito_idp_login_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_login_get_0_serialize( + _param = self._aws_cognito_idp_login_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -701,7 +701,7 @@ def aws_cognito_idp_login_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_login_get_0_serialize( + def _aws_cognito_idp_login_get_serialize( self, _request_auth, _content_type, @@ -755,7 +755,7 @@ def _aws_cognito_idp_login_get_0_serialize( @validate_call - def aws_cognito_idp_login_post_0( + def aws_cognito_idp_login_post( self, _request_timeout: Union[ None, @@ -770,7 +770,7 @@ def aws_cognito_idp_login_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_login_post_0 + """aws_cognito_idp_login_post Cognito login endpoint @@ -796,7 +796,7 @@ def aws_cognito_idp_login_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_login_post_0_serialize( + _param = self._aws_cognito_idp_login_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -817,7 +817,7 @@ def aws_cognito_idp_login_post_0( @validate_call - def aws_cognito_idp_login_post_0_with_http_info( + def aws_cognito_idp_login_post_with_http_info( self, _request_timeout: Union[ None, @@ -832,7 +832,7 @@ def aws_cognito_idp_login_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_login_post_0 + """aws_cognito_idp_login_post Cognito login endpoint @@ -858,7 +858,7 @@ def aws_cognito_idp_login_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_login_post_0_serialize( + _param = self._aws_cognito_idp_login_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -879,7 +879,7 @@ def aws_cognito_idp_login_post_0_with_http_info( @validate_call - def aws_cognito_idp_login_post_0_without_preload_content( + def aws_cognito_idp_login_post_without_preload_content( self, _request_timeout: Union[ None, @@ -894,7 +894,7 @@ def aws_cognito_idp_login_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_login_post_0 + """aws_cognito_idp_login_post Cognito login endpoint @@ -920,7 +920,7 @@ def aws_cognito_idp_login_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_login_post_0_serialize( + _param = self._aws_cognito_idp_login_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -936,7 +936,7 @@ def aws_cognito_idp_login_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_login_post_0_serialize( + def _aws_cognito_idp_login_post_serialize( self, _request_auth, _content_type, @@ -990,7 +990,7 @@ def _aws_cognito_idp_login_post_0_serialize( @validate_call - def aws_cognito_idp_logout_get_0( + def aws_cognito_idp_logout_get( self, _request_timeout: Union[ None, @@ -1005,7 +1005,7 @@ def aws_cognito_idp_logout_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_logout_get_0 + """aws_cognito_idp_logout_get Cognito logout endpoint @@ -1031,7 +1031,7 @@ def aws_cognito_idp_logout_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_logout_get_0_serialize( + _param = self._aws_cognito_idp_logout_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1052,7 +1052,7 @@ def aws_cognito_idp_logout_get_0( @validate_call - def aws_cognito_idp_logout_get_0_with_http_info( + def aws_cognito_idp_logout_get_with_http_info( self, _request_timeout: Union[ None, @@ -1067,7 +1067,7 @@ def aws_cognito_idp_logout_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_logout_get_0 + """aws_cognito_idp_logout_get Cognito logout endpoint @@ -1093,7 +1093,7 @@ def aws_cognito_idp_logout_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_logout_get_0_serialize( + _param = self._aws_cognito_idp_logout_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1114,7 +1114,7 @@ def aws_cognito_idp_logout_get_0_with_http_info( @validate_call - def aws_cognito_idp_logout_get_0_without_preload_content( + def aws_cognito_idp_logout_get_without_preload_content( self, _request_timeout: Union[ None, @@ -1129,7 +1129,7 @@ def aws_cognito_idp_logout_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_logout_get_0 + """aws_cognito_idp_logout_get Cognito logout endpoint @@ -1155,7 +1155,7 @@ def aws_cognito_idp_logout_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_logout_get_0_serialize( + _param = self._aws_cognito_idp_logout_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1171,7 +1171,7 @@ def aws_cognito_idp_logout_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_logout_get_0_serialize( + def _aws_cognito_idp_logout_get_serialize( self, _request_auth, _content_type, @@ -1225,7 +1225,7 @@ def _aws_cognito_idp_logout_get_0_serialize( @validate_call - def aws_cognito_idp_logout_post_0( + def aws_cognito_idp_logout_post( self, _request_timeout: Union[ None, @@ -1240,7 +1240,7 @@ def aws_cognito_idp_logout_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_logout_post_0 + """aws_cognito_idp_logout_post Cognito logout endpoint @@ -1266,7 +1266,7 @@ def aws_cognito_idp_logout_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_logout_post_0_serialize( + _param = self._aws_cognito_idp_logout_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1287,7 +1287,7 @@ def aws_cognito_idp_logout_post_0( @validate_call - def aws_cognito_idp_logout_post_0_with_http_info( + def aws_cognito_idp_logout_post_with_http_info( self, _request_timeout: Union[ None, @@ -1302,7 +1302,7 @@ def aws_cognito_idp_logout_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_logout_post_0 + """aws_cognito_idp_logout_post Cognito logout endpoint @@ -1328,7 +1328,7 @@ def aws_cognito_idp_logout_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_logout_post_0_serialize( + _param = self._aws_cognito_idp_logout_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1349,7 +1349,7 @@ def aws_cognito_idp_logout_post_0_with_http_info( @validate_call - def aws_cognito_idp_logout_post_0_without_preload_content( + def aws_cognito_idp_logout_post_without_preload_content( self, _request_timeout: Union[ None, @@ -1364,7 +1364,7 @@ def aws_cognito_idp_logout_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_logout_post_0 + """aws_cognito_idp_logout_post Cognito logout endpoint @@ -1390,7 +1390,7 @@ def aws_cognito_idp_logout_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_logout_post_0_serialize( + _param = self._aws_cognito_idp_logout_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1406,7 +1406,7 @@ def aws_cognito_idp_logout_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_logout_post_0_serialize( + def _aws_cognito_idp_logout_post_serialize( self, _request_auth, _content_type, @@ -1460,7 +1460,7 @@ def _aws_cognito_idp_logout_post_0_serialize( @validate_call - def aws_cognito_idp_oauth2_authorize_get_0( + def aws_cognito_idp_oauth2_authorize_get( self, _request_timeout: Union[ None, @@ -1475,7 +1475,7 @@ def aws_cognito_idp_oauth2_authorize_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_oauth2_authorize_get_0 + """aws_cognito_idp_oauth2_authorize_get Cognito OAuth 2.0 authorization endpoint @@ -1501,7 +1501,7 @@ def aws_cognito_idp_oauth2_authorize_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_authorize_get_0_serialize( + _param = self._aws_cognito_idp_oauth2_authorize_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1522,7 +1522,7 @@ def aws_cognito_idp_oauth2_authorize_get_0( @validate_call - def aws_cognito_idp_oauth2_authorize_get_0_with_http_info( + def aws_cognito_idp_oauth2_authorize_get_with_http_info( self, _request_timeout: Union[ None, @@ -1537,7 +1537,7 @@ def aws_cognito_idp_oauth2_authorize_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_oauth2_authorize_get_0 + """aws_cognito_idp_oauth2_authorize_get Cognito OAuth 2.0 authorization endpoint @@ -1563,7 +1563,7 @@ def aws_cognito_idp_oauth2_authorize_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_authorize_get_0_serialize( + _param = self._aws_cognito_idp_oauth2_authorize_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1584,7 +1584,7 @@ def aws_cognito_idp_oauth2_authorize_get_0_with_http_info( @validate_call - def aws_cognito_idp_oauth2_authorize_get_0_without_preload_content( + def aws_cognito_idp_oauth2_authorize_get_without_preload_content( self, _request_timeout: Union[ None, @@ -1599,7 +1599,7 @@ def aws_cognito_idp_oauth2_authorize_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_oauth2_authorize_get_0 + """aws_cognito_idp_oauth2_authorize_get Cognito OAuth 2.0 authorization endpoint @@ -1625,7 +1625,7 @@ def aws_cognito_idp_oauth2_authorize_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_authorize_get_0_serialize( + _param = self._aws_cognito_idp_oauth2_authorize_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1641,7 +1641,7 @@ def aws_cognito_idp_oauth2_authorize_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_oauth2_authorize_get_0_serialize( + def _aws_cognito_idp_oauth2_authorize_get_serialize( self, _request_auth, _content_type, @@ -1695,7 +1695,7 @@ def _aws_cognito_idp_oauth2_authorize_get_0_serialize( @validate_call - def aws_cognito_idp_oauth2_revoke_post_0( + def aws_cognito_idp_oauth2_revoke_post( self, _request_timeout: Union[ None, @@ -1710,7 +1710,7 @@ def aws_cognito_idp_oauth2_revoke_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_oauth2_revoke_post_0 + """aws_cognito_idp_oauth2_revoke_post Cognito OAuth 2.0 token revocation endpoint @@ -1736,7 +1736,7 @@ def aws_cognito_idp_oauth2_revoke_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_revoke_post_0_serialize( + _param = self._aws_cognito_idp_oauth2_revoke_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1757,7 +1757,7 @@ def aws_cognito_idp_oauth2_revoke_post_0( @validate_call - def aws_cognito_idp_oauth2_revoke_post_0_with_http_info( + def aws_cognito_idp_oauth2_revoke_post_with_http_info( self, _request_timeout: Union[ None, @@ -1772,7 +1772,7 @@ def aws_cognito_idp_oauth2_revoke_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_oauth2_revoke_post_0 + """aws_cognito_idp_oauth2_revoke_post Cognito OAuth 2.0 token revocation endpoint @@ -1798,7 +1798,7 @@ def aws_cognito_idp_oauth2_revoke_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_revoke_post_0_serialize( + _param = self._aws_cognito_idp_oauth2_revoke_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1819,7 +1819,7 @@ def aws_cognito_idp_oauth2_revoke_post_0_with_http_info( @validate_call - def aws_cognito_idp_oauth2_revoke_post_0_without_preload_content( + def aws_cognito_idp_oauth2_revoke_post_without_preload_content( self, _request_timeout: Union[ None, @@ -1834,7 +1834,7 @@ def aws_cognito_idp_oauth2_revoke_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_oauth2_revoke_post_0 + """aws_cognito_idp_oauth2_revoke_post Cognito OAuth 2.0 token revocation endpoint @@ -1860,7 +1860,7 @@ def aws_cognito_idp_oauth2_revoke_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_revoke_post_0_serialize( + _param = self._aws_cognito_idp_oauth2_revoke_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1876,7 +1876,7 @@ def aws_cognito_idp_oauth2_revoke_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_oauth2_revoke_post_0_serialize( + def _aws_cognito_idp_oauth2_revoke_post_serialize( self, _request_auth, _content_type, @@ -1930,7 +1930,7 @@ def _aws_cognito_idp_oauth2_revoke_post_0_serialize( @validate_call - def aws_cognito_idp_oauth2_token_post_0( + def aws_cognito_idp_oauth2_token_post( self, _request_timeout: Union[ None, @@ -1945,7 +1945,7 @@ def aws_cognito_idp_oauth2_token_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_oauth2_token_post_0 + """aws_cognito_idp_oauth2_token_post Cognito OAuth 2.0 token endpoint @@ -1971,7 +1971,7 @@ def aws_cognito_idp_oauth2_token_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_token_post_0_serialize( + _param = self._aws_cognito_idp_oauth2_token_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1992,7 +1992,7 @@ def aws_cognito_idp_oauth2_token_post_0( @validate_call - def aws_cognito_idp_oauth2_token_post_0_with_http_info( + def aws_cognito_idp_oauth2_token_post_with_http_info( self, _request_timeout: Union[ None, @@ -2007,7 +2007,7 @@ def aws_cognito_idp_oauth2_token_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_oauth2_token_post_0 + """aws_cognito_idp_oauth2_token_post Cognito OAuth 2.0 token endpoint @@ -2033,7 +2033,7 @@ def aws_cognito_idp_oauth2_token_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_token_post_0_serialize( + _param = self._aws_cognito_idp_oauth2_token_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2054,7 +2054,7 @@ def aws_cognito_idp_oauth2_token_post_0_with_http_info( @validate_call - def aws_cognito_idp_oauth2_token_post_0_without_preload_content( + def aws_cognito_idp_oauth2_token_post_without_preload_content( self, _request_timeout: Union[ None, @@ -2069,7 +2069,7 @@ def aws_cognito_idp_oauth2_token_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_oauth2_token_post_0 + """aws_cognito_idp_oauth2_token_post Cognito OAuth 2.0 token endpoint @@ -2095,7 +2095,7 @@ def aws_cognito_idp_oauth2_token_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_token_post_0_serialize( + _param = self._aws_cognito_idp_oauth2_token_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2111,7 +2111,7 @@ def aws_cognito_idp_oauth2_token_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_oauth2_token_post_0_serialize( + def _aws_cognito_idp_oauth2_token_post_serialize( self, _request_auth, _content_type, @@ -2165,7 +2165,7 @@ def _aws_cognito_idp_oauth2_token_post_0_serialize( @validate_call - def aws_cognito_idp_oauth2_user_info_get_0( + def aws_cognito_idp_oauth2_user_info_get( self, _request_timeout: Union[ None, @@ -2180,7 +2180,7 @@ def aws_cognito_idp_oauth2_user_info_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_oauth2_user_info_get_0 + """aws_cognito_idp_oauth2_user_info_get Cognito OpenID Connect userInfo endpoint @@ -2206,7 +2206,7 @@ def aws_cognito_idp_oauth2_user_info_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_user_info_get_0_serialize( + _param = self._aws_cognito_idp_oauth2_user_info_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2227,7 +2227,7 @@ def aws_cognito_idp_oauth2_user_info_get_0( @validate_call - def aws_cognito_idp_oauth2_user_info_get_0_with_http_info( + def aws_cognito_idp_oauth2_user_info_get_with_http_info( self, _request_timeout: Union[ None, @@ -2242,7 +2242,7 @@ def aws_cognito_idp_oauth2_user_info_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_oauth2_user_info_get_0 + """aws_cognito_idp_oauth2_user_info_get Cognito OpenID Connect userInfo endpoint @@ -2268,7 +2268,7 @@ def aws_cognito_idp_oauth2_user_info_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_user_info_get_0_serialize( + _param = self._aws_cognito_idp_oauth2_user_info_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2289,7 +2289,7 @@ def aws_cognito_idp_oauth2_user_info_get_0_with_http_info( @validate_call - def aws_cognito_idp_oauth2_user_info_get_0_without_preload_content( + def aws_cognito_idp_oauth2_user_info_get_without_preload_content( self, _request_timeout: Union[ None, @@ -2304,7 +2304,7 @@ def aws_cognito_idp_oauth2_user_info_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_oauth2_user_info_get_0 + """aws_cognito_idp_oauth2_user_info_get Cognito OpenID Connect userInfo endpoint @@ -2330,7 +2330,7 @@ def aws_cognito_idp_oauth2_user_info_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_oauth2_user_info_get_0_serialize( + _param = self._aws_cognito_idp_oauth2_user_info_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2346,7 +2346,7 @@ def aws_cognito_idp_oauth2_user_info_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_oauth2_user_info_get_0_serialize( + def _aws_cognito_idp_oauth2_user_info_get_serialize( self, _request_auth, _content_type, @@ -2400,7 +2400,7 @@ def _aws_cognito_idp_oauth2_user_info_get_0_serialize( @validate_call - def aws_cognito_idp_saml2_idpresponse_get_0( + def aws_cognito_idp_saml2_idpresponse_get( self, _request_timeout: Union[ None, @@ -2415,7 +2415,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_saml2_idpresponse_get_0 + """aws_cognito_idp_saml2_idpresponse_get Cognito SAML 2.0 idpresponse endpoint @@ -2441,7 +2441,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_saml2_idpresponse_get_0_serialize( + _param = self._aws_cognito_idp_saml2_idpresponse_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2462,7 +2462,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0( @validate_call - def aws_cognito_idp_saml2_idpresponse_get_0_with_http_info( + def aws_cognito_idp_saml2_idpresponse_get_with_http_info( self, _request_timeout: Union[ None, @@ -2477,7 +2477,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_saml2_idpresponse_get_0 + """aws_cognito_idp_saml2_idpresponse_get Cognito SAML 2.0 idpresponse endpoint @@ -2503,7 +2503,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_saml2_idpresponse_get_0_serialize( + _param = self._aws_cognito_idp_saml2_idpresponse_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2524,7 +2524,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0_with_http_info( @validate_call - def aws_cognito_idp_saml2_idpresponse_get_0_without_preload_content( + def aws_cognito_idp_saml2_idpresponse_get_without_preload_content( self, _request_timeout: Union[ None, @@ -2539,7 +2539,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_saml2_idpresponse_get_0 + """aws_cognito_idp_saml2_idpresponse_get Cognito SAML 2.0 idpresponse endpoint @@ -2565,7 +2565,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_saml2_idpresponse_get_0_serialize( + _param = self._aws_cognito_idp_saml2_idpresponse_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2581,7 +2581,7 @@ def aws_cognito_idp_saml2_idpresponse_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_saml2_idpresponse_get_0_serialize( + def _aws_cognito_idp_saml2_idpresponse_get_serialize( self, _request_auth, _content_type, @@ -2635,7 +2635,7 @@ def _aws_cognito_idp_saml2_idpresponse_get_0_serialize( @validate_call - def aws_cognito_idp_saml2_idpresponse_post_0( + def aws_cognito_idp_saml2_idpresponse_post( self, _request_timeout: Union[ None, @@ -2650,7 +2650,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_saml2_idpresponse_post_0 + """aws_cognito_idp_saml2_idpresponse_post Cognito SAML 2.0 idpresponse endpoint @@ -2676,7 +2676,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_saml2_idpresponse_post_0_serialize( + _param = self._aws_cognito_idp_saml2_idpresponse_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2697,7 +2697,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0( @validate_call - def aws_cognito_idp_saml2_idpresponse_post_0_with_http_info( + def aws_cognito_idp_saml2_idpresponse_post_with_http_info( self, _request_timeout: Union[ None, @@ -2712,7 +2712,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_saml2_idpresponse_post_0 + """aws_cognito_idp_saml2_idpresponse_post Cognito SAML 2.0 idpresponse endpoint @@ -2738,7 +2738,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_saml2_idpresponse_post_0_serialize( + _param = self._aws_cognito_idp_saml2_idpresponse_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2759,7 +2759,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0_with_http_info( @validate_call - def aws_cognito_idp_saml2_idpresponse_post_0_without_preload_content( + def aws_cognito_idp_saml2_idpresponse_post_without_preload_content( self, _request_timeout: Union[ None, @@ -2774,7 +2774,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_saml2_idpresponse_post_0 + """aws_cognito_idp_saml2_idpresponse_post Cognito SAML 2.0 idpresponse endpoint @@ -2800,7 +2800,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_saml2_idpresponse_post_0_serialize( + _param = self._aws_cognito_idp_saml2_idpresponse_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2816,7 +2816,7 @@ def aws_cognito_idp_saml2_idpresponse_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_saml2_idpresponse_post_0_serialize( + def _aws_cognito_idp_saml2_idpresponse_post_serialize( self, _request_auth, _content_type, @@ -2870,7 +2870,7 @@ def _aws_cognito_idp_saml2_idpresponse_post_0_serialize( @validate_call - def aws_cognito_idp_signup_get_0( + def aws_cognito_idp_signup_get( self, _request_timeout: Union[ None, @@ -2885,7 +2885,7 @@ def aws_cognito_idp_signup_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_signup_get_0 + """aws_cognito_idp_signup_get Cognito signup endpoint @@ -2911,7 +2911,7 @@ def aws_cognito_idp_signup_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_signup_get_0_serialize( + _param = self._aws_cognito_idp_signup_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2932,7 +2932,7 @@ def aws_cognito_idp_signup_get_0( @validate_call - def aws_cognito_idp_signup_get_0_with_http_info( + def aws_cognito_idp_signup_get_with_http_info( self, _request_timeout: Union[ None, @@ -2947,7 +2947,7 @@ def aws_cognito_idp_signup_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_signup_get_0 + """aws_cognito_idp_signup_get Cognito signup endpoint @@ -2973,7 +2973,7 @@ def aws_cognito_idp_signup_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_signup_get_0_serialize( + _param = self._aws_cognito_idp_signup_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2994,7 +2994,7 @@ def aws_cognito_idp_signup_get_0_with_http_info( @validate_call - def aws_cognito_idp_signup_get_0_without_preload_content( + def aws_cognito_idp_signup_get_without_preload_content( self, _request_timeout: Union[ None, @@ -3009,7 +3009,7 @@ def aws_cognito_idp_signup_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_signup_get_0 + """aws_cognito_idp_signup_get Cognito signup endpoint @@ -3035,7 +3035,7 @@ def aws_cognito_idp_signup_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_signup_get_0_serialize( + _param = self._aws_cognito_idp_signup_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3051,7 +3051,7 @@ def aws_cognito_idp_signup_get_0_without_preload_content( return response_data.response - def _aws_cognito_idp_signup_get_0_serialize( + def _aws_cognito_idp_signup_get_serialize( self, _request_auth, _content_type, @@ -3105,7 +3105,7 @@ def _aws_cognito_idp_signup_get_0_serialize( @validate_call - def aws_cognito_idp_signup_post_0( + def aws_cognito_idp_signup_post( self, _request_timeout: Union[ None, @@ -3120,7 +3120,7 @@ def aws_cognito_idp_signup_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_cognito_idp_signup_post_0 + """aws_cognito_idp_signup_post Cognito signup endpoint @@ -3146,7 +3146,7 @@ def aws_cognito_idp_signup_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_signup_post_0_serialize( + _param = self._aws_cognito_idp_signup_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3167,7 +3167,7 @@ def aws_cognito_idp_signup_post_0( @validate_call - def aws_cognito_idp_signup_post_0_with_http_info( + def aws_cognito_idp_signup_post_with_http_info( self, _request_timeout: Union[ None, @@ -3182,7 +3182,7 @@ def aws_cognito_idp_signup_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_cognito_idp_signup_post_0 + """aws_cognito_idp_signup_post Cognito signup endpoint @@ -3208,7 +3208,7 @@ def aws_cognito_idp_signup_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_signup_post_0_serialize( + _param = self._aws_cognito_idp_signup_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3229,7 +3229,7 @@ def aws_cognito_idp_signup_post_0_with_http_info( @validate_call - def aws_cognito_idp_signup_post_0_without_preload_content( + def aws_cognito_idp_signup_post_without_preload_content( self, _request_timeout: Union[ None, @@ -3244,7 +3244,7 @@ def aws_cognito_idp_signup_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_cognito_idp_signup_post_0 + """aws_cognito_idp_signup_post Cognito signup endpoint @@ -3270,7 +3270,7 @@ def aws_cognito_idp_signup_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_cognito_idp_signup_post_0_serialize( + _param = self._aws_cognito_idp_signup_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3286,7 +3286,7 @@ def aws_cognito_idp_signup_post_0_without_preload_content( return response_data.response - def _aws_cognito_idp_signup_post_0_serialize( + def _aws_cognito_idp_signup_post_serialize( self, _request_auth, _content_type, @@ -3340,7 +3340,7 @@ def _aws_cognito_idp_signup_post_0_serialize( @validate_call - def aws_iam_config_get_0( + def aws_iam_config_get( self, _request_timeout: Union[ None, @@ -3355,7 +3355,7 @@ def aws_iam_config_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> IamConfig: - """aws_iam_config_get_0 + """aws_iam_config_get IAM config endpoint @@ -3381,7 +3381,7 @@ def aws_iam_config_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iam_config_get_0_serialize( + _param = self._aws_iam_config_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3403,7 +3403,7 @@ def aws_iam_config_get_0( @validate_call - def aws_iam_config_get_0_with_http_info( + def aws_iam_config_get_with_http_info( self, _request_timeout: Union[ None, @@ -3418,7 +3418,7 @@ def aws_iam_config_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[IamConfig]: - """aws_iam_config_get_0 + """aws_iam_config_get IAM config endpoint @@ -3444,7 +3444,7 @@ def aws_iam_config_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iam_config_get_0_serialize( + _param = self._aws_iam_config_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3466,7 +3466,7 @@ def aws_iam_config_get_0_with_http_info( @validate_call - def aws_iam_config_get_0_without_preload_content( + def aws_iam_config_get_without_preload_content( self, _request_timeout: Union[ None, @@ -3481,7 +3481,7 @@ def aws_iam_config_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_iam_config_get_0 + """aws_iam_config_get IAM config endpoint @@ -3507,7 +3507,7 @@ def aws_iam_config_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iam_config_get_0_serialize( + _param = self._aws_iam_config_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3524,7 +3524,7 @@ def aws_iam_config_get_0_without_preload_content( return response_data.response - def _aws_iam_config_get_0_serialize( + def _aws_iam_config_get_serialize( self, _request_auth, _content_type, @@ -3585,7 +3585,7 @@ def _aws_iam_config_get_0_serialize( @validate_call - def aws_iam_config_post_0( + def aws_iam_config_post( self, iam_config: IamConfig, _request_timeout: Union[ @@ -3601,7 +3601,7 @@ def aws_iam_config_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_iam_config_post_0 + """aws_iam_config_post IAM config endpoint @@ -3629,7 +3629,7 @@ def aws_iam_config_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iam_config_post_0_serialize( + _param = self._aws_iam_config_post_serialize( iam_config=iam_config, _request_auth=_request_auth, _content_type=_content_type, @@ -3653,7 +3653,7 @@ def aws_iam_config_post_0( @validate_call - def aws_iam_config_post_0_with_http_info( + def aws_iam_config_post_with_http_info( self, iam_config: IamConfig, _request_timeout: Union[ @@ -3669,7 +3669,7 @@ def aws_iam_config_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_iam_config_post_0 + """aws_iam_config_post IAM config endpoint @@ -3697,7 +3697,7 @@ def aws_iam_config_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iam_config_post_0_serialize( + _param = self._aws_iam_config_post_serialize( iam_config=iam_config, _request_auth=_request_auth, _content_type=_content_type, @@ -3721,7 +3721,7 @@ def aws_iam_config_post_0_with_http_info( @validate_call - def aws_iam_config_post_0_without_preload_content( + def aws_iam_config_post_without_preload_content( self, iam_config: IamConfig, _request_timeout: Union[ @@ -3737,7 +3737,7 @@ def aws_iam_config_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_iam_config_post_0 + """aws_iam_config_post IAM config endpoint @@ -3765,7 +3765,7 @@ def aws_iam_config_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iam_config_post_0_serialize( + _param = self._aws_iam_config_post_serialize( iam_config=iam_config, _request_auth=_request_auth, _content_type=_content_type, @@ -3784,7 +3784,7 @@ def aws_iam_config_post_0_without_preload_content( return response_data.response - def _aws_iam_config_post_0_serialize( + def _aws_iam_config_post_serialize( self, iam_config, _request_auth, @@ -3854,7 +3854,7 @@ def _aws_iam_config_post_0_serialize( @validate_call - def aws_iot_local_stack_io_t_root_ca_pem_get_0( + def aws_iot_local_stack_io_t_root_ca_pem_get( self, _request_timeout: Union[ None, @@ -3869,7 +3869,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """aws_iot_local_stack_io_t_root_ca_pem_get_0 + """aws_iot_local_stack_io_t_root_ca_pem_get Retrieve certificate for LocalStack IoT root certificate authority @@ -3895,7 +3895,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iot_local_stack_io_t_root_ca_pem_get_0_serialize( + _param = self._aws_iot_local_stack_io_t_root_ca_pem_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3916,7 +3916,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0( @validate_call - def aws_iot_local_stack_io_t_root_ca_pem_get_0_with_http_info( + def aws_iot_local_stack_io_t_root_ca_pem_get_with_http_info( self, _request_timeout: Union[ None, @@ -3931,7 +3931,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """aws_iot_local_stack_io_t_root_ca_pem_get_0 + """aws_iot_local_stack_io_t_root_ca_pem_get Retrieve certificate for LocalStack IoT root certificate authority @@ -3957,7 +3957,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iot_local_stack_io_t_root_ca_pem_get_0_serialize( + _param = self._aws_iot_local_stack_io_t_root_ca_pem_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3978,7 +3978,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0_with_http_info( @validate_call - def aws_iot_local_stack_io_t_root_ca_pem_get_0_without_preload_content( + def aws_iot_local_stack_io_t_root_ca_pem_get_without_preload_content( self, _request_timeout: Union[ None, @@ -3993,7 +3993,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_iot_local_stack_io_t_root_ca_pem_get_0 + """aws_iot_local_stack_io_t_root_ca_pem_get Retrieve certificate for LocalStack IoT root certificate authority @@ -4019,7 +4019,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_iot_local_stack_io_t_root_ca_pem_get_0_serialize( + _param = self._aws_iot_local_stack_io_t_root_ca_pem_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -4035,7 +4035,7 @@ def aws_iot_local_stack_io_t_root_ca_pem_get_0_without_preload_content( return response_data.response - def _aws_iot_local_stack_io_t_root_ca_pem_get_0_serialize( + def _aws_iot_local_stack_io_t_root_ca_pem_get_serialize( self, _request_auth, _content_type, @@ -4089,7 +4089,7 @@ def _aws_iot_local_stack_io_t_root_ca_pem_get_0_serialize( @validate_call - def aws_pinpoint_application_id_reference_id_get_0( + def aws_pinpoint_application_id_reference_id_get( self, application_id: Annotated[StrictStr, Field(description="Pinpoint application ID")], reference_id: Annotated[StrictStr, Field(description="Reference ID that was used in SentOTPMessage")], @@ -4106,7 +4106,7 @@ def aws_pinpoint_application_id_reference_id_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> AwsPinpointApplicationIdReferenceIdGet200Response: - """aws_pinpoint_application_id_reference_id_get_0 + """aws_pinpoint_application_id_reference_id_get Retrieve Pinpoint OTP code @@ -4136,7 +4136,7 @@ def aws_pinpoint_application_id_reference_id_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_pinpoint_application_id_reference_id_get_0_serialize( + _param = self._aws_pinpoint_application_id_reference_id_get_serialize( application_id=application_id, reference_id=reference_id, _request_auth=_request_auth, @@ -4160,7 +4160,7 @@ def aws_pinpoint_application_id_reference_id_get_0( @validate_call - def aws_pinpoint_application_id_reference_id_get_0_with_http_info( + def aws_pinpoint_application_id_reference_id_get_with_http_info( self, application_id: Annotated[StrictStr, Field(description="Pinpoint application ID")], reference_id: Annotated[StrictStr, Field(description="Reference ID that was used in SentOTPMessage")], @@ -4177,7 +4177,7 @@ def aws_pinpoint_application_id_reference_id_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[AwsPinpointApplicationIdReferenceIdGet200Response]: - """aws_pinpoint_application_id_reference_id_get_0 + """aws_pinpoint_application_id_reference_id_get Retrieve Pinpoint OTP code @@ -4207,7 +4207,7 @@ def aws_pinpoint_application_id_reference_id_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_pinpoint_application_id_reference_id_get_0_serialize( + _param = self._aws_pinpoint_application_id_reference_id_get_serialize( application_id=application_id, reference_id=reference_id, _request_auth=_request_auth, @@ -4231,7 +4231,7 @@ def aws_pinpoint_application_id_reference_id_get_0_with_http_info( @validate_call - def aws_pinpoint_application_id_reference_id_get_0_without_preload_content( + def aws_pinpoint_application_id_reference_id_get_without_preload_content( self, application_id: Annotated[StrictStr, Field(description="Pinpoint application ID")], reference_id: Annotated[StrictStr, Field(description="Reference ID that was used in SentOTPMessage")], @@ -4248,7 +4248,7 @@ def aws_pinpoint_application_id_reference_id_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """aws_pinpoint_application_id_reference_id_get_0 + """aws_pinpoint_application_id_reference_id_get Retrieve Pinpoint OTP code @@ -4278,7 +4278,7 @@ def aws_pinpoint_application_id_reference_id_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._aws_pinpoint_application_id_reference_id_get_0_serialize( + _param = self._aws_pinpoint_application_id_reference_id_get_serialize( application_id=application_id, reference_id=reference_id, _request_auth=_request_auth, @@ -4297,7 +4297,7 @@ def aws_pinpoint_application_id_reference_id_get_0_without_preload_content( return response_data.response - def _aws_pinpoint_application_id_reference_id_get_0_serialize( + def _aws_pinpoint_application_id_reference_id_get_serialize( self, application_id, reference_id, diff --git a/packages/localstack-sdk-generated/localstack/sdk/api/chaos_api.py b/packages/localstack-sdk-generated/localstack/sdk/api/chaos_api.py index a26c24b..2aaefea 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api/chaos_api.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api/chaos_api.py @@ -40,7 +40,7 @@ def __init__(self, api_client=None) -> None: @validate_call - def add_fault_rules_0( + def add_fault_rules( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -84,7 +84,7 @@ def add_fault_rules_0( :return: Returns the result object. """ # noqa: E501 - _param = self._add_fault_rules_0_serialize( + _param = self._add_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -107,7 +107,7 @@ def add_fault_rules_0( @validate_call - def add_fault_rules_0_with_http_info( + def add_fault_rules_with_http_info( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -151,7 +151,7 @@ def add_fault_rules_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._add_fault_rules_0_serialize( + _param = self._add_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -174,7 +174,7 @@ def add_fault_rules_0_with_http_info( @validate_call - def add_fault_rules_0_without_preload_content( + def add_fault_rules_without_preload_content( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -218,7 +218,7 @@ def add_fault_rules_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._add_fault_rules_0_serialize( + _param = self._add_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -236,7 +236,7 @@ def add_fault_rules_0_without_preload_content( return response_data.response - def _add_fault_rules_0_serialize( + def _add_fault_rules_serialize( self, fault_rule, _request_auth, @@ -314,7 +314,7 @@ def _add_fault_rules_0_serialize( @validate_call - def delete_fault_rules_0( + def delete_fault_rules( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -358,7 +358,7 @@ def delete_fault_rules_0( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_fault_rules_0_serialize( + _param = self._delete_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -381,7 +381,7 @@ def delete_fault_rules_0( @validate_call - def delete_fault_rules_0_with_http_info( + def delete_fault_rules_with_http_info( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -425,7 +425,7 @@ def delete_fault_rules_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_fault_rules_0_serialize( + _param = self._delete_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -448,7 +448,7 @@ def delete_fault_rules_0_with_http_info( @validate_call - def delete_fault_rules_0_without_preload_content( + def delete_fault_rules_without_preload_content( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -492,7 +492,7 @@ def delete_fault_rules_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_fault_rules_0_serialize( + _param = self._delete_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -510,7 +510,7 @@ def delete_fault_rules_0_without_preload_content( return response_data.response - def _delete_fault_rules_0_serialize( + def _delete_fault_rules_serialize( self, fault_rule, _request_auth, @@ -588,7 +588,7 @@ def _delete_fault_rules_0_serialize( @validate_call - def get_fault_rules_0( + def get_fault_rules( self, _request_timeout: Union[ None, @@ -629,7 +629,7 @@ def get_fault_rules_0( :return: Returns the result object. """ # noqa: E501 - _param = self._get_fault_rules_0_serialize( + _param = self._get_fault_rules_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -651,7 +651,7 @@ def get_fault_rules_0( @validate_call - def get_fault_rules_0_with_http_info( + def get_fault_rules_with_http_info( self, _request_timeout: Union[ None, @@ -692,7 +692,7 @@ def get_fault_rules_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._get_fault_rules_0_serialize( + _param = self._get_fault_rules_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -714,7 +714,7 @@ def get_fault_rules_0_with_http_info( @validate_call - def get_fault_rules_0_without_preload_content( + def get_fault_rules_without_preload_content( self, _request_timeout: Union[ None, @@ -755,7 +755,7 @@ def get_fault_rules_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._get_fault_rules_0_serialize( + _param = self._get_fault_rules_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -772,7 +772,7 @@ def get_fault_rules_0_without_preload_content( return response_data.response - def _get_fault_rules_0_serialize( + def _get_fault_rules_serialize( self, _request_auth, _content_type, @@ -833,7 +833,7 @@ def _get_fault_rules_0_serialize( @validate_call - def get_network_effects_0( + def get_network_effects( self, _request_timeout: Union[ None, @@ -874,7 +874,7 @@ def get_network_effects_0( :return: Returns the result object. """ # noqa: E501 - _param = self._get_network_effects_0_serialize( + _param = self._get_network_effects_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -896,7 +896,7 @@ def get_network_effects_0( @validate_call - def get_network_effects_0_with_http_info( + def get_network_effects_with_http_info( self, _request_timeout: Union[ None, @@ -937,7 +937,7 @@ def get_network_effects_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._get_network_effects_0_serialize( + _param = self._get_network_effects_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -959,7 +959,7 @@ def get_network_effects_0_with_http_info( @validate_call - def get_network_effects_0_without_preload_content( + def get_network_effects_without_preload_content( self, _request_timeout: Union[ None, @@ -1000,7 +1000,7 @@ def get_network_effects_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._get_network_effects_0_serialize( + _param = self._get_network_effects_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1017,7 +1017,7 @@ def get_network_effects_0_without_preload_content( return response_data.response - def _get_network_effects_0_serialize( + def _get_network_effects_serialize( self, _request_auth, _content_type, @@ -1078,7 +1078,7 @@ def _get_network_effects_0_serialize( @validate_call - def set_fault_rules_0( + def set_fault_rules( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -1122,7 +1122,7 @@ def set_fault_rules_0( :return: Returns the result object. """ # noqa: E501 - _param = self._set_fault_rules_0_serialize( + _param = self._set_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -1145,7 +1145,7 @@ def set_fault_rules_0( @validate_call - def set_fault_rules_0_with_http_info( + def set_fault_rules_with_http_info( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -1189,7 +1189,7 @@ def set_fault_rules_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._set_fault_rules_0_serialize( + _param = self._set_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -1212,7 +1212,7 @@ def set_fault_rules_0_with_http_info( @validate_call - def set_fault_rules_0_without_preload_content( + def set_fault_rules_without_preload_content( self, fault_rule: List[FaultRule], _request_timeout: Union[ @@ -1256,7 +1256,7 @@ def set_fault_rules_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._set_fault_rules_0_serialize( + _param = self._set_fault_rules_serialize( fault_rule=fault_rule, _request_auth=_request_auth, _content_type=_content_type, @@ -1274,7 +1274,7 @@ def set_fault_rules_0_without_preload_content( return response_data.response - def _set_fault_rules_0_serialize( + def _set_fault_rules_serialize( self, fault_rule, _request_auth, @@ -1352,7 +1352,7 @@ def _set_fault_rules_0_serialize( @validate_call - def set_network_effects_0( + def set_network_effects( self, network_effects_config: NetworkEffectsConfig, _request_timeout: Union[ @@ -1396,7 +1396,7 @@ def set_network_effects_0( :return: Returns the result object. """ # noqa: E501 - _param = self._set_network_effects_0_serialize( + _param = self._set_network_effects_serialize( network_effects_config=network_effects_config, _request_auth=_request_auth, _content_type=_content_type, @@ -1419,7 +1419,7 @@ def set_network_effects_0( @validate_call - def set_network_effects_0_with_http_info( + def set_network_effects_with_http_info( self, network_effects_config: NetworkEffectsConfig, _request_timeout: Union[ @@ -1463,7 +1463,7 @@ def set_network_effects_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._set_network_effects_0_serialize( + _param = self._set_network_effects_serialize( network_effects_config=network_effects_config, _request_auth=_request_auth, _content_type=_content_type, @@ -1486,7 +1486,7 @@ def set_network_effects_0_with_http_info( @validate_call - def set_network_effects_0_without_preload_content( + def set_network_effects_without_preload_content( self, network_effects_config: NetworkEffectsConfig, _request_timeout: Union[ @@ -1530,7 +1530,7 @@ def set_network_effects_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._set_network_effects_0_serialize( + _param = self._set_network_effects_serialize( network_effects_config=network_effects_config, _request_auth=_request_auth, _content_type=_content_type, @@ -1548,7 +1548,7 @@ def set_network_effects_0_without_preload_content( return response_data.response - def _set_network_effects_0_serialize( + def _set_network_effects_serialize( self, network_effects_config, _request_auth, diff --git a/packages/localstack-sdk-generated/localstack/sdk/api/pods_api.py b/packages/localstack-sdk-generated/localstack/sdk/api/pods_api.py index 15415e5..3c9ceff 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api/pods_api.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api/pods_api.py @@ -48,7 +48,7 @@ def __init__(self, api_client=None) -> None: @validate_call - def create_remote_0( + def create_remote( self, name: Annotated[StrictStr, Field(description="The name of the new remote.")], create_remote_request: CreateRemoteRequest, @@ -95,7 +95,7 @@ def create_remote_0( :return: Returns the result object. """ # noqa: E501 - _param = self._create_remote_0_serialize( + _param = self._create_remote_serialize( name=name, create_remote_request=create_remote_request, _request_auth=_request_auth, @@ -119,7 +119,7 @@ def create_remote_0( @validate_call - def create_remote_0_with_http_info( + def create_remote_with_http_info( self, name: Annotated[StrictStr, Field(description="The name of the new remote.")], create_remote_request: CreateRemoteRequest, @@ -166,7 +166,7 @@ def create_remote_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._create_remote_0_serialize( + _param = self._create_remote_serialize( name=name, create_remote_request=create_remote_request, _request_auth=_request_auth, @@ -190,7 +190,7 @@ def create_remote_0_with_http_info( @validate_call - def create_remote_0_without_preload_content( + def create_remote_without_preload_content( self, name: Annotated[StrictStr, Field(description="The name of the new remote.")], create_remote_request: CreateRemoteRequest, @@ -237,7 +237,7 @@ def create_remote_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._create_remote_0_serialize( + _param = self._create_remote_serialize( name=name, create_remote_request=create_remote_request, _request_auth=_request_auth, @@ -256,7 +256,7 @@ def create_remote_0_without_preload_content( return response_data.response - def _create_remote_0_serialize( + def _create_remote_serialize( self, name, create_remote_request, @@ -329,7 +329,7 @@ def _create_remote_0_serialize( @validate_call - def delete_pod_0( + def delete_pod( self, name: StrictStr, local: Annotated[Optional[StrictStr], Field(description="If true, the pod will be deleted only from the local storage")] = None, @@ -348,7 +348,7 @@ def delete_pod_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """delete_pod_0 + """delete_pod :param name: (required) @@ -381,7 +381,7 @@ def delete_pod_0( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_pod_0_serialize( + _param = self._delete_pod_serialize( name=name, local=local, x_localstack_state_secret=x_localstack_state_secret, @@ -408,7 +408,7 @@ def delete_pod_0( @validate_call - def delete_pod_0_with_http_info( + def delete_pod_with_http_info( self, name: StrictStr, local: Annotated[Optional[StrictStr], Field(description="If true, the pod will be deleted only from the local storage")] = None, @@ -427,7 +427,7 @@ def delete_pod_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """delete_pod_0 + """delete_pod :param name: (required) @@ -460,7 +460,7 @@ def delete_pod_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_pod_0_serialize( + _param = self._delete_pod_serialize( name=name, local=local, x_localstack_state_secret=x_localstack_state_secret, @@ -487,7 +487,7 @@ def delete_pod_0_with_http_info( @validate_call - def delete_pod_0_without_preload_content( + def delete_pod_without_preload_content( self, name: StrictStr, local: Annotated[Optional[StrictStr], Field(description="If true, the pod will be deleted only from the local storage")] = None, @@ -506,7 +506,7 @@ def delete_pod_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """delete_pod_0 + """delete_pod :param name: (required) @@ -539,7 +539,7 @@ def delete_pod_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_pod_0_serialize( + _param = self._delete_pod_serialize( name=name, local=local, x_localstack_state_secret=x_localstack_state_secret, @@ -561,7 +561,7 @@ def delete_pod_0_without_preload_content( return response_data.response - def _delete_pod_0_serialize( + def _delete_pod_serialize( self, name, local, @@ -642,7 +642,7 @@ def _delete_pod_0_serialize( @validate_call - def delete_remote_0( + def delete_remote( self, name: Annotated[StrictStr, Field(description="The name of the remote to delete.")], _request_timeout: Union[ @@ -686,7 +686,7 @@ def delete_remote_0( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_remote_0_serialize( + _param = self._delete_remote_serialize( name=name, _request_auth=_request_auth, _content_type=_content_type, @@ -709,7 +709,7 @@ def delete_remote_0( @validate_call - def delete_remote_0_with_http_info( + def delete_remote_with_http_info( self, name: Annotated[StrictStr, Field(description="The name of the remote to delete.")], _request_timeout: Union[ @@ -753,7 +753,7 @@ def delete_remote_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_remote_0_serialize( + _param = self._delete_remote_serialize( name=name, _request_auth=_request_auth, _content_type=_content_type, @@ -776,7 +776,7 @@ def delete_remote_0_with_http_info( @validate_call - def delete_remote_0_without_preload_content( + def delete_remote_without_preload_content( self, name: Annotated[StrictStr, Field(description="The name of the remote to delete.")], _request_timeout: Union[ @@ -820,7 +820,7 @@ def delete_remote_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._delete_remote_0_serialize( + _param = self._delete_remote_serialize( name=name, _request_auth=_request_auth, _content_type=_content_type, @@ -838,7 +838,7 @@ def delete_remote_0_without_preload_content( return response_data.response - def _delete_remote_0_serialize( + def _delete_remote_serialize( self, name, _request_auth, @@ -895,7 +895,7 @@ def _delete_remote_0_serialize( @validate_call - def get_pod_versions_0( + def get_pod_versions( self, name: Annotated[StrictStr, Field(description="Cloud pod name")], x_localstack_state_secret: Annotated[Optional[StrictStr], Field(description="A secret token for authenticating the request against the platform")] = None, @@ -913,7 +913,7 @@ def get_pod_versions_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> PodVersions: - """get_pod_versions_0 + """get_pod_versions List versions for a cloud pod @@ -945,7 +945,7 @@ def get_pod_versions_0( :return: Returns the result object. """ # noqa: E501 - _param = self._get_pod_versions_0_serialize( + _param = self._get_pod_versions_serialize( name=name, x_localstack_state_secret=x_localstack_state_secret, remote_config=remote_config, @@ -970,7 +970,7 @@ def get_pod_versions_0( @validate_call - def get_pod_versions_0_with_http_info( + def get_pod_versions_with_http_info( self, name: Annotated[StrictStr, Field(description="Cloud pod name")], x_localstack_state_secret: Annotated[Optional[StrictStr], Field(description="A secret token for authenticating the request against the platform")] = None, @@ -988,7 +988,7 @@ def get_pod_versions_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[PodVersions]: - """get_pod_versions_0 + """get_pod_versions List versions for a cloud pod @@ -1020,7 +1020,7 @@ def get_pod_versions_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._get_pod_versions_0_serialize( + _param = self._get_pod_versions_serialize( name=name, x_localstack_state_secret=x_localstack_state_secret, remote_config=remote_config, @@ -1045,7 +1045,7 @@ def get_pod_versions_0_with_http_info( @validate_call - def get_pod_versions_0_without_preload_content( + def get_pod_versions_without_preload_content( self, name: Annotated[StrictStr, Field(description="Cloud pod name")], x_localstack_state_secret: Annotated[Optional[StrictStr], Field(description="A secret token for authenticating the request against the platform")] = None, @@ -1063,7 +1063,7 @@ def get_pod_versions_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """get_pod_versions_0 + """get_pod_versions List versions for a cloud pod @@ -1095,7 +1095,7 @@ def get_pod_versions_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._get_pod_versions_0_serialize( + _param = self._get_pod_versions_serialize( name=name, x_localstack_state_secret=x_localstack_state_secret, remote_config=remote_config, @@ -1115,7 +1115,7 @@ def get_pod_versions_0_without_preload_content( return response_data.response - def _get_pod_versions_0_serialize( + def _get_pod_versions_serialize( self, name, x_localstack_state_secret, @@ -1198,7 +1198,7 @@ def _get_pod_versions_0_serialize( @validate_call - def get_remote_0( + def get_remote( self, name: Annotated[StrictStr, Field(description="The name of the remote.")], _request_timeout: Union[ @@ -1242,7 +1242,7 @@ def get_remote_0( :return: Returns the result object. """ # noqa: E501 - _param = self._get_remote_0_serialize( + _param = self._get_remote_serialize( name=name, _request_auth=_request_auth, _content_type=_content_type, @@ -1265,7 +1265,7 @@ def get_remote_0( @validate_call - def get_remote_0_with_http_info( + def get_remote_with_http_info( self, name: Annotated[StrictStr, Field(description="The name of the remote.")], _request_timeout: Union[ @@ -1309,7 +1309,7 @@ def get_remote_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._get_remote_0_serialize( + _param = self._get_remote_serialize( name=name, _request_auth=_request_auth, _content_type=_content_type, @@ -1332,7 +1332,7 @@ def get_remote_0_with_http_info( @validate_call - def get_remote_0_without_preload_content( + def get_remote_without_preload_content( self, name: Annotated[StrictStr, Field(description="The name of the remote.")], _request_timeout: Union[ @@ -1376,7 +1376,7 @@ def get_remote_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._get_remote_0_serialize( + _param = self._get_remote_serialize( name=name, _request_auth=_request_auth, _content_type=_content_type, @@ -1394,7 +1394,7 @@ def get_remote_0_without_preload_content( return response_data.response - def _get_remote_0_serialize( + def _get_remote_serialize( self, name, _request_auth, @@ -1458,7 +1458,7 @@ def _get_remote_0_serialize( @validate_call - def list_pods_0( + def list_pods( self, creator: Annotated[Optional[StrictStr], Field(description="User ID of the pod creator. Special values like `me` are accepted.")] = None, remote_config: Optional[RemoteConfig] = None, @@ -1475,7 +1475,7 @@ def list_pods_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> PodList: - """list_pods_0 + """list_pods List cloud pods @@ -1505,7 +1505,7 @@ def list_pods_0( :return: Returns the result object. """ # noqa: E501 - _param = self._list_pods_0_serialize( + _param = self._list_pods_serialize( creator=creator, remote_config=remote_config, _request_auth=_request_auth, @@ -1529,7 +1529,7 @@ def list_pods_0( @validate_call - def list_pods_0_with_http_info( + def list_pods_with_http_info( self, creator: Annotated[Optional[StrictStr], Field(description="User ID of the pod creator. Special values like `me` are accepted.")] = None, remote_config: Optional[RemoteConfig] = None, @@ -1546,7 +1546,7 @@ def list_pods_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[PodList]: - """list_pods_0 + """list_pods List cloud pods @@ -1576,7 +1576,7 @@ def list_pods_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._list_pods_0_serialize( + _param = self._list_pods_serialize( creator=creator, remote_config=remote_config, _request_auth=_request_auth, @@ -1600,7 +1600,7 @@ def list_pods_0_with_http_info( @validate_call - def list_pods_0_without_preload_content( + def list_pods_without_preload_content( self, creator: Annotated[Optional[StrictStr], Field(description="User ID of the pod creator. Special values like `me` are accepted.")] = None, remote_config: Optional[RemoteConfig] = None, @@ -1617,7 +1617,7 @@ def list_pods_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """list_pods_0 + """list_pods List cloud pods @@ -1647,7 +1647,7 @@ def list_pods_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._list_pods_0_serialize( + _param = self._list_pods_serialize( creator=creator, remote_config=remote_config, _request_auth=_request_auth, @@ -1666,7 +1666,7 @@ def list_pods_0_without_preload_content( return response_data.response - def _list_pods_0_serialize( + def _list_pods_serialize( self, creator, remote_config, @@ -1748,7 +1748,7 @@ def _list_pods_0_serialize( @validate_call - def list_remotes_0( + def list_remotes( self, _request_timeout: Union[ None, @@ -1763,7 +1763,7 @@ def list_remotes_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ListRemotes200Response: - """list_remotes_0 + """list_remotes Retrieves a list of all configured remotes. @@ -1789,7 +1789,7 @@ def list_remotes_0( :return: Returns the result object. """ # noqa: E501 - _param = self._list_remotes_0_serialize( + _param = self._list_remotes_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1811,7 +1811,7 @@ def list_remotes_0( @validate_call - def list_remotes_0_with_http_info( + def list_remotes_with_http_info( self, _request_timeout: Union[ None, @@ -1826,7 +1826,7 @@ def list_remotes_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[ListRemotes200Response]: - """list_remotes_0 + """list_remotes Retrieves a list of all configured remotes. @@ -1852,7 +1852,7 @@ def list_remotes_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._list_remotes_0_serialize( + _param = self._list_remotes_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1874,7 +1874,7 @@ def list_remotes_0_with_http_info( @validate_call - def list_remotes_0_without_preload_content( + def list_remotes_without_preload_content( self, _request_timeout: Union[ None, @@ -1889,7 +1889,7 @@ def list_remotes_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """list_remotes_0 + """list_remotes Retrieves a list of all configured remotes. @@ -1915,7 +1915,7 @@ def list_remotes_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._list_remotes_0_serialize( + _param = self._list_remotes_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1932,7 +1932,7 @@ def list_remotes_0_without_preload_content( return response_data.response - def _list_remotes_0_serialize( + def _list_remotes_serialize( self, _request_auth, _content_type, @@ -1993,7 +1993,7 @@ def _list_remotes_0_serialize( @validate_call - def load_pod_0( + def load_pod( self, name: Annotated[StrictStr, Field(description="The name of the Cloud Pod to be loaded into the runtime")], version: Annotated[Optional[StrictStr], Field(description="The version of the Cloud Pod to be loaded into the runtime")] = None, @@ -2014,7 +2014,7 @@ def load_pod_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """load_pod_0 + """load_pod Load a cloud pod version @@ -2052,7 +2052,7 @@ def load_pod_0( :return: Returns the result object. """ # noqa: E501 - _param = self._load_pod_0_serialize( + _param = self._load_pod_serialize( name=name, version=version, merge=merge, @@ -2080,7 +2080,7 @@ def load_pod_0( @validate_call - def load_pod_0_with_http_info( + def load_pod_with_http_info( self, name: Annotated[StrictStr, Field(description="The name of the Cloud Pod to be loaded into the runtime")], version: Annotated[Optional[StrictStr], Field(description="The version of the Cloud Pod to be loaded into the runtime")] = None, @@ -2101,7 +2101,7 @@ def load_pod_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """load_pod_0 + """load_pod Load a cloud pod version @@ -2139,7 +2139,7 @@ def load_pod_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._load_pod_0_serialize( + _param = self._load_pod_serialize( name=name, version=version, merge=merge, @@ -2167,7 +2167,7 @@ def load_pod_0_with_http_info( @validate_call - def load_pod_0_without_preload_content( + def load_pod_without_preload_content( self, name: Annotated[StrictStr, Field(description="The name of the Cloud Pod to be loaded into the runtime")], version: Annotated[Optional[StrictStr], Field(description="The version of the Cloud Pod to be loaded into the runtime")] = None, @@ -2188,7 +2188,7 @@ def load_pod_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """load_pod_0 + """load_pod Load a cloud pod version @@ -2226,7 +2226,7 @@ def load_pod_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._load_pod_0_serialize( + _param = self._load_pod_serialize( name=name, version=version, merge=merge, @@ -2249,7 +2249,7 @@ def load_pod_0_without_preload_content( return response_data.response - def _load_pod_0_serialize( + def _load_pod_serialize( self, name, version, @@ -2347,7 +2347,7 @@ def _load_pod_0_serialize( @validate_call - def localstack_pods_environment_get_0( + def localstack_pods_environment_get( self, _request_timeout: Union[ None, @@ -2362,7 +2362,7 @@ def localstack_pods_environment_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> LocalstackPodsEnvironmentGet200Response: - """localstack_pods_environment_get_0 + """localstack_pods_environment_get Retrieves some information about the current environment, like LocalStack and Moto versions. @@ -2388,7 +2388,7 @@ def localstack_pods_environment_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_environment_get_0_serialize( + _param = self._localstack_pods_environment_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2410,7 +2410,7 @@ def localstack_pods_environment_get_0( @validate_call - def localstack_pods_environment_get_0_with_http_info( + def localstack_pods_environment_get_with_http_info( self, _request_timeout: Union[ None, @@ -2425,7 +2425,7 @@ def localstack_pods_environment_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[LocalstackPodsEnvironmentGet200Response]: - """localstack_pods_environment_get_0 + """localstack_pods_environment_get Retrieves some information about the current environment, like LocalStack and Moto versions. @@ -2451,7 +2451,7 @@ def localstack_pods_environment_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_environment_get_0_serialize( + _param = self._localstack_pods_environment_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2473,7 +2473,7 @@ def localstack_pods_environment_get_0_with_http_info( @validate_call - def localstack_pods_environment_get_0_without_preload_content( + def localstack_pods_environment_get_without_preload_content( self, _request_timeout: Union[ None, @@ -2488,7 +2488,7 @@ def localstack_pods_environment_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_pods_environment_get_0 + """localstack_pods_environment_get Retrieves some information about the current environment, like LocalStack and Moto versions. @@ -2514,7 +2514,7 @@ def localstack_pods_environment_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_environment_get_0_serialize( + _param = self._localstack_pods_environment_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2531,7 +2531,7 @@ def localstack_pods_environment_get_0_without_preload_content( return response_data.response - def _localstack_pods_environment_get_0_serialize( + def _localstack_pods_environment_get_serialize( self, _request_auth, _content_type, @@ -2592,7 +2592,7 @@ def _localstack_pods_environment_get_0_serialize( @validate_call - def localstack_pods_state_get_0( + def localstack_pods_state_get( self, pod_name: Annotated[Optional[StrictStr], Field(description="The name of the pod to save. Defaults to a unique name based on the current timestamp.")] = None, services: Annotated[Optional[StrictStr], Field(description="Comma-separated list of service names to include in the exported state.")] = None, @@ -2609,7 +2609,7 @@ def localstack_pods_state_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> bytearray: - """localstack_pods_state_get_0 + """localstack_pods_state_get Exports the current state of the LocalStack container into a zip file. @@ -2639,7 +2639,7 @@ def localstack_pods_state_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_get_0_serialize( + _param = self._localstack_pods_state_get_serialize( pod_name=pod_name, services=services, _request_auth=_request_auth, @@ -2663,7 +2663,7 @@ def localstack_pods_state_get_0( @validate_call - def localstack_pods_state_get_0_with_http_info( + def localstack_pods_state_get_with_http_info( self, pod_name: Annotated[Optional[StrictStr], Field(description="The name of the pod to save. Defaults to a unique name based on the current timestamp.")] = None, services: Annotated[Optional[StrictStr], Field(description="Comma-separated list of service names to include in the exported state.")] = None, @@ -2680,7 +2680,7 @@ def localstack_pods_state_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[bytearray]: - """localstack_pods_state_get_0 + """localstack_pods_state_get Exports the current state of the LocalStack container into a zip file. @@ -2710,7 +2710,7 @@ def localstack_pods_state_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_get_0_serialize( + _param = self._localstack_pods_state_get_serialize( pod_name=pod_name, services=services, _request_auth=_request_auth, @@ -2734,7 +2734,7 @@ def localstack_pods_state_get_0_with_http_info( @validate_call - def localstack_pods_state_get_0_without_preload_content( + def localstack_pods_state_get_without_preload_content( self, pod_name: Annotated[Optional[StrictStr], Field(description="The name of the pod to save. Defaults to a unique name based on the current timestamp.")] = None, services: Annotated[Optional[StrictStr], Field(description="Comma-separated list of service names to include in the exported state.")] = None, @@ -2751,7 +2751,7 @@ def localstack_pods_state_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_pods_state_get_0 + """localstack_pods_state_get Exports the current state of the LocalStack container into a zip file. @@ -2781,7 +2781,7 @@ def localstack_pods_state_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_get_0_serialize( + _param = self._localstack_pods_state_get_serialize( pod_name=pod_name, services=services, _request_auth=_request_auth, @@ -2800,7 +2800,7 @@ def localstack_pods_state_get_0_without_preload_content( return response_data.response - def _localstack_pods_state_get_0_serialize( + def _localstack_pods_state_get_serialize( self, pod_name, services, @@ -2871,7 +2871,7 @@ def _localstack_pods_state_get_0_serialize( @validate_call - def localstack_pods_state_metamodel_get_0( + def localstack_pods_state_metamodel_get( self, _request_timeout: Union[ None, @@ -2886,7 +2886,7 @@ def localstack_pods_state_metamodel_get_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """localstack_pods_state_metamodel_get_0 + """localstack_pods_state_metamodel_get Extract a metamodel representing the state of the current LocalStack session @@ -2912,7 +2912,7 @@ def localstack_pods_state_metamodel_get_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_metamodel_get_0_serialize( + _param = self._localstack_pods_state_metamodel_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2934,7 +2934,7 @@ def localstack_pods_state_metamodel_get_0( @validate_call - def localstack_pods_state_metamodel_get_0_with_http_info( + def localstack_pods_state_metamodel_get_with_http_info( self, _request_timeout: Union[ None, @@ -2949,7 +2949,7 @@ def localstack_pods_state_metamodel_get_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """localstack_pods_state_metamodel_get_0 + """localstack_pods_state_metamodel_get Extract a metamodel representing the state of the current LocalStack session @@ -2975,7 +2975,7 @@ def localstack_pods_state_metamodel_get_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_metamodel_get_0_serialize( + _param = self._localstack_pods_state_metamodel_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -2997,7 +2997,7 @@ def localstack_pods_state_metamodel_get_0_with_http_info( @validate_call - def localstack_pods_state_metamodel_get_0_without_preload_content( + def localstack_pods_state_metamodel_get_without_preload_content( self, _request_timeout: Union[ None, @@ -3012,7 +3012,7 @@ def localstack_pods_state_metamodel_get_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_pods_state_metamodel_get_0 + """localstack_pods_state_metamodel_get Extract a metamodel representing the state of the current LocalStack session @@ -3038,7 +3038,7 @@ def localstack_pods_state_metamodel_get_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_metamodel_get_0_serialize( + _param = self._localstack_pods_state_metamodel_get_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -3055,7 +3055,7 @@ def localstack_pods_state_metamodel_get_0_without_preload_content( return response_data.response - def _localstack_pods_state_metamodel_get_0_serialize( + def _localstack_pods_state_metamodel_get_serialize( self, _request_auth, _content_type, @@ -3116,7 +3116,7 @@ def _localstack_pods_state_metamodel_get_0_serialize( @validate_call - def localstack_pods_state_post_0( + def localstack_pods_state_post( self, pod: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], _request_timeout: Union[ @@ -3132,7 +3132,7 @@ def localstack_pods_state_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """localstack_pods_state_post_0 + """localstack_pods_state_post Loads a pod state from a zip file and restores its services. @@ -3160,7 +3160,7 @@ def localstack_pods_state_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_post_0_serialize( + _param = self._localstack_pods_state_post_serialize( pod=pod, _request_auth=_request_auth, _content_type=_content_type, @@ -3184,7 +3184,7 @@ def localstack_pods_state_post_0( @validate_call - def localstack_pods_state_post_0_with_http_info( + def localstack_pods_state_post_with_http_info( self, pod: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], _request_timeout: Union[ @@ -3200,7 +3200,7 @@ def localstack_pods_state_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """localstack_pods_state_post_0 + """localstack_pods_state_post Loads a pod state from a zip file and restores its services. @@ -3228,7 +3228,7 @@ def localstack_pods_state_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_post_0_serialize( + _param = self._localstack_pods_state_post_serialize( pod=pod, _request_auth=_request_auth, _content_type=_content_type, @@ -3252,7 +3252,7 @@ def localstack_pods_state_post_0_with_http_info( @validate_call - def localstack_pods_state_post_0_without_preload_content( + def localstack_pods_state_post_without_preload_content( self, pod: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], _request_timeout: Union[ @@ -3268,7 +3268,7 @@ def localstack_pods_state_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_pods_state_post_0 + """localstack_pods_state_post Loads a pod state from a zip file and restores its services. @@ -3296,7 +3296,7 @@ def localstack_pods_state_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_pods_state_post_0_serialize( + _param = self._localstack_pods_state_post_serialize( pod=pod, _request_auth=_request_auth, _content_type=_content_type, @@ -3315,7 +3315,7 @@ def localstack_pods_state_post_0_without_preload_content( return response_data.response - def _localstack_pods_state_post_0_serialize( + def _localstack_pods_state_post_serialize( self, pod, _request_auth, @@ -3386,7 +3386,7 @@ def _localstack_pods_state_post_0_serialize( @validate_call - def save_pod_0( + def save_pod( self, name: Annotated[StrictStr, Field(description="Cloud pod name")], local: Optional[StrictBool] = None, @@ -3406,7 +3406,7 @@ def save_pod_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """save_pod_0 + """save_pod Create and register a cloud pod version @@ -3442,7 +3442,7 @@ def save_pod_0( :return: Returns the result object. """ # noqa: E501 - _param = self._save_pod_0_serialize( + _param = self._save_pod_serialize( name=name, local=local, version=version, @@ -3469,7 +3469,7 @@ def save_pod_0( @validate_call - def save_pod_0_with_http_info( + def save_pod_with_http_info( self, name: Annotated[StrictStr, Field(description="Cloud pod name")], local: Optional[StrictBool] = None, @@ -3489,7 +3489,7 @@ def save_pod_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """save_pod_0 + """save_pod Create and register a cloud pod version @@ -3525,7 +3525,7 @@ def save_pod_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._save_pod_0_serialize( + _param = self._save_pod_serialize( name=name, local=local, version=version, @@ -3552,7 +3552,7 @@ def save_pod_0_with_http_info( @validate_call - def save_pod_0_without_preload_content( + def save_pod_without_preload_content( self, name: Annotated[StrictStr, Field(description="Cloud pod name")], local: Optional[StrictBool] = None, @@ -3572,7 +3572,7 @@ def save_pod_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """save_pod_0 + """save_pod Create and register a cloud pod version @@ -3608,7 +3608,7 @@ def save_pod_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._save_pod_0_serialize( + _param = self._save_pod_serialize( name=name, local=local, version=version, @@ -3630,7 +3630,7 @@ def save_pod_0_without_preload_content( return response_data.response - def _save_pod_0_serialize( + def _save_pod_serialize( self, name, local, diff --git a/packages/localstack-sdk-generated/localstack/sdk/api/state_api.py b/packages/localstack-sdk-generated/localstack/sdk/api/state_api.py index c441867..e06ad93 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/api/state_api.py +++ b/packages/localstack-sdk-generated/localstack/sdk/api/state_api.py @@ -40,7 +40,7 @@ def __init__(self, api_client=None) -> None: @validate_call - def localstack_state_load_post_0( + def localstack_state_load_post( self, _request_timeout: Union[ None, @@ -55,7 +55,7 @@ def localstack_state_load_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> StateResult: - """localstack_state_load_post_0 + """localstack_state_load_post Load all service states @@ -81,7 +81,7 @@ def localstack_state_load_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_load_post_0_serialize( + _param = self._localstack_state_load_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -103,7 +103,7 @@ def localstack_state_load_post_0( @validate_call - def localstack_state_load_post_0_with_http_info( + def localstack_state_load_post_with_http_info( self, _request_timeout: Union[ None, @@ -118,7 +118,7 @@ def localstack_state_load_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[StateResult]: - """localstack_state_load_post_0 + """localstack_state_load_post Load all service states @@ -144,7 +144,7 @@ def localstack_state_load_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_load_post_0_serialize( + _param = self._localstack_state_load_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -166,7 +166,7 @@ def localstack_state_load_post_0_with_http_info( @validate_call - def localstack_state_load_post_0_without_preload_content( + def localstack_state_load_post_without_preload_content( self, _request_timeout: Union[ None, @@ -181,7 +181,7 @@ def localstack_state_load_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_state_load_post_0 + """localstack_state_load_post Load all service states @@ -207,7 +207,7 @@ def localstack_state_load_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_load_post_0_serialize( + _param = self._localstack_state_load_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -224,7 +224,7 @@ def localstack_state_load_post_0_without_preload_content( return response_data.response - def _localstack_state_load_post_0_serialize( + def _localstack_state_load_post_serialize( self, _request_auth, _content_type, @@ -285,7 +285,7 @@ def _localstack_state_load_post_0_serialize( @validate_call - def localstack_state_reset_post_0( + def localstack_state_reset_post( self, _request_timeout: Union[ None, @@ -300,7 +300,7 @@ def localstack_state_reset_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """localstack_state_reset_post_0 + """localstack_state_reset_post Reset all service states @@ -326,7 +326,7 @@ def localstack_state_reset_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_reset_post_0_serialize( + _param = self._localstack_state_reset_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -348,7 +348,7 @@ def localstack_state_reset_post_0( @validate_call - def localstack_state_reset_post_0_with_http_info( + def localstack_state_reset_post_with_http_info( self, _request_timeout: Union[ None, @@ -363,7 +363,7 @@ def localstack_state_reset_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """localstack_state_reset_post_0 + """localstack_state_reset_post Reset all service states @@ -389,7 +389,7 @@ def localstack_state_reset_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_reset_post_0_serialize( + _param = self._localstack_state_reset_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -411,7 +411,7 @@ def localstack_state_reset_post_0_with_http_info( @validate_call - def localstack_state_reset_post_0_without_preload_content( + def localstack_state_reset_post_without_preload_content( self, _request_timeout: Union[ None, @@ -426,7 +426,7 @@ def localstack_state_reset_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_state_reset_post_0 + """localstack_state_reset_post Reset all service states @@ -452,7 +452,7 @@ def localstack_state_reset_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_reset_post_0_serialize( + _param = self._localstack_state_reset_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -469,7 +469,7 @@ def localstack_state_reset_post_0_without_preload_content( return response_data.response - def _localstack_state_reset_post_0_serialize( + def _localstack_state_reset_post_serialize( self, _request_auth, _content_type, @@ -523,7 +523,7 @@ def _localstack_state_reset_post_0_serialize( @validate_call - def localstack_state_save_post_0( + def localstack_state_save_post( self, _request_timeout: Union[ None, @@ -538,7 +538,7 @@ def localstack_state_save_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> StateResult: - """localstack_state_save_post_0 + """localstack_state_save_post Save all service states @@ -564,7 +564,7 @@ def localstack_state_save_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_save_post_0_serialize( + _param = self._localstack_state_save_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -586,7 +586,7 @@ def localstack_state_save_post_0( @validate_call - def localstack_state_save_post_0_with_http_info( + def localstack_state_save_post_with_http_info( self, _request_timeout: Union[ None, @@ -601,7 +601,7 @@ def localstack_state_save_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[StateResult]: - """localstack_state_save_post_0 + """localstack_state_save_post Save all service states @@ -627,7 +627,7 @@ def localstack_state_save_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_save_post_0_serialize( + _param = self._localstack_state_save_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -649,7 +649,7 @@ def localstack_state_save_post_0_with_http_info( @validate_call - def localstack_state_save_post_0_without_preload_content( + def localstack_state_save_post_without_preload_content( self, _request_timeout: Union[ None, @@ -664,7 +664,7 @@ def localstack_state_save_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_state_save_post_0 + """localstack_state_save_post Save all service states @@ -690,7 +690,7 @@ def localstack_state_save_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_save_post_0_serialize( + _param = self._localstack_state_save_post_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -707,7 +707,7 @@ def localstack_state_save_post_0_without_preload_content( return response_data.response - def _localstack_state_save_post_0_serialize( + def _localstack_state_save_post_serialize( self, _request_auth, _content_type, @@ -768,7 +768,7 @@ def _localstack_state_save_post_0_serialize( @validate_call - def localstack_state_service_load_post_0( + def localstack_state_service_load_post( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -784,7 +784,7 @@ def localstack_state_service_load_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """localstack_state_service_load_post_0 + """localstack_state_service_load_post Load a service state @@ -812,7 +812,7 @@ def localstack_state_service_load_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_load_post_0_serialize( + _param = self._localstack_state_service_load_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -836,7 +836,7 @@ def localstack_state_service_load_post_0( @validate_call - def localstack_state_service_load_post_0_with_http_info( + def localstack_state_service_load_post_with_http_info( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -852,7 +852,7 @@ def localstack_state_service_load_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """localstack_state_service_load_post_0 + """localstack_state_service_load_post Load a service state @@ -880,7 +880,7 @@ def localstack_state_service_load_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_load_post_0_serialize( + _param = self._localstack_state_service_load_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -904,7 +904,7 @@ def localstack_state_service_load_post_0_with_http_info( @validate_call - def localstack_state_service_load_post_0_without_preload_content( + def localstack_state_service_load_post_without_preload_content( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -920,7 +920,7 @@ def localstack_state_service_load_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_state_service_load_post_0 + """localstack_state_service_load_post Load a service state @@ -948,7 +948,7 @@ def localstack_state_service_load_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_load_post_0_serialize( + _param = self._localstack_state_service_load_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -967,7 +967,7 @@ def localstack_state_service_load_post_0_without_preload_content( return response_data.response - def _localstack_state_service_load_post_0_serialize( + def _localstack_state_service_load_post_serialize( self, service, _request_auth, @@ -1031,7 +1031,7 @@ def _localstack_state_service_load_post_0_serialize( @validate_call - def localstack_state_service_reset_post_0( + def localstack_state_service_reset_post( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -1047,7 +1047,7 @@ def localstack_state_service_reset_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """localstack_state_service_reset_post_0 + """localstack_state_service_reset_post Reset a service state @@ -1075,7 +1075,7 @@ def localstack_state_service_reset_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_reset_post_0_serialize( + _param = self._localstack_state_service_reset_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -1098,7 +1098,7 @@ def localstack_state_service_reset_post_0( @validate_call - def localstack_state_service_reset_post_0_with_http_info( + def localstack_state_service_reset_post_with_http_info( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -1114,7 +1114,7 @@ def localstack_state_service_reset_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """localstack_state_service_reset_post_0 + """localstack_state_service_reset_post Reset a service state @@ -1142,7 +1142,7 @@ def localstack_state_service_reset_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_reset_post_0_serialize( + _param = self._localstack_state_service_reset_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -1165,7 +1165,7 @@ def localstack_state_service_reset_post_0_with_http_info( @validate_call - def localstack_state_service_reset_post_0_without_preload_content( + def localstack_state_service_reset_post_without_preload_content( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -1181,7 +1181,7 @@ def localstack_state_service_reset_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_state_service_reset_post_0 + """localstack_state_service_reset_post Reset a service state @@ -1209,7 +1209,7 @@ def localstack_state_service_reset_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_reset_post_0_serialize( + _param = self._localstack_state_service_reset_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -1227,7 +1227,7 @@ def localstack_state_service_reset_post_0_without_preload_content( return response_data.response - def _localstack_state_service_reset_post_0_serialize( + def _localstack_state_service_reset_post_serialize( self, service, _request_auth, @@ -1284,7 +1284,7 @@ def _localstack_state_service_reset_post_0_serialize( @validate_call - def localstack_state_service_save_post_0( + def localstack_state_service_save_post( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -1300,7 +1300,7 @@ def localstack_state_service_save_post_0( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - """localstack_state_service_save_post_0 + """localstack_state_service_save_post Save a service state @@ -1328,7 +1328,7 @@ def localstack_state_service_save_post_0( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_save_post_0_serialize( + _param = self._localstack_state_service_save_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -1352,7 +1352,7 @@ def localstack_state_service_save_post_0( @validate_call - def localstack_state_service_save_post_0_with_http_info( + def localstack_state_service_save_post_with_http_info( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -1368,7 +1368,7 @@ def localstack_state_service_save_post_0_with_http_info( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: - """localstack_state_service_save_post_0 + """localstack_state_service_save_post Save a service state @@ -1396,7 +1396,7 @@ def localstack_state_service_save_post_0_with_http_info( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_save_post_0_serialize( + _param = self._localstack_state_service_save_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -1420,7 +1420,7 @@ def localstack_state_service_save_post_0_with_http_info( @validate_call - def localstack_state_service_save_post_0_without_preload_content( + def localstack_state_service_save_post_without_preload_content( self, service: Annotated[StrictStr, Field(description="Service name")], _request_timeout: Union[ @@ -1436,7 +1436,7 @@ def localstack_state_service_save_post_0_without_preload_content( _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: - """localstack_state_service_save_post_0 + """localstack_state_service_save_post Save a service state @@ -1464,7 +1464,7 @@ def localstack_state_service_save_post_0_without_preload_content( :return: Returns the result object. """ # noqa: E501 - _param = self._localstack_state_service_save_post_0_serialize( + _param = self._localstack_state_service_save_post_serialize( service=service, _request_auth=_request_auth, _content_type=_content_type, @@ -1483,7 +1483,7 @@ def localstack_state_service_save_post_0_without_preload_content( return response_data.response - def _localstack_state_service_save_post_0_serialize( + def _localstack_state_service_save_post_serialize( self, service, _request_auth, diff --git a/packages/localstack-sdk-generated/localstack/sdk/configuration.py b/packages/localstack-sdk-generated/localstack/sdk/configuration.py index b7a018f..66e1426 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/configuration.py +++ b/packages/localstack-sdk-generated/localstack/sdk/configuration.py @@ -14,14 +14,16 @@ import copy +import http.client as httplib import logging from logging import FileHandler import multiprocessing import sys -from typing import Optional +from typing import Any, ClassVar, Dict, List, Literal, Optional, TypedDict +from typing_extensions import NotRequired, Self + import urllib3 -import http.client as httplib JSON_SCHEMA_VALIDATION_KEYWORDS = { 'multipleOf', 'maximum', 'exclusiveMaximum', @@ -29,6 +31,106 @@ 'minLength', 'pattern', 'maxItems', 'minItems' } +ServerVariablesT = Dict[str, str] + +GenericAuthSetting = TypedDict( + "GenericAuthSetting", + { + "type": str, + "in": str, + "key": str, + "value": str, + }, +) + + +OAuth2AuthSetting = TypedDict( + "OAuth2AuthSetting", + { + "type": Literal["oauth2"], + "in": Literal["header"], + "key": Literal["Authorization"], + "value": str, + }, +) + + +APIKeyAuthSetting = TypedDict( + "APIKeyAuthSetting", + { + "type": Literal["api_key"], + "in": str, + "key": str, + "value": Optional[str], + }, +) + + +BasicAuthSetting = TypedDict( + "BasicAuthSetting", + { + "type": Literal["basic"], + "in": Literal["header"], + "key": Literal["Authorization"], + "value": Optional[str], + }, +) + + +BearerFormatAuthSetting = TypedDict( + "BearerFormatAuthSetting", + { + "type": Literal["bearer"], + "in": Literal["header"], + "format": Literal["JWT"], + "key": Literal["Authorization"], + "value": str, + }, +) + + +BearerAuthSetting = TypedDict( + "BearerAuthSetting", + { + "type": Literal["bearer"], + "in": Literal["header"], + "key": Literal["Authorization"], + "value": str, + }, +) + + +HTTPSignatureAuthSetting = TypedDict( + "HTTPSignatureAuthSetting", + { + "type": Literal["http-signature"], + "in": Literal["header"], + "key": Literal["Authorization"], + "value": None, + }, +) + + +AuthSettings = TypedDict( + "AuthSettings", + { + }, + total=False, +) + + +class HostSettingVariable(TypedDict): + description: str + default_value: str + enum_values: List[str] + + +class HostSetting(TypedDict): + url: str + description: str + variables: NotRequired[Dict[str, HostSettingVariable]] + + class Configuration: """This class contains various settings of the API client. @@ -62,20 +164,26 @@ class Configuration: """ - _default = None - - def __init__(self, host=None, - api_key=None, api_key_prefix=None, - username=None, password=None, - access_token=None, - server_index=None, server_variables=None, - server_operation_index=None, server_operation_variables=None, - ignore_operation_servers=False, - ssl_ca_cert=None, - retries=None, - *, - debug: Optional[bool] = None - ) -> None: + _default: ClassVar[Optional[Self]] = None + + def __init__( + self, + host: Optional[str]=None, + api_key: Optional[Dict[str, str]]=None, + api_key_prefix: Optional[Dict[str, str]]=None, + username: Optional[str]=None, + password: Optional[str]=None, + access_token: Optional[str]=None, + server_index: Optional[int]=None, + server_variables: Optional[ServerVariablesT]=None, + server_operation_index: Optional[Dict[int, int]]=None, + server_operation_variables: Optional[Dict[int, ServerVariablesT]]=None, + ignore_operation_servers: bool=False, + ssl_ca_cert: Optional[str]=None, + retries: Optional[int] = None, + *, + debug: Optional[bool] = None, + ) -> None: """Constructor """ self._base_path = "http://localhost.localstack.cloud:4566" if host is None else host @@ -199,7 +307,7 @@ def __init__(self, host=None, """date format """ - def __deepcopy__(self, memo): + def __deepcopy__(self, memo: Dict[int, Any]) -> Self: cls = self.__class__ result = cls.__new__(cls) memo[id(self)] = result @@ -213,11 +321,11 @@ def __deepcopy__(self, memo): result.debug = self.debug return result - def __setattr__(self, name, value): + def __setattr__(self, name: str, value: Any) -> None: object.__setattr__(self, name, value) @classmethod - def set_default(cls, default): + def set_default(cls, default: Optional[Self]) -> None: """Set default instance of configuration. It stores default configuration, which can be @@ -228,7 +336,7 @@ def set_default(cls, default): cls._default = default @classmethod - def get_default_copy(cls): + def get_default_copy(cls) -> Self: """Deprecated. Please use `get_default` instead. Deprecated. Please use `get_default` instead. @@ -238,7 +346,7 @@ def get_default_copy(cls): return cls.get_default() @classmethod - def get_default(cls): + def get_default(cls) -> Self: """Return the default configuration. This method returns newly created, based on default constructor, @@ -248,11 +356,11 @@ def get_default(cls): :return: The configuration object. """ if cls._default is None: - cls._default = Configuration() + cls._default = cls() return cls._default @property - def logger_file(self): + def logger_file(self) -> Optional[str]: """The logger file. If the logger_file is None, then add stream handler and remove file @@ -264,7 +372,7 @@ def logger_file(self): return self.__logger_file @logger_file.setter - def logger_file(self, value): + def logger_file(self, value: Optional[str]) -> None: """The logger file. If the logger_file is None, then add stream handler and remove file @@ -283,7 +391,7 @@ def logger_file(self, value): logger.addHandler(self.logger_file_handler) @property - def debug(self): + def debug(self) -> bool: """Debug status :param value: The debug status, True or False. @@ -292,7 +400,7 @@ def debug(self): return self.__debug @debug.setter - def debug(self, value): + def debug(self, value: bool) -> None: """Debug status :param value: The debug status, True or False. @@ -314,7 +422,7 @@ def debug(self, value): httplib.HTTPConnection.debuglevel = 0 @property - def logger_format(self): + def logger_format(self) -> str: """The logger format. The logger_formatter will be updated when sets logger_format. @@ -325,7 +433,7 @@ def logger_format(self): return self.__logger_format @logger_format.setter - def logger_format(self, value): + def logger_format(self, value: str) -> None: """The logger format. The logger_formatter will be updated when sets logger_format. @@ -336,7 +444,7 @@ def logger_format(self, value): self.__logger_format = value self.logger_formatter = logging.Formatter(self.__logger_format) - def get_api_key_with_prefix(self, identifier, alias=None): + def get_api_key_with_prefix(self, identifier: str, alias: Optional[str]=None) -> Optional[str]: """Gets API key (with prefix if set). :param identifier: The identifier of apiKey. @@ -353,7 +461,9 @@ def get_api_key_with_prefix(self, identifier, alias=None): else: return key - def get_basic_auth_token(self): + return None + + def get_basic_auth_token(self) -> Optional[str]: """Gets HTTP basic authentication header (string). :return: The token for basic HTTP authentication. @@ -368,15 +478,15 @@ def get_basic_auth_token(self): basic_auth=username + ':' + password ).get('authorization') - def auth_settings(self): + def auth_settings(self)-> AuthSettings: """Gets Auth Settings dict for api client. :return: The Auth Settings information dict. """ - auth = {} + auth: AuthSettings = {} return auth - def to_debug_report(self): + def to_debug_report(self) -> str: """Gets the essential information for debugging. :return: The report for debugging. @@ -388,7 +498,7 @@ def to_debug_report(self): "SDK Package Version: 0.0.4".\ format(env=sys.platform, pyversion=sys.version) - def get_host_settings(self): + def get_host_settings(self) -> List[HostSetting]: """Gets an array of host settings :return: An array of host settings @@ -410,7 +520,12 @@ def get_host_settings(self): } ] - def get_host_from_settings(self, index, variables=None, servers=None): + def get_host_from_settings( + self, + index: Optional[int], + variables: Optional[ServerVariablesT]=None, + servers: Optional[List[HostSetting]]=None, + ) -> str: """Gets host URL based on the index and variables :param index: array index of the host settings :param variables: hash of variable and the corresponding value @@ -450,12 +565,12 @@ def get_host_from_settings(self, index, variables=None, servers=None): return url @property - def host(self): + def host(self) -> str: """Return generated host.""" return self.get_host_from_settings(self.server_index, variables=self.server_variables) @host.setter - def host(self, value): + def host(self, value: str) -> None: """Fix base path.""" self._base_path = value self.server_index = None From 76a7f9a69e505477627b2cf503d354c83e33cf55 Mon Sep 17 00:00:00 2001 From: Giovanni Grano Date: Fri, 29 Nov 2024 16:31:12 -0500 Subject: [PATCH 3/3] generate code after v4.0.3 ls release --- .../localstack/sdk/models/ses_sent_email_body.py | 4 ++-- uv.lock | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/localstack-sdk-generated/localstack/sdk/models/ses_sent_email_body.py b/packages/localstack-sdk-generated/localstack/sdk/models/ses_sent_email_body.py index b72bf6c..2eb49ff 100644 --- a/packages/localstack-sdk-generated/localstack/sdk/models/ses_sent_email_body.py +++ b/packages/localstack-sdk-generated/localstack/sdk/models/ses_sent_email_body.py @@ -19,7 +19,7 @@ import json from pydantic import BaseModel, ConfigDict, StrictStr -from typing import Any, ClassVar, Dict, List +from typing import Any, ClassVar, Dict, List, Optional from typing import Optional, Set from typing_extensions import Self @@ -27,7 +27,7 @@ class SesSentEmailBody(BaseModel): """ SesSentEmailBody """ # noqa: E501 - html_part: StrictStr + html_part: Optional[StrictStr] = None text_part: StrictStr __properties: ClassVar[List[str]] = ["html_part", "text_part"] diff --git a/uv.lock b/uv.lock index b28829b..db5a055 100644 --- a/uv.lock +++ b/uv.lock @@ -197,7 +197,7 @@ wheels = [ [[package]] name = "localstack-sdk-generated" -version = "0.0.3" +version = "0.0.4" source = { editable = "packages/localstack-sdk-generated" } dependencies = [ { name = "pydantic" }, @@ -224,7 +224,7 @@ dev = [{ name = "pytest", specifier = ">=7.2.1" }] [[package]] name = "localstack-sdk-python" -version = "0.0.3" +version = "0.0.4" source = { editable = "." } dependencies = [ { name = "localstack-sdk-generated" },