Bugfix: change response code type to string for StartEventStreaming.

VERSION

@@ -1 +1 @@
-1.36.1859
+1.36.1860

eventbridge/CMakeLists.txt

@@ -0,0 +1,254 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(eventbridge_public_header 
+	include/alibabacloud/eventbridge/EventbridgeClient.h
+	include/alibabacloud/eventbridge/EventbridgeExport.h )
+
+set(eventbridge_public_header_model 
+	include/alibabacloud/eventbridge/model/CreateApiDestinationRequest.h
+	include/alibabacloud/eventbridge/model/CreateApiDestinationResult.h
+	include/alibabacloud/eventbridge/model/CreateConnectionRequest.h
+	include/alibabacloud/eventbridge/model/CreateConnectionResult.h
+	include/alibabacloud/eventbridge/model/CreateEventBusRequest.h
+	include/alibabacloud/eventbridge/model/CreateEventBusResult.h
+	include/alibabacloud/eventbridge/model/CreateEventSourceRequest.h
+	include/alibabacloud/eventbridge/model/CreateEventSourceResult.h
+	include/alibabacloud/eventbridge/model/CreateEventStreamingRequest.h
+	include/alibabacloud/eventbridge/model/CreateEventStreamingResult.h
+	include/alibabacloud/eventbridge/model/CreateRuleRequest.h
+	include/alibabacloud/eventbridge/model/CreateRuleResult.h
+	include/alibabacloud/eventbridge/model/CreateServiceLinkedRoleForProductRequest.h
+	include/alibabacloud/eventbridge/model/CreateServiceLinkedRoleForProductResult.h
+	include/alibabacloud/eventbridge/model/DeleteApiDestinationRequest.h
+	include/alibabacloud/eventbridge/model/DeleteApiDestinationResult.h
+	include/alibabacloud/eventbridge/model/DeleteConnectionRequest.h
+	include/alibabacloud/eventbridge/model/DeleteConnectionResult.h
+	include/alibabacloud/eventbridge/model/DeleteEventBusRequest.h
+	include/alibabacloud/eventbridge/model/DeleteEventBusResult.h
+	include/alibabacloud/eventbridge/model/DeleteEventSourceRequest.h
+	include/alibabacloud/eventbridge/model/DeleteEventSourceResult.h
+	include/alibabacloud/eventbridge/model/DeleteEventStreamingRequest.h
+	include/alibabacloud/eventbridge/model/DeleteEventStreamingResult.h
+	include/alibabacloud/eventbridge/model/DeleteRuleRequest.h
+	include/alibabacloud/eventbridge/model/DeleteRuleResult.h
+	include/alibabacloud/eventbridge/model/DeleteTargetsRequest.h
+	include/alibabacloud/eventbridge/model/DeleteTargetsResult.h
+	include/alibabacloud/eventbridge/model/DisableRuleRequest.h
+	include/alibabacloud/eventbridge/model/DisableRuleResult.h
+	include/alibabacloud/eventbridge/model/EnableRuleRequest.h
+	include/alibabacloud/eventbridge/model/EnableRuleResult.h
+	include/alibabacloud/eventbridge/model/GetApiDestinationRequest.h
+	include/alibabacloud/eventbridge/model/GetApiDestinationResult.h
+	include/alibabacloud/eventbridge/model/GetConnectionRequest.h
+	include/alibabacloud/eventbridge/model/GetConnectionResult.h
+	include/alibabacloud/eventbridge/model/GetEventBusRequest.h
+	include/alibabacloud/eventbridge/model/GetEventBusResult.h
+	include/alibabacloud/eventbridge/model/GetEventStreamingRequest.h
+	include/alibabacloud/eventbridge/model/GetEventStreamingResult.h
+	include/alibabacloud/eventbridge/model/GetRuleRequest.h
+	include/alibabacloud/eventbridge/model/GetRuleResult.h
+	include/alibabacloud/eventbridge/model/ListAliyunOfficialEventSourcesRequest.h
+	include/alibabacloud/eventbridge/model/ListAliyunOfficialEventSourcesResult.h
+	include/alibabacloud/eventbridge/model/ListApiDestinationsRequest.h
+	include/alibabacloud/eventbridge/model/ListApiDestinationsResult.h
+	include/alibabacloud/eventbridge/model/ListConnectionsRequest.h
+	include/alibabacloud/eventbridge/model/ListConnectionsResult.h
+	include/alibabacloud/eventbridge/model/ListEventBusesRequest.h
+	include/alibabacloud/eventbridge/model/ListEventBusesResult.h
+	include/alibabacloud/eventbridge/model/ListEventStreamingsRequest.h
+	include/alibabacloud/eventbridge/model/ListEventStreamingsResult.h
+	include/alibabacloud/eventbridge/model/ListRulesRequest.h
+	include/alibabacloud/eventbridge/model/ListRulesResult.h
+	include/alibabacloud/eventbridge/model/ListTargetsRequest.h
+	include/alibabacloud/eventbridge/model/ListTargetsResult.h
+	include/alibabacloud/eventbridge/model/ListUserDefinedEventSourcesRequest.h
+	include/alibabacloud/eventbridge/model/ListUserDefinedEventSourcesResult.h
+	include/alibabacloud/eventbridge/model/PauseEventStreamingRequest.h
+	include/alibabacloud/eventbridge/model/PauseEventStreamingResult.h
+	include/alibabacloud/eventbridge/model/PutTargetsRequest.h
+	include/alibabacloud/eventbridge/model/PutTargetsResult.h
+	include/alibabacloud/eventbridge/model/QueryEventRequest.h
+	include/alibabacloud/eventbridge/model/QueryEventResult.h
+	include/alibabacloud/eventbridge/model/QueryEventTracesRequest.h
+	include/alibabacloud/eventbridge/model/QueryEventTracesResult.h
+	include/alibabacloud/eventbridge/model/QueryTracedEventByEventIdRequest.h
+	include/alibabacloud/eventbridge/model/QueryTracedEventByEventIdResult.h
+	include/alibabacloud/eventbridge/model/QueryTracedEventsRequest.h
+	include/alibabacloud/eventbridge/model/QueryTracedEventsResult.h
+	include/alibabacloud/eventbridge/model/StartEventStreamingRequest.h
+	include/alibabacloud/eventbridge/model/StartEventStreamingResult.h
+	include/alibabacloud/eventbridge/model/TestEventPatternRequest.h
+	include/alibabacloud/eventbridge/model/TestEventPatternResult.h
+	include/alibabacloud/eventbridge/model/UpdateApiDestinationRequest.h
+	include/alibabacloud/eventbridge/model/UpdateApiDestinationResult.h
+	include/alibabacloud/eventbridge/model/UpdateConnectionRequest.h
+	include/alibabacloud/eventbridge/model/UpdateConnectionResult.h
+	include/alibabacloud/eventbridge/model/UpdateEventBusRequest.h
+	include/alibabacloud/eventbridge/model/UpdateEventBusResult.h
+	include/alibabacloud/eventbridge/model/UpdateEventSourceRequest.h
+	include/alibabacloud/eventbridge/model/UpdateEventSourceResult.h
+	include/alibabacloud/eventbridge/model/UpdateEventStreamingRequest.h
+	include/alibabacloud/eventbridge/model/UpdateEventStreamingResult.h
+	include/alibabacloud/eventbridge/model/UpdateRuleRequest.h
+	include/alibabacloud/eventbridge/model/UpdateRuleResult.h )
+
+set(eventbridge_src 
+	src/EventbridgeClient.cc
+	src/model/CreateApiDestinationRequest.cc
+	src/model/CreateApiDestinationResult.cc
+	src/model/CreateConnectionRequest.cc
+	src/model/CreateConnectionResult.cc
+	src/model/CreateEventBusRequest.cc
+	src/model/CreateEventBusResult.cc
+	src/model/CreateEventSourceRequest.cc
+	src/model/CreateEventSourceResult.cc
+	src/model/CreateEventStreamingRequest.cc
+	src/model/CreateEventStreamingResult.cc
+	src/model/CreateRuleRequest.cc
+	src/model/CreateRuleResult.cc
+	src/model/CreateServiceLinkedRoleForProductRequest.cc
+	src/model/CreateServiceLinkedRoleForProductResult.cc
+	src/model/DeleteApiDestinationRequest.cc
+	src/model/DeleteApiDestinationResult.cc
+	src/model/DeleteConnectionRequest.cc
+	src/model/DeleteConnectionResult.cc
+	src/model/DeleteEventBusRequest.cc
+	src/model/DeleteEventBusResult.cc
+	src/model/DeleteEventSourceRequest.cc
+	src/model/DeleteEventSourceResult.cc
+	src/model/DeleteEventStreamingRequest.cc
+	src/model/DeleteEventStreamingResult.cc
+	src/model/DeleteRuleRequest.cc
+	src/model/DeleteRuleResult.cc
+	src/model/DeleteTargetsRequest.cc
+	src/model/DeleteTargetsResult.cc
+	src/model/DisableRuleRequest.cc
+	src/model/DisableRuleResult.cc
+	src/model/EnableRuleRequest.cc
+	src/model/EnableRuleResult.cc
+	src/model/GetApiDestinationRequest.cc
+	src/model/GetApiDestinationResult.cc
+	src/model/GetConnectionRequest.cc
+	src/model/GetConnectionResult.cc
+	src/model/GetEventBusRequest.cc
+	src/model/GetEventBusResult.cc
+	src/model/GetEventStreamingRequest.cc
+	src/model/GetEventStreamingResult.cc
+	src/model/GetRuleRequest.cc
+	src/model/GetRuleResult.cc
+	src/model/ListAliyunOfficialEventSourcesRequest.cc
+	src/model/ListAliyunOfficialEventSourcesResult.cc
+	src/model/ListApiDestinationsRequest.cc
+	src/model/ListApiDestinationsResult.cc
+	src/model/ListConnectionsRequest.cc
+	src/model/ListConnectionsResult.cc
+	src/model/ListEventBusesRequest.cc
+	src/model/ListEventBusesResult.cc
+	src/model/ListEventStreamingsRequest.cc
+	src/model/ListEventStreamingsResult.cc
+	src/model/ListRulesRequest.cc
+	src/model/ListRulesResult.cc
+	src/model/ListTargetsRequest.cc
+	src/model/ListTargetsResult.cc
+	src/model/ListUserDefinedEventSourcesRequest.cc
+	src/model/ListUserDefinedEventSourcesResult.cc
+	src/model/PauseEventStreamingRequest.cc
+	src/model/PauseEventStreamingResult.cc
+	src/model/PutTargetsRequest.cc
+	src/model/PutTargetsResult.cc
+	src/model/QueryEventRequest.cc
+	src/model/QueryEventResult.cc
+	src/model/QueryEventTracesRequest.cc
+	src/model/QueryEventTracesResult.cc
+	src/model/QueryTracedEventByEventIdRequest.cc
+	src/model/QueryTracedEventByEventIdResult.cc
+	src/model/QueryTracedEventsRequest.cc
+	src/model/QueryTracedEventsResult.cc
+	src/model/StartEventStreamingRequest.cc
+	src/model/StartEventStreamingResult.cc
+	src/model/TestEventPatternRequest.cc
+	src/model/TestEventPatternResult.cc
+	src/model/UpdateApiDestinationRequest.cc
+	src/model/UpdateApiDestinationResult.cc
+	src/model/UpdateConnectionRequest.cc
+	src/model/UpdateConnectionResult.cc
+	src/model/UpdateEventBusRequest.cc
+	src/model/UpdateEventBusResult.cc
+	src/model/UpdateEventSourceRequest.cc
+	src/model/UpdateEventSourceResult.cc
+	src/model/UpdateEventStreamingRequest.cc
+	src/model/UpdateEventStreamingResult.cc
+	src/model/UpdateRuleRequest.cc
+	src/model/UpdateRuleResult.cc )
+
+add_library(eventbridge ${LIB_TYPE}
+	${eventbridge_public_header}
+	${eventbridge_public_header_model}
+	${eventbridge_src})
+
+set_target_properties(eventbridge
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}eventbridge
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(eventbridge
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_EVENTBRIDGE_LIBRARY)
+endif()
+
+target_include_directories(eventbridge
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(eventbridge
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(eventbridge
+		jsoncpp)
+	target_include_directories(eventbridge
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(eventbridge
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(eventbridge
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(eventbridge
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(eventbridge
+		jsoncpp)
+endif()
+
+install(FILES ${eventbridge_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/eventbridge)
+install(FILES ${eventbridge_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/eventbridge/model)
+install(TARGETS eventbridge
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

eventbridge/include/alibabacloud/eventbridge/EventbridgeClient.h

@@ -0,0 +1,390 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_EVENTBRIDGECLIENT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_EVENTBRIDGECLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "EventbridgeExport.h"
+#include "model/CreateApiDestinationRequest.h"
+#include "model/CreateApiDestinationResult.h"
+#include "model/CreateConnectionRequest.h"
+#include "model/CreateConnectionResult.h"
+#include "model/CreateEventBusRequest.h"
+#include "model/CreateEventBusResult.h"
+#include "model/CreateEventSourceRequest.h"
+#include "model/CreateEventSourceResult.h"
+#include "model/CreateEventStreamingRequest.h"
+#include "model/CreateEventStreamingResult.h"
+#include "model/CreateRuleRequest.h"
+#include "model/CreateRuleResult.h"
+#include "model/CreateServiceLinkedRoleForProductRequest.h"
+#include "model/CreateServiceLinkedRoleForProductResult.h"
+#include "model/DeleteApiDestinationRequest.h"
+#include "model/DeleteApiDestinationResult.h"
+#include "model/DeleteConnectionRequest.h"
+#include "model/DeleteConnectionResult.h"
+#include "model/DeleteEventBusRequest.h"
+#include "model/DeleteEventBusResult.h"
+#include "model/DeleteEventSourceRequest.h"
+#include "model/DeleteEventSourceResult.h"
+#include "model/DeleteEventStreamingRequest.h"
+#include "model/DeleteEventStreamingResult.h"
+#include "model/DeleteRuleRequest.h"
+#include "model/DeleteRuleResult.h"
+#include "model/DeleteTargetsRequest.h"
+#include "model/DeleteTargetsResult.h"
+#include "model/DisableRuleRequest.h"
+#include "model/DisableRuleResult.h"
+#include "model/EnableRuleRequest.h"
+#include "model/EnableRuleResult.h"
+#include "model/GetApiDestinationRequest.h"
+#include "model/GetApiDestinationResult.h"
+#include "model/GetConnectionRequest.h"
+#include "model/GetConnectionResult.h"
+#include "model/GetEventBusRequest.h"
+#include "model/GetEventBusResult.h"
+#include "model/GetEventStreamingRequest.h"
+#include "model/GetEventStreamingResult.h"
+#include "model/GetRuleRequest.h"
+#include "model/GetRuleResult.h"
+#include "model/ListAliyunOfficialEventSourcesRequest.h"
+#include "model/ListAliyunOfficialEventSourcesResult.h"
+#include "model/ListApiDestinationsRequest.h"
+#include "model/ListApiDestinationsResult.h"
+#include "model/ListConnectionsRequest.h"
+#include "model/ListConnectionsResult.h"
+#include "model/ListEventBusesRequest.h"
+#include "model/ListEventBusesResult.h"
+#include "model/ListEventStreamingsRequest.h"
+#include "model/ListEventStreamingsResult.h"
+#include "model/ListRulesRequest.h"
+#include "model/ListRulesResult.h"
+#include "model/ListTargetsRequest.h"
+#include "model/ListTargetsResult.h"
+#include "model/ListUserDefinedEventSourcesRequest.h"
+#include "model/ListUserDefinedEventSourcesResult.h"
+#include "model/PauseEventStreamingRequest.h"
+#include "model/PauseEventStreamingResult.h"
+#include "model/PutTargetsRequest.h"
+#include "model/PutTargetsResult.h"
+#include "model/QueryEventRequest.h"
+#include "model/QueryEventResult.h"
+#include "model/QueryEventTracesRequest.h"
+#include "model/QueryEventTracesResult.h"
+#include "model/QueryTracedEventByEventIdRequest.h"
+#include "model/QueryTracedEventByEventIdResult.h"
+#include "model/QueryTracedEventsRequest.h"
+#include "model/QueryTracedEventsResult.h"
+#include "model/StartEventStreamingRequest.h"
+#include "model/StartEventStreamingResult.h"
+#include "model/TestEventPatternRequest.h"
+#include "model/TestEventPatternResult.h"
+#include "model/UpdateApiDestinationRequest.h"
+#include "model/UpdateApiDestinationResult.h"
+#include "model/UpdateConnectionRequest.h"
+#include "model/UpdateConnectionResult.h"
+#include "model/UpdateEventBusRequest.h"
+#include "model/UpdateEventBusResult.h"
+#include "model/UpdateEventSourceRequest.h"
+#include "model/UpdateEventSourceResult.h"
+#include "model/UpdateEventStreamingRequest.h"
+#include "model/UpdateEventStreamingResult.h"
+#include "model/UpdateRuleRequest.h"
+#include "model/UpdateRuleResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		class ALIBABACLOUD_EVENTBRIDGE_EXPORT EventbridgeClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateApiDestinationResult> CreateApiDestinationOutcome;
+			typedef std::future<CreateApiDestinationOutcome> CreateApiDestinationOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateApiDestinationRequest&, const CreateApiDestinationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateApiDestinationAsyncHandler;
+			typedef Outcome<Error, Model::CreateConnectionResult> CreateConnectionOutcome;
+			typedef std::future<CreateConnectionOutcome> CreateConnectionOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateConnectionRequest&, const CreateConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CreateEventBusResult> CreateEventBusOutcome;
+			typedef std::future<CreateEventBusOutcome> CreateEventBusOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateEventBusRequest&, const CreateEventBusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEventBusAsyncHandler;
+			typedef Outcome<Error, Model::CreateEventSourceResult> CreateEventSourceOutcome;
+			typedef std::future<CreateEventSourceOutcome> CreateEventSourceOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateEventSourceRequest&, const CreateEventSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEventSourceAsyncHandler;
+			typedef Outcome<Error, Model::CreateEventStreamingResult> CreateEventStreamingOutcome;
+			typedef std::future<CreateEventStreamingOutcome> CreateEventStreamingOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateEventStreamingRequest&, const CreateEventStreamingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEventStreamingAsyncHandler;
+			typedef Outcome<Error, Model::CreateRuleResult> CreateRuleOutcome;
+			typedef std::future<CreateRuleOutcome> CreateRuleOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateRuleRequest&, const CreateRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateServiceLinkedRoleForProductResult> CreateServiceLinkedRoleForProductOutcome;
+			typedef std::future<CreateServiceLinkedRoleForProductOutcome> CreateServiceLinkedRoleForProductOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::CreateServiceLinkedRoleForProductRequest&, const CreateServiceLinkedRoleForProductOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceLinkedRoleForProductAsyncHandler;
+			typedef Outcome<Error, Model::DeleteApiDestinationResult> DeleteApiDestinationOutcome;
+			typedef std::future<DeleteApiDestinationOutcome> DeleteApiDestinationOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteApiDestinationRequest&, const DeleteApiDestinationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteApiDestinationAsyncHandler;
+			typedef Outcome<Error, Model::DeleteConnectionResult> DeleteConnectionOutcome;
+			typedef std::future<DeleteConnectionOutcome> DeleteConnectionOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteConnectionRequest&, const DeleteConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteConnectionAsyncHandler;
+			typedef Outcome<Error, Model::DeleteEventBusResult> DeleteEventBusOutcome;
+			typedef std::future<DeleteEventBusOutcome> DeleteEventBusOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteEventBusRequest&, const DeleteEventBusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEventBusAsyncHandler;
+			typedef Outcome<Error, Model::DeleteEventSourceResult> DeleteEventSourceOutcome;
+			typedef std::future<DeleteEventSourceOutcome> DeleteEventSourceOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteEventSourceRequest&, const DeleteEventSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEventSourceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteEventStreamingResult> DeleteEventStreamingOutcome;
+			typedef std::future<DeleteEventStreamingOutcome> DeleteEventStreamingOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteEventStreamingRequest&, const DeleteEventStreamingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEventStreamingAsyncHandler;
+			typedef Outcome<Error, Model::DeleteRuleResult> DeleteRuleOutcome;
+			typedef std::future<DeleteRuleOutcome> DeleteRuleOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteRuleRequest&, const DeleteRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTargetsResult> DeleteTargetsOutcome;
+			typedef std::future<DeleteTargetsOutcome> DeleteTargetsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DeleteTargetsRequest&, const DeleteTargetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTargetsAsyncHandler;
+			typedef Outcome<Error, Model::DisableRuleResult> DisableRuleOutcome;
+			typedef std::future<DisableRuleOutcome> DisableRuleOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::DisableRuleRequest&, const DisableRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableRuleAsyncHandler;
+			typedef Outcome<Error, Model::EnableRuleResult> EnableRuleOutcome;
+			typedef std::future<EnableRuleOutcome> EnableRuleOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::EnableRuleRequest&, const EnableRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetApiDestinationResult> GetApiDestinationOutcome;
+			typedef std::future<GetApiDestinationOutcome> GetApiDestinationOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::GetApiDestinationRequest&, const GetApiDestinationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetApiDestinationAsyncHandler;
+			typedef Outcome<Error, Model::GetConnectionResult> GetConnectionOutcome;
+			typedef std::future<GetConnectionOutcome> GetConnectionOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::GetConnectionRequest&, const GetConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConnectionAsyncHandler;
+			typedef Outcome<Error, Model::GetEventBusResult> GetEventBusOutcome;
+			typedef std::future<GetEventBusOutcome> GetEventBusOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::GetEventBusRequest&, const GetEventBusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEventBusAsyncHandler;
+			typedef Outcome<Error, Model::GetEventStreamingResult> GetEventStreamingOutcome;
+			typedef std::future<GetEventStreamingOutcome> GetEventStreamingOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::GetEventStreamingRequest&, const GetEventStreamingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEventStreamingAsyncHandler;
+			typedef Outcome<Error, Model::GetRuleResult> GetRuleOutcome;
+			typedef std::future<GetRuleOutcome> GetRuleOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::GetRuleRequest&, const GetRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRuleAsyncHandler;
+			typedef Outcome<Error, Model::ListAliyunOfficialEventSourcesResult> ListAliyunOfficialEventSourcesOutcome;
+			typedef std::future<ListAliyunOfficialEventSourcesOutcome> ListAliyunOfficialEventSourcesOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListAliyunOfficialEventSourcesRequest&, const ListAliyunOfficialEventSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAliyunOfficialEventSourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListApiDestinationsResult> ListApiDestinationsOutcome;
+			typedef std::future<ListApiDestinationsOutcome> ListApiDestinationsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListApiDestinationsRequest&, const ListApiDestinationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApiDestinationsAsyncHandler;
+			typedef Outcome<Error, Model::ListConnectionsResult> ListConnectionsOutcome;
+			typedef std::future<ListConnectionsOutcome> ListConnectionsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListConnectionsRequest&, const ListConnectionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConnectionsAsyncHandler;
+			typedef Outcome<Error, Model::ListEventBusesResult> ListEventBusesOutcome;
+			typedef std::future<ListEventBusesOutcome> ListEventBusesOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListEventBusesRequest&, const ListEventBusesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListEventBusesAsyncHandler;
+			typedef Outcome<Error, Model::ListEventStreamingsResult> ListEventStreamingsOutcome;
+			typedef std::future<ListEventStreamingsOutcome> ListEventStreamingsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListEventStreamingsRequest&, const ListEventStreamingsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListEventStreamingsAsyncHandler;
+			typedef Outcome<Error, Model::ListRulesResult> ListRulesOutcome;
+			typedef std::future<ListRulesOutcome> ListRulesOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListRulesRequest&, const ListRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListTargetsResult> ListTargetsOutcome;
+			typedef std::future<ListTargetsOutcome> ListTargetsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListTargetsRequest&, const ListTargetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTargetsAsyncHandler;
+			typedef Outcome<Error, Model::ListUserDefinedEventSourcesResult> ListUserDefinedEventSourcesOutcome;
+			typedef std::future<ListUserDefinedEventSourcesOutcome> ListUserDefinedEventSourcesOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::ListUserDefinedEventSourcesRequest&, const ListUserDefinedEventSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserDefinedEventSourcesAsyncHandler;
+			typedef Outcome<Error, Model::PauseEventStreamingResult> PauseEventStreamingOutcome;
+			typedef std::future<PauseEventStreamingOutcome> PauseEventStreamingOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::PauseEventStreamingRequest&, const PauseEventStreamingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PauseEventStreamingAsyncHandler;
+			typedef Outcome<Error, Model::PutTargetsResult> PutTargetsOutcome;
+			typedef std::future<PutTargetsOutcome> PutTargetsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::PutTargetsRequest&, const PutTargetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutTargetsAsyncHandler;
+			typedef Outcome<Error, Model::QueryEventResult> QueryEventOutcome;
+			typedef std::future<QueryEventOutcome> QueryEventOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::QueryEventRequest&, const QueryEventOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryEventAsyncHandler;
+			typedef Outcome<Error, Model::QueryEventTracesResult> QueryEventTracesOutcome;
+			typedef std::future<QueryEventTracesOutcome> QueryEventTracesOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::QueryEventTracesRequest&, const QueryEventTracesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryEventTracesAsyncHandler;
+			typedef Outcome<Error, Model::QueryTracedEventByEventIdResult> QueryTracedEventByEventIdOutcome;
+			typedef std::future<QueryTracedEventByEventIdOutcome> QueryTracedEventByEventIdOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::QueryTracedEventByEventIdRequest&, const QueryTracedEventByEventIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTracedEventByEventIdAsyncHandler;
+			typedef Outcome<Error, Model::QueryTracedEventsResult> QueryTracedEventsOutcome;
+			typedef std::future<QueryTracedEventsOutcome> QueryTracedEventsOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::QueryTracedEventsRequest&, const QueryTracedEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTracedEventsAsyncHandler;
+			typedef Outcome<Error, Model::StartEventStreamingResult> StartEventStreamingOutcome;
+			typedef std::future<StartEventStreamingOutcome> StartEventStreamingOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::StartEventStreamingRequest&, const StartEventStreamingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartEventStreamingAsyncHandler;
+			typedef Outcome<Error, Model::TestEventPatternResult> TestEventPatternOutcome;
+			typedef std::future<TestEventPatternOutcome> TestEventPatternOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::TestEventPatternRequest&, const TestEventPatternOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TestEventPatternAsyncHandler;
+			typedef Outcome<Error, Model::UpdateApiDestinationResult> UpdateApiDestinationOutcome;
+			typedef std::future<UpdateApiDestinationOutcome> UpdateApiDestinationOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::UpdateApiDestinationRequest&, const UpdateApiDestinationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateApiDestinationAsyncHandler;
+			typedef Outcome<Error, Model::UpdateConnectionResult> UpdateConnectionOutcome;
+			typedef std::future<UpdateConnectionOutcome> UpdateConnectionOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::UpdateConnectionRequest&, const UpdateConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateConnectionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateEventBusResult> UpdateEventBusOutcome;
+			typedef std::future<UpdateEventBusOutcome> UpdateEventBusOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::UpdateEventBusRequest&, const UpdateEventBusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateEventBusAsyncHandler;
+			typedef Outcome<Error, Model::UpdateEventSourceResult> UpdateEventSourceOutcome;
+			typedef std::future<UpdateEventSourceOutcome> UpdateEventSourceOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::UpdateEventSourceRequest&, const UpdateEventSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateEventSourceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateEventStreamingResult> UpdateEventStreamingOutcome;
+			typedef std::future<UpdateEventStreamingOutcome> UpdateEventStreamingOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::UpdateEventStreamingRequest&, const UpdateEventStreamingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateEventStreamingAsyncHandler;
+			typedef Outcome<Error, Model::UpdateRuleResult> UpdateRuleOutcome;
+			typedef std::future<UpdateRuleOutcome> UpdateRuleOutcomeCallable;
+			typedef std::function<void(const EventbridgeClient*, const Model::UpdateRuleRequest&, const UpdateRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRuleAsyncHandler;
+
+			EventbridgeClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			EventbridgeClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			EventbridgeClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~EventbridgeClient();
+			CreateApiDestinationOutcome createApiDestination(const Model::CreateApiDestinationRequest &request)const;
+			void createApiDestinationAsync(const Model::CreateApiDestinationRequest& request, const CreateApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateApiDestinationOutcomeCallable createApiDestinationCallable(const Model::CreateApiDestinationRequest& request) const;
+			CreateConnectionOutcome createConnection(const Model::CreateConnectionRequest &request)const;
+			void createConnectionAsync(const Model::CreateConnectionRequest& request, const CreateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateConnectionOutcomeCallable createConnectionCallable(const Model::CreateConnectionRequest& request) const;
+			CreateEventBusOutcome createEventBus(const Model::CreateEventBusRequest &request)const;
+			void createEventBusAsync(const Model::CreateEventBusRequest& request, const CreateEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateEventBusOutcomeCallable createEventBusCallable(const Model::CreateEventBusRequest& request) const;
+			CreateEventSourceOutcome createEventSource(const Model::CreateEventSourceRequest &request)const;
+			void createEventSourceAsync(const Model::CreateEventSourceRequest& request, const CreateEventSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateEventSourceOutcomeCallable createEventSourceCallable(const Model::CreateEventSourceRequest& request) const;
+			CreateEventStreamingOutcome createEventStreaming(const Model::CreateEventStreamingRequest &request)const;
+			void createEventStreamingAsync(const Model::CreateEventStreamingRequest& request, const CreateEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateEventStreamingOutcomeCallable createEventStreamingCallable(const Model::CreateEventStreamingRequest& request) const;
+			CreateRuleOutcome createRule(const Model::CreateRuleRequest &request)const;
+			void createRuleAsync(const Model::CreateRuleRequest& request, const CreateRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRuleOutcomeCallable createRuleCallable(const Model::CreateRuleRequest& request) const;
+			CreateServiceLinkedRoleForProductOutcome createServiceLinkedRoleForProduct(const Model::CreateServiceLinkedRoleForProductRequest &request)const;
+			void createServiceLinkedRoleForProductAsync(const Model::CreateServiceLinkedRoleForProductRequest& request, const CreateServiceLinkedRoleForProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServiceLinkedRoleForProductOutcomeCallable createServiceLinkedRoleForProductCallable(const Model::CreateServiceLinkedRoleForProductRequest& request) const;
+			DeleteApiDestinationOutcome deleteApiDestination(const Model::DeleteApiDestinationRequest &request)const;
+			void deleteApiDestinationAsync(const Model::DeleteApiDestinationRequest& request, const DeleteApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteApiDestinationOutcomeCallable deleteApiDestinationCallable(const Model::DeleteApiDestinationRequest& request) const;
+			DeleteConnectionOutcome deleteConnection(const Model::DeleteConnectionRequest &request)const;
+			void deleteConnectionAsync(const Model::DeleteConnectionRequest& request, const DeleteConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteConnectionOutcomeCallable deleteConnectionCallable(const Model::DeleteConnectionRequest& request) const;
+			DeleteEventBusOutcome deleteEventBus(const Model::DeleteEventBusRequest &request)const;
+			void deleteEventBusAsync(const Model::DeleteEventBusRequest& request, const DeleteEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteEventBusOutcomeCallable deleteEventBusCallable(const Model::DeleteEventBusRequest& request) const;
+			DeleteEventSourceOutcome deleteEventSource(const Model::DeleteEventSourceRequest &request)const;
+			void deleteEventSourceAsync(const Model::DeleteEventSourceRequest& request, const DeleteEventSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteEventSourceOutcomeCallable deleteEventSourceCallable(const Model::DeleteEventSourceRequest& request) const;
+			DeleteEventStreamingOutcome deleteEventStreaming(const Model::DeleteEventStreamingRequest &request)const;
+			void deleteEventStreamingAsync(const Model::DeleteEventStreamingRequest& request, const DeleteEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteEventStreamingOutcomeCallable deleteEventStreamingCallable(const Model::DeleteEventStreamingRequest& request) const;
+			DeleteRuleOutcome deleteRule(const Model::DeleteRuleRequest &request)const;
+			void deleteRuleAsync(const Model::DeleteRuleRequest& request, const DeleteRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteRuleOutcomeCallable deleteRuleCallable(const Model::DeleteRuleRequest& request) const;
+			DeleteTargetsOutcome deleteTargets(const Model::DeleteTargetsRequest &request)const;
+			void deleteTargetsAsync(const Model::DeleteTargetsRequest& request, const DeleteTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTargetsOutcomeCallable deleteTargetsCallable(const Model::DeleteTargetsRequest& request) const;
+			DisableRuleOutcome disableRule(const Model::DisableRuleRequest &request)const;
+			void disableRuleAsync(const Model::DisableRuleRequest& request, const DisableRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableRuleOutcomeCallable disableRuleCallable(const Model::DisableRuleRequest& request) const;
+			EnableRuleOutcome enableRule(const Model::EnableRuleRequest &request)const;
+			void enableRuleAsync(const Model::EnableRuleRequest& request, const EnableRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableRuleOutcomeCallable enableRuleCallable(const Model::EnableRuleRequest& request) const;
+			GetApiDestinationOutcome getApiDestination(const Model::GetApiDestinationRequest &request)const;
+			void getApiDestinationAsync(const Model::GetApiDestinationRequest& request, const GetApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetApiDestinationOutcomeCallable getApiDestinationCallable(const Model::GetApiDestinationRequest& request) const;
+			GetConnectionOutcome getConnection(const Model::GetConnectionRequest &request)const;
+			void getConnectionAsync(const Model::GetConnectionRequest& request, const GetConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetConnectionOutcomeCallable getConnectionCallable(const Model::GetConnectionRequest& request) const;
+			GetEventBusOutcome getEventBus(const Model::GetEventBusRequest &request)const;
+			void getEventBusAsync(const Model::GetEventBusRequest& request, const GetEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetEventBusOutcomeCallable getEventBusCallable(const Model::GetEventBusRequest& request) const;
+			GetEventStreamingOutcome getEventStreaming(const Model::GetEventStreamingRequest &request)const;
+			void getEventStreamingAsync(const Model::GetEventStreamingRequest& request, const GetEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetEventStreamingOutcomeCallable getEventStreamingCallable(const Model::GetEventStreamingRequest& request) const;
+			GetRuleOutcome getRule(const Model::GetRuleRequest &request)const;
+			void getRuleAsync(const Model::GetRuleRequest& request, const GetRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRuleOutcomeCallable getRuleCallable(const Model::GetRuleRequest& request) const;
+			ListAliyunOfficialEventSourcesOutcome listAliyunOfficialEventSources(const Model::ListAliyunOfficialEventSourcesRequest &request)const;
+			void listAliyunOfficialEventSourcesAsync(const Model::ListAliyunOfficialEventSourcesRequest& request, const ListAliyunOfficialEventSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAliyunOfficialEventSourcesOutcomeCallable listAliyunOfficialEventSourcesCallable(const Model::ListAliyunOfficialEventSourcesRequest& request) const;
+			ListApiDestinationsOutcome listApiDestinations(const Model::ListApiDestinationsRequest &request)const;
+			void listApiDestinationsAsync(const Model::ListApiDestinationsRequest& request, const ListApiDestinationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApiDestinationsOutcomeCallable listApiDestinationsCallable(const Model::ListApiDestinationsRequest& request) const;
+			ListConnectionsOutcome listConnections(const Model::ListConnectionsRequest &request)const;
+			void listConnectionsAsync(const Model::ListConnectionsRequest& request, const ListConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListConnectionsOutcomeCallable listConnectionsCallable(const Model::ListConnectionsRequest& request) const;
+			ListEventBusesOutcome listEventBuses(const Model::ListEventBusesRequest &request)const;
+			void listEventBusesAsync(const Model::ListEventBusesRequest& request, const ListEventBusesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListEventBusesOutcomeCallable listEventBusesCallable(const Model::ListEventBusesRequest& request) const;
+			ListEventStreamingsOutcome listEventStreamings(const Model::ListEventStreamingsRequest &request)const;
+			void listEventStreamingsAsync(const Model::ListEventStreamingsRequest& request, const ListEventStreamingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListEventStreamingsOutcomeCallable listEventStreamingsCallable(const Model::ListEventStreamingsRequest& request) const;
+			ListRulesOutcome listRules(const Model::ListRulesRequest &request)const;
+			void listRulesAsync(const Model::ListRulesRequest& request, const ListRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListRulesOutcomeCallable listRulesCallable(const Model::ListRulesRequest& request) const;
+			ListTargetsOutcome listTargets(const Model::ListTargetsRequest &request)const;
+			void listTargetsAsync(const Model::ListTargetsRequest& request, const ListTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTargetsOutcomeCallable listTargetsCallable(const Model::ListTargetsRequest& request) const;
+			ListUserDefinedEventSourcesOutcome listUserDefinedEventSources(const Model::ListUserDefinedEventSourcesRequest &request)const;
+			void listUserDefinedEventSourcesAsync(const Model::ListUserDefinedEventSourcesRequest& request, const ListUserDefinedEventSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUserDefinedEventSourcesOutcomeCallable listUserDefinedEventSourcesCallable(const Model::ListUserDefinedEventSourcesRequest& request) const;
+			PauseEventStreamingOutcome pauseEventStreaming(const Model::PauseEventStreamingRequest &request)const;
+			void pauseEventStreamingAsync(const Model::PauseEventStreamingRequest& request, const PauseEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PauseEventStreamingOutcomeCallable pauseEventStreamingCallable(const Model::PauseEventStreamingRequest& request) const;
+			PutTargetsOutcome putTargets(const Model::PutTargetsRequest &request)const;
+			void putTargetsAsync(const Model::PutTargetsRequest& request, const PutTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PutTargetsOutcomeCallable putTargetsCallable(const Model::PutTargetsRequest& request) const;
+			QueryEventOutcome queryEvent(const Model::QueryEventRequest &request)const;
+			void queryEventAsync(const Model::QueryEventRequest& request, const QueryEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryEventOutcomeCallable queryEventCallable(const Model::QueryEventRequest& request) const;
+			QueryEventTracesOutcome queryEventTraces(const Model::QueryEventTracesRequest &request)const;
+			void queryEventTracesAsync(const Model::QueryEventTracesRequest& request, const QueryEventTracesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryEventTracesOutcomeCallable queryEventTracesCallable(const Model::QueryEventTracesRequest& request) const;
+			QueryTracedEventByEventIdOutcome queryTracedEventByEventId(const Model::QueryTracedEventByEventIdRequest &request)const;
+			void queryTracedEventByEventIdAsync(const Model::QueryTracedEventByEventIdRequest& request, const QueryTracedEventByEventIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryTracedEventByEventIdOutcomeCallable queryTracedEventByEventIdCallable(const Model::QueryTracedEventByEventIdRequest& request) const;
+			QueryTracedEventsOutcome queryTracedEvents(const Model::QueryTracedEventsRequest &request)const;
+			void queryTracedEventsAsync(const Model::QueryTracedEventsRequest& request, const QueryTracedEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryTracedEventsOutcomeCallable queryTracedEventsCallable(const Model::QueryTracedEventsRequest& request) const;
+			StartEventStreamingOutcome startEventStreaming(const Model::StartEventStreamingRequest &request)const;
+			void startEventStreamingAsync(const Model::StartEventStreamingRequest& request, const StartEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartEventStreamingOutcomeCallable startEventStreamingCallable(const Model::StartEventStreamingRequest& request) const;
+			TestEventPatternOutcome testEventPattern(const Model::TestEventPatternRequest &request)const;
+			void testEventPatternAsync(const Model::TestEventPatternRequest& request, const TestEventPatternAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TestEventPatternOutcomeCallable testEventPatternCallable(const Model::TestEventPatternRequest& request) const;
+			UpdateApiDestinationOutcome updateApiDestination(const Model::UpdateApiDestinationRequest &request)const;
+			void updateApiDestinationAsync(const Model::UpdateApiDestinationRequest& request, const UpdateApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateApiDestinationOutcomeCallable updateApiDestinationCallable(const Model::UpdateApiDestinationRequest& request) const;
+			UpdateConnectionOutcome updateConnection(const Model::UpdateConnectionRequest &request)const;
+			void updateConnectionAsync(const Model::UpdateConnectionRequest& request, const UpdateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateConnectionOutcomeCallable updateConnectionCallable(const Model::UpdateConnectionRequest& request) const;
+			UpdateEventBusOutcome updateEventBus(const Model::UpdateEventBusRequest &request)const;
+			void updateEventBusAsync(const Model::UpdateEventBusRequest& request, const UpdateEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateEventBusOutcomeCallable updateEventBusCallable(const Model::UpdateEventBusRequest& request) const;
+			UpdateEventSourceOutcome updateEventSource(const Model::UpdateEventSourceRequest &request)const;
+			void updateEventSourceAsync(const Model::UpdateEventSourceRequest& request, const UpdateEventSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateEventSourceOutcomeCallable updateEventSourceCallable(const Model::UpdateEventSourceRequest& request) const;
+			UpdateEventStreamingOutcome updateEventStreaming(const Model::UpdateEventStreamingRequest &request)const;
+			void updateEventStreamingAsync(const Model::UpdateEventStreamingRequest& request, const UpdateEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateEventStreamingOutcomeCallable updateEventStreamingCallable(const Model::UpdateEventStreamingRequest& request) const;
+			UpdateRuleOutcome updateRule(const Model::UpdateRuleRequest &request)const;
+			void updateRuleAsync(const Model::UpdateRuleRequest& request, const UpdateRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateRuleOutcomeCallable updateRuleCallable(const Model::UpdateRuleRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_EVENTBRIDGE_EVENTBRIDGECLIENT_H_

eventbridge/include/alibabacloud/eventbridge/EventbridgeExport.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_EVENTBRIDGEEXPORT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_EVENTBRIDGEEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_EVENTBRIDGE_LIBRARY)
+#		define ALIBABACLOUD_EVENTBRIDGE_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_EVENTBRIDGE_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_EVENTBRIDGE_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_EVENTBRIDGE_EVENTBRIDGEEXPORT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateApiDestinationRequest.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEAPIDESTINATIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEAPIDESTINATIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateApiDestinationRequest : public RpcServiceRequest {
+public:
+	struct HttpApiParameters {
+		std::string endpoint;
+		std::string method;
+		struct ApiParametersItem {
+			std::string in;
+			std::string name;
+			std::string description;
+			std::string defaultValue;
+			std::string type;
+		};
+		ApiParametersItem apiParametersItem;
+		std::vector<ApiParametersItem> apiParameters;
+	};
+	CreateApiDestinationRequest();
+	~CreateApiDestinationRequest();
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	HttpApiParameters getHttpApiParameters() const;
+	void setHttpApiParameters(const HttpApiParameters &httpApiParameters);
+	std::string getApiDestinationName() const;
+	void setApiDestinationName(const std::string &apiDestinationName);
+	long getInvocationRateLimitPerSecond() const;
+	void setInvocationRateLimitPerSecond(long invocationRateLimitPerSecond);
+
+private:
+	std::string connectionName_;
+	std::string description_;
+	HttpApiParameters httpApiParameters_;
+	std::string apiDestinationName_;
+	long invocationRateLimitPerSecond_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEAPIDESTINATIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateApiDestinationResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEAPIDESTINATIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEAPIDESTINATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateApiDestinationResult : public ServiceResult
+			{
+			public:
+				struct Date
+				{
+					std::string apiDestinationName;
+				};
+
+
+				CreateApiDestinationResult();
+				explicit CreateApiDestinationResult(const std::string &payload);
+				~CreateApiDestinationResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				Date getDate()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				Date date_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEAPIDESTINATIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateConnectionRequest.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATECONNECTIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATECONNECTIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateConnectionRequest : public RpcServiceRequest {
+public:
+	struct NetworkParameters {
+		std::string vpcId;
+		std::string securityGroupId;
+		std::string networkType;
+		std::string vswitcheId;
+	};
+	struct AuthParameters {
+		struct BasicAuthParameters {
+			std::string password;
+			std::string username;
+		};
+		BasicAuthParameters basicAuthParameters;
+		struct ApiKeyAuthParameters {
+			std::string apiKeyName;
+			std::string apiKeyValue;
+		};
+		ApiKeyAuthParameters apiKeyAuthParameters;
+		std::string authorizationType;
+		struct InvocationHttpParameters {
+			struct BodyParametersItem {
+				std::string isValueSecret;
+				std::string value;
+				std::string key;
+			};
+			BodyParametersItem bodyParametersItem;
+			std::vector<BodyParametersItem> bodyParameters;
+			struct HeaderParametersItem {
+				std::string isValueSecret;
+				std::string value;
+				std::string key;
+			};
+			HeaderParametersItem headerParametersItem;
+			std::vector<HeaderParametersItem> headerParameters;
+			struct QueryStringParametersItem {
+				std::string isValueSecret;
+				std::string value;
+				std::string key;
+			};
+			QueryStringParametersItem queryStringParametersItem;
+			std::vector<QueryStringParametersItem> queryStringParameters;
+		};
+		InvocationHttpParameters invocationHttpParameters;
+		struct OAuthParameters {
+			struct ClientParameters {
+				std::string clientID;
+				std::string clientSecret;
+			};
+			ClientParameters clientParameters;
+			std::string authorizationEndpoint;
+			std::string httpMethod;
+			struct OAuthHttpParameters {
+				struct BodyParametersItem {
+					std::string isValueSecret;
+					std::string value;
+					std::string key;
+				};
+				BodyParametersItem bodyParametersItem;
+				std::vector<BodyParametersItem> bodyParameters;
+				struct HeaderParametersItem {
+					std::string isValueSecret;
+					std::string value;
+					std::string key;
+				};
+				HeaderParametersItem headerParametersItem;
+				std::vector<HeaderParametersItem> headerParameters;
+				struct QueryStringParametersItem {
+					std::string isValueSecret;
+					std::string value;
+					std::string key;
+				};
+				QueryStringParametersItem queryStringParametersItem;
+				std::vector<QueryStringParametersItem> queryStringParameters;
+			};
+			OAuthHttpParameters oAuthHttpParameters;
+		};
+		OAuthParameters oAuthParameters;
+	};
+	CreateConnectionRequest();
+	~CreateConnectionRequest();
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	NetworkParameters getNetworkParameters() const;
+	void setNetworkParameters(const NetworkParameters &networkParameters);
+	AuthParameters getAuthParameters() const;
+	void setAuthParameters(const AuthParameters &authParameters);
+
+private:
+	std::string connectionName_;
+	std::string description_;
+	NetworkParameters networkParameters_;
+	AuthParameters authParameters_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATECONNECTIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateConnectionResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATECONNECTIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATECONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateConnectionResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string connectionName;
+				};
+
+
+				CreateConnectionResult();
+				explicit CreateConnectionResult(const std::string &payload);
+				~CreateConnectionResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATECONNECTIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateEventBusRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTBUSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTBUSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateEventBusRequest : public RpcServiceRequest {
+public:
+	CreateEventBusRequest();
+	~CreateEventBusRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTBUSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateEventBusResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTBUSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTBUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateEventBusResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string eventBusARN;
+				};
+
+
+				CreateEventBusResult();
+				explicit CreateEventBusResult(const std::string &payload);
+				~CreateEventBusResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTBUSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateEventSourceRequest.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSOURCEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSOURCEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateEventSourceRequest : public RpcServiceRequest {
+public:
+	struct SourceMNSParameters {
+		std::string queueName;
+		std::string regionId;
+		bool isBase64Decode;
+	};
+	struct SourceRabbitMQParameters {
+		std::string queueName;
+		std::string virtualHostName;
+		std::string instanceId;
+		std::string regionId;
+	};
+	struct SourceRocketMQParameters {
+		std::string instanceSecurityGroupId;
+		std::string offset;
+		std::string groupID;
+		std::string instanceUsername;
+		std::string authType;
+		std::string instancePassword;
+		std::string instanceNetwork;
+		std::string instanceVSwitchIds;
+		std::string instanceId;
+		std::string instanceVpcId;
+		std::string instanceEndpoint;
+		std::string regionId;
+		std::string topic;
+		std::string instanceType;
+		std::string tag;
+		long timestamp;
+	};
+	struct SourceSLSParameters {
+		std::string roleName;
+		std::string project;
+		std::string logStore;
+		std::string consumePosition;
+	};
+	struct SourceScheduledEventParameters {
+		std::string schedule;
+		std::string userData;
+		std::string timeZone;
+	};
+	struct SourceKafkaParameters {
+		std::string instanceId;
+		std::string consumerGroup;
+		std::string regionId;
+		std::string vSwitchIds;
+		std::string vpcId;
+		std::string securityGroupId;
+		std::string topic;
+		std::string offsetReset;
+		int maximumTasks;
+		std::string network;
+	};
+	struct SourceHttpEventParameters {
+		std::string string;
+		std::vector<std::string> referer;
+		std::string string;
+		std::vector<std::string> method;
+		std::string string;
+		std::vector<std::string> ip;
+		std::string securityConfig;
+		std::string type;
+	};
+	CreateEventSourceRequest();
+	~CreateEventSourceRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	SourceMNSParameters getSourceMNSParameters() const;
+	void setSourceMNSParameters(const SourceMNSParameters &sourceMNSParameters);
+	bool getLinkedExternalSource() const;
+	void setLinkedExternalSource(bool linkedExternalSource);
+	std::string getExternalSourceType() const;
+	void setExternalSourceType(const std::string &externalSourceType);
+	std::string getExternalSourceConfig() const;
+	void setExternalSourceConfig(const std::string &externalSourceConfig);
+	SourceRabbitMQParameters getSourceRabbitMQParameters() const;
+	void setSourceRabbitMQParameters(const SourceRabbitMQParameters &sourceRabbitMQParameters);
+	SourceRocketMQParameters getSourceRocketMQParameters() const;
+	void setSourceRocketMQParameters(const SourceRocketMQParameters &sourceRocketMQParameters);
+	SourceSLSParameters getSourceSLSParameters() const;
+	void setSourceSLSParameters(const SourceSLSParameters &sourceSLSParameters);
+	SourceScheduledEventParameters getSourceScheduledEventParameters() const;
+	void setSourceScheduledEventParameters(const SourceScheduledEventParameters &sourceScheduledEventParameters);
+	SourceKafkaParameters getSourceKafkaParameters() const;
+	void setSourceKafkaParameters(const SourceKafkaParameters &sourceKafkaParameters);
+	SourceHttpEventParameters getSourceHttpEventParameters() const;
+	void setSourceHttpEventParameters(const SourceHttpEventParameters &sourceHttpEventParameters);
+	std::string getEventSourceName() const;
+	void setEventSourceName(const std::string &eventSourceName);
+
+private:
+	std::string description_;
+	std::string eventBusName_;
+	SourceMNSParameters sourceMNSParameters_;
+	bool linkedExternalSource_;
+	std::string externalSourceType_;
+	std::string externalSourceConfig_;
+	SourceRabbitMQParameters sourceRabbitMQParameters_;
+	SourceRocketMQParameters sourceRocketMQParameters_;
+	SourceSLSParameters sourceSLSParameters_;
+	SourceScheduledEventParameters sourceScheduledEventParameters_;
+	SourceKafkaParameters sourceKafkaParameters_;
+	SourceHttpEventParameters sourceHttpEventParameters_;
+	std::string eventSourceName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSOURCEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateEventSourceResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSOURCERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateEventSourceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string eventSourceARN;
+				};
+
+
+				CreateEventSourceResult();
+				explicit CreateEventSourceResult(const std::string &payload);
+				~CreateEventSourceResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSOURCERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateEventStreamingRequest.h

@@ -0,0 +1,567 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSTREAMINGREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSTREAMINGREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateEventStreamingRequest : public RpcServiceRequest {
+public:
+	struct Sink {
+		struct SinkRabbitMQParameters {
+			struct RoutingKey {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoutingKey routingKey;
+			struct QueueName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			QueueName queueName;
+			struct VirtualHostName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VirtualHostName virtualHostName;
+			struct InstanceId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceId instanceId;
+			struct TargetType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			TargetType targetType;
+			struct MessageId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			MessageId messageId;
+			struct Exchange {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Exchange exchange;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct Properties {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Properties properties;
+		};
+		SinkRabbitMQParameters sinkRabbitMQParameters;
+		struct SinkMNSParameters {
+			struct QueueName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			QueueName queueName;
+			struct IsBase64Encode {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			IsBase64Encode isBase64Encode;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+		};
+		SinkMNSParameters sinkMNSParameters;
+		struct SinkDataHubParameters {
+			struct RoleName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoleName roleName;
+			struct Project {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Project project;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct TopicType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			TopicType topicType;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct TopicSchema {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			TopicSchema topicSchema;
+		};
+		SinkDataHubParameters sinkDataHubParameters;
+		struct SinkKafkaParameters {
+			struct InstanceId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceId instanceId;
+			struct Acks {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Acks acks;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct SaslUser {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			SaslUser saslUser;
+			struct Value {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Value value;
+			struct Key {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Key key;
+		};
+		SinkKafkaParameters sinkKafkaParameters;
+		struct SinkFnfParameters {
+			struct Input {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Input input;
+			struct ExecutionName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			ExecutionName executionName;
+			struct RoleName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoleName roleName;
+			struct FlowName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			FlowName flowName;
+		};
+		SinkFnfParameters sinkFnfParameters;
+		struct SinkFcParameters {
+			struct InvocationType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InvocationType invocationType;
+			struct FunctionName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			FunctionName functionName;
+			struct Qualifier {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Qualifier qualifier;
+			struct ServiceName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			ServiceName serviceName;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct Concurrency {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Concurrency concurrency;
+		};
+		SinkFcParameters sinkFcParameters;
+		struct SinkPrometheusParameters {
+			struct VSwitchId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VSwitchId vSwitchId;
+			struct Password {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Password password;
+			struct Data {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Data data;
+			struct VpcId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VpcId vpcId;
+			struct SecurityGroupId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			SecurityGroupId securityGroupId;
+			struct AuthorizationType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			AuthorizationType authorizationType;
+			struct NetworkType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			NetworkType networkType;
+			struct URL {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			URL uRL;
+			struct Username {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Username username;
+		};
+		SinkPrometheusParameters sinkPrometheusParameters;
+		struct SinkSLSParameters {
+			struct RoleName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoleName roleName;
+			struct Project {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Project project;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct LogStore {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			LogStore logStore;
+		};
+		SinkSLSParameters sinkSLSParameters;
+		struct SinkRocketMQParameters {
+			struct Keys {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Keys keys;
+			struct VSwitchIds {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VSwitchIds vSwitchIds;
+			struct SecurityGroupId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			SecurityGroupId securityGroupId;
+			struct InstanceUsername {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceUsername instanceUsername;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct Tags {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Tags tags;
+			struct Network {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Network network;
+			struct InstancePassword {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstancePassword instancePassword;
+			struct InstanceId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceId instanceId;
+			struct InstanceEndpoint {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceEndpoint instanceEndpoint;
+			struct VpcId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VpcId vpcId;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct InstanceType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceType instanceType;
+			struct Properties {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Properties properties;
+		};
+		SinkRocketMQParameters sinkRocketMQParameters;
+	};
+	struct Transforms {
+		std::string arn;
+	};
+	struct Source {
+		struct SourceMQTTParameters {
+			std::string instanceId;
+			std::string regionId;
+			std::string topic;
+		};
+		SourceMQTTParameters sourceMQTTParameters;
+		struct SourceRocketMQParameters {
+			std::string filterSql;
+			std::string instanceSecurityGroupId;
+			std::string offset;
+			std::string vSwitchIds;
+			std::string groupID;
+			std::string securityGroupId;
+			std::string instanceUsername;
+			std::string filterType;
+			std::string network;
+			std::string authType;
+			std::string instancePassword;
+			std::string instanceVSwitchIds;
+			std::string instanceNetwork;
+			std::string instanceId;
+			std::string instanceEndpoint;
+			std::string instanceVpcId;
+			std::string regionId;
+			std::string vpcId;
+			std::string topic;
+			std::string instanceType;
+			std::string tag;
+			long timestamp;
+		};
+		SourceRocketMQParameters sourceRocketMQParameters;
+		struct SourceSLSParameters {
+			std::string roleName;
+			std::string project;
+			std::string logStore;
+			std::string consumePosition;
+		};
+		SourceSLSParameters sourceSLSParameters;
+		struct SourcePrometheusParameters {
+			std::string dataType;
+			std::string clusterId;
+			std::string labels;
+		};
+		SourcePrometheusParameters sourcePrometheusParameters;
+		struct SourceDTSParameters {
+			std::string brokerUrl;
+			std::string password;
+			long initCheckPoint;
+			std::string topic;
+			std::string taskId;
+			std::string sid;
+			std::string username;
+		};
+		SourceDTSParameters sourceDTSParameters;
+		struct SourceKafkaParameters {
+			std::string instanceId;
+			std::string consumerGroup;
+			std::string regionId;
+			std::string vSwitchIds;
+			std::string vpcId;
+			std::string securityGroupId;
+			std::string topic;
+			std::string offsetReset;
+			std::string network;
+		};
+		SourceKafkaParameters sourceKafkaParameters;
+		struct SourceMNSParameters {
+			std::string queueName;
+			std::string regionId;
+			bool isBase64Decode;
+		};
+		SourceMNSParameters sourceMNSParameters;
+		struct SourceRabbitMQParameters {
+			std::string queueName;
+			std::string virtualHostName;
+			std::string instanceId;
+			std::string regionId;
+		};
+		SourceRabbitMQParameters sourceRabbitMQParameters;
+	};
+	struct RunOptions {
+		struct BatchWindow {
+			int countBasedWindow;
+			int timeBasedWindow;
+		};
+		BatchWindow batchWindow;
+		struct RetryStrategy {
+			std::string pushRetryStrategy;
+			long maximumRetryAttempts;
+			long maximumEventAgeInSeconds;
+		};
+		RetryStrategy retryStrategy;
+		struct DeadLetterQueue {
+			std::string arn;
+		};
+		DeadLetterQueue deadLetterQueue;
+		long maximumTasks;
+		std::string errorsTolerance;
+	};
+	CreateEventStreamingRequest();
+	~CreateEventStreamingRequest();
+	Sink getSink() const;
+	void setSink(const Sink &sink);
+	std::vector<Transforms> getTransforms() const;
+	void setTransforms(const std::vector<Transforms> &transforms);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getFilterPattern() const;
+	void setFilterPattern(const std::string &filterPattern);
+	Source getSource() const;
+	void setSource(const Source &source);
+	RunOptions getRunOptions() const;
+	void setRunOptions(const RunOptions &runOptions);
+	std::string getEventStreamingName() const;
+	void setEventStreamingName(const std::string &eventStreamingName);
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+
+private:
+	Sink sink_;
+	std::vector<Transforms> transforms_;
+	std::string description_;
+	std::string filterPattern_;
+	Source source_;
+	RunOptions runOptions_;
+	std::string eventStreamingName_;
+	std::string tag_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSTREAMINGREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateEventStreamingResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSTREAMINGRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSTREAMINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateEventStreamingResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string eventStreamingARN;
+				};
+
+
+				CreateEventStreamingResult();
+				explicit CreateEventStreamingResult(const std::string &payload);
+				~CreateEventStreamingResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATEEVENTSTREAMINGRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateRuleRequest.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATERULEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATERULEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateRuleRequest : public RpcServiceRequest {
+public:
+	struct EventTargets {
+		std::string endpoint;
+		std::string pushRetryStrategy;
+		struct ParamListItem {
+			std::string _template;
+			std::string resourceKey;
+			std::string form;
+			std::string value;
+		};
+		ParamListItem paramListItem;
+		std::vector<ParamListItem> paramList;
+		std::string id;
+		struct DeadLetterQueue {
+			std::string arn;
+		};
+		DeadLetterQueue deadLetterQueue;
+		std::string type;
+		std::string errorsTolerance;
+	};
+	CreateRuleRequest();
+	~CreateRuleRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getTargets() const;
+	void setTargets(const std::string &targets);
+	std::vector<EventTargets> getEventTargets() const;
+	void setEventTargets(const std::vector<EventTargets> &eventTargets);
+	std::string getFilterPattern() const;
+	void setFilterPattern(const std::string &filterPattern);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::string ruleName_;
+	std::string eventBusName_;
+	std::string targets_;
+	std::vector<EventTargets> eventTargets_;
+	std::string filterPattern_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATERULEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateRuleResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATERULERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATERULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string ruleARN;
+				};
+
+
+				CreateRuleResult();
+				explicit CreateRuleResult(const std::string &payload);
+				~CreateRuleResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATERULERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateServiceLinkedRoleForProductRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATESERVICELINKEDROLEFORPRODUCTREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATESERVICELINKEDROLEFORPRODUCTREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateServiceLinkedRoleForProductRequest : public RpcServiceRequest {
+public:
+	CreateServiceLinkedRoleForProductRequest();
+	~CreateServiceLinkedRoleForProductRequest();
+	std::string getProductName() const;
+	void setProductName(const std::string &productName);
+
+private:
+	std::string productName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATESERVICELINKEDROLEFORPRODUCTREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/CreateServiceLinkedRoleForProductResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATESERVICELINKEDROLEFORPRODUCTRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATESERVICELINKEDROLEFORPRODUCTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT CreateServiceLinkedRoleForProductResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServiceLinkedRoleForProductResult();
+				explicit CreateServiceLinkedRoleForProductResult(const std::string &payload);
+				~CreateServiceLinkedRoleForProductResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_CREATESERVICELINKEDROLEFORPRODUCTRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteApiDestinationRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEAPIDESTINATIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEAPIDESTINATIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteApiDestinationRequest : public RpcServiceRequest {
+public:
+	DeleteApiDestinationRequest();
+	~DeleteApiDestinationRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getApiDestinationName() const;
+	void setApiDestinationName(const std::string &apiDestinationName);
+
+private:
+	std::string clientToken_;
+	std::string apiDestinationName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEAPIDESTINATIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteApiDestinationResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEAPIDESTINATIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEAPIDESTINATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteApiDestinationResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteApiDestinationResult();
+				explicit DeleteApiDestinationResult(const std::string &payload);
+				~DeleteApiDestinationResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEAPIDESTINATIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteConnectionRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETECONNECTIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETECONNECTIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteConnectionRequest : public RpcServiceRequest {
+public:
+	DeleteConnectionRequest();
+	~DeleteConnectionRequest();
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+
+private:
+	std::string connectionName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETECONNECTIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteConnectionResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETECONNECTIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETECONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteConnectionResult();
+				explicit DeleteConnectionResult(const std::string &payload);
+				~DeleteConnectionResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETECONNECTIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteEventBusRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTBUSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTBUSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteEventBusRequest : public RpcServiceRequest {
+public:
+	DeleteEventBusRequest();
+	~DeleteEventBusRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string clientToken_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTBUSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteEventBusResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTBUSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTBUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteEventBusResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteEventBusResult();
+				explicit DeleteEventBusResult(const std::string &payload);
+				~DeleteEventBusResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTBUSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteEventSourceRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSOURCEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSOURCEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteEventSourceRequest : public RpcServiceRequest {
+public:
+	DeleteEventSourceRequest();
+	~DeleteEventSourceRequest();
+	std::string getEventSourceName() const;
+	void setEventSourceName(const std::string &eventSourceName);
+
+private:
+	std::string eventSourceName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSOURCEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteEventSourceResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSOURCERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteEventSourceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteEventSourceResult();
+				explicit DeleteEventSourceResult(const std::string &payload);
+				~DeleteEventSourceResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSOURCERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteEventStreamingRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSTREAMINGREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSTREAMINGREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteEventStreamingRequest : public RpcServiceRequest {
+public:
+	DeleteEventStreamingRequest();
+	~DeleteEventStreamingRequest();
+	std::string getEventStreamingName() const;
+	void setEventStreamingName(const std::string &eventStreamingName);
+
+private:
+	std::string eventStreamingName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSTREAMINGREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteEventStreamingResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSTREAMINGRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSTREAMINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteEventStreamingResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteEventStreamingResult();
+				explicit DeleteEventStreamingResult(const std::string &payload);
+				~DeleteEventStreamingResult();
+				std::string getMessage()const;
+				bool getData()const;
+				bool getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				bool code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETEEVENTSTREAMINGRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteRuleRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETERULEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETERULEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteRuleRequest : public RpcServiceRequest {
+public:
+	DeleteRuleRequest();
+	~DeleteRuleRequest();
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string ruleName_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETERULEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteRuleResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETERULERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETERULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteRuleResult();
+				explicit DeleteRuleResult(const std::string &payload);
+				~DeleteRuleResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETERULERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteTargetsRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETETARGETSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETETARGETSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteTargetsRequest : public RpcServiceRequest {
+public:
+	DeleteTargetsRequest();
+	~DeleteTargetsRequest();
+	std::vector<std::string> getTargetIds() const;
+	void setTargetIds(const std::vector<std::string> &targetIds);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::vector<std::string> targetIds_;
+	std::string ruleName_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETETARGETSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DeleteTargetsResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETETARGETSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETETARGETSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DeleteTargetsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ErrorEntriesItem
+					{
+						std::string entryId;
+						std::string errorCode;
+						std::string errorMessage;
+					};
+					std::vector<ErrorEntriesItem> errorEntries;
+					int errorEntriesCount;
+				};
+
+
+				DeleteTargetsResult();
+				explicit DeleteTargetsResult(const std::string &payload);
+				~DeleteTargetsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DELETETARGETSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/DisableRuleRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DISABLERULEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DISABLERULEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT DisableRuleRequest : public RpcServiceRequest {
+public:
+	DisableRuleRequest();
+	~DisableRuleRequest();
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string ruleName_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DISABLERULEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/DisableRuleResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_DISABLERULERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_DISABLERULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT DisableRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DisableRuleResult();
+				explicit DisableRuleResult(const std::string &payload);
+				~DisableRuleResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_DISABLERULERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/EnableRuleRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_ENABLERULEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_ENABLERULEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT EnableRuleRequest : public RpcServiceRequest {
+public:
+	EnableRuleRequest();
+	~EnableRuleRequest();
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string ruleName_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_ENABLERULEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/EnableRuleResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_ENABLERULERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_ENABLERULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT EnableRuleResult : public ServiceResult
+			{
+			public:
+
+
+				EnableRuleResult();
+				explicit EnableRuleResult(const std::string &payload);
+				~EnableRuleResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_ENABLERULERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/GetApiDestinationRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETAPIDESTINATIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETAPIDESTINATIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetApiDestinationRequest : public RpcServiceRequest {
+public:
+	GetApiDestinationRequest();
+	~GetApiDestinationRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getApiDestinationName() const;
+	void setApiDestinationName(const std::string &apiDestinationName);
+
+private:
+	std::string clientToken_;
+	std::string apiDestinationName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETAPIDESTINATIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/GetApiDestinationResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETAPIDESTINATIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETAPIDESTINATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetApiDestinationResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct HttpApiParameters
+					{
+						struct ApiParametersItem
+						{
+							std::string type;
+							std::string description;
+							std::string in;
+							std::string name;
+						};
+						std::string endpoint;
+						std::vector<ApiParametersItem> apiParameters;
+						std::string method;
+					};
+					std::string connectionName;
+					long gmtCreate;
+					std::string description;
+					HttpApiParameters httpApiParameters;
+					std::string apiDestinationName;
+					long invocationRateLimitPerSecond;
+				};
+
+
+				GetApiDestinationResult();
+				explicit GetApiDestinationResult(const std::string &payload);
+				~GetApiDestinationResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETAPIDESTINATIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/GetConnectionRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETCONNECTIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetConnectionRequest : public RpcServiceRequest {
+public:
+	GetConnectionRequest();
+	~GetConnectionRequest();
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+
+private:
+	std::string connectionName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETCONNECTIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/GetConnectionResult.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETCONNECTIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETCONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetConnectionResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ConnectionsItem
+					{
+						struct NetworkParameters
+						{
+							std::string vpcId;
+							std::string networkType;
+							std::string securityGroupId;
+							std::string vswitcheId;
+						};
+						struct AuthParameters
+						{
+							struct ApiKeyAuthParameters
+							{
+								std::string apiKeyValue;
+								std::string apiKeyName;
+							};
+							struct BasicAuthParameters
+							{
+								std::string username;
+								std::string password;
+							};
+							struct InvocationHttpParameters
+							{
+								struct BodyParametersItem
+								{
+									std::string isValueSecret;
+									std::string value;
+									std::string key;
+								};
+								struct HeaderParametersItem
+								{
+									std::string isValueSecret;
+									std::string value;
+									std::string key;
+								};
+								struct QueryStringParametersItem
+								{
+									std::string isValueSecret;
+									std::string value;
+									std::string key;
+								};
+								std::vector<HeaderParametersItem> headerParameters;
+								std::vector<QueryStringParametersItem> queryStringParameters;
+								std::vector<BodyParametersItem> bodyParameters;
+							};
+							struct OAuthParameters
+							{
+								struct ClientParameters
+								{
+									std::string clientSecret;
+									std::string clientID;
+								};
+								struct OAuthHttpParameters
+								{
+									struct BodyParametersItem4
+									{
+										std::string isValueSecret;
+										std::string value;
+										std::string key;
+									};
+									struct HeaderParametersItem5
+									{
+										std::string isValueSecret;
+										std::string value;
+										std::string key;
+									};
+									struct QueryStringParametersItem6
+									{
+										std::string isValueSecret;
+										std::string value;
+										std::string key;
+									};
+									std::vector<HeaderParametersItem5> headerParameters2;
+									std::vector<BodyParametersItem4> bodyParameters1;
+									std::vector<QueryStringParametersItem6> queryStringParameters3;
+								};
+								ClientParameters clientParameters;
+								OAuthHttpParameters oAuthHttpParameters;
+								std::string authorizationEndpoint;
+								std::string httpMethod;
+							};
+							InvocationHttpParameters invocationHttpParameters;
+							BasicAuthParameters basicAuthParameters;
+							ApiKeyAuthParameters apiKeyAuthParameters;
+							OAuthParameters oAuthParameters;
+							std::string authorizationType;
+						};
+						std::string connectionName;
+						AuthParameters authParameters;
+						long gmtCreate;
+						std::string description;
+						NetworkParameters networkParameters;
+						long id;
+					};
+					std::vector<ConnectionsItem> connections;
+				};
+
+
+				GetConnectionResult();
+				explicit GetConnectionResult(const std::string &payload);
+				~GetConnectionResult();
+				int getHttpCode()const;
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpCode_;
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETCONNECTIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/GetEventBusRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTBUSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTBUSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetEventBusRequest : public RpcServiceRequest {
+public:
+	GetEventBusRequest();
+	~GetEventBusRequest();
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTBUSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/GetEventBusResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTBUSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTBUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetEventBusResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string eventBusName;
+					std::string description;
+					long createTimestamp;
+					std::string eventBusARN;
+				};
+
+
+				GetEventBusResult();
+				explicit GetEventBusResult(const std::string &payload);
+				~GetEventBusResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTBUSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/GetEventStreamingRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTSTREAMINGREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTSTREAMINGREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetEventStreamingRequest : public RpcServiceRequest {
+public:
+	GetEventStreamingRequest();
+	~GetEventStreamingRequest();
+	std::string getEventStreamingName() const;
+	void setEventStreamingName(const std::string &eventStreamingName);
+
+private:
+	std::string eventStreamingName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTSTREAMINGREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/GetEventStreamingResult.h

@@ -0,0 +1,485 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTSTREAMINGRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTSTREAMINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetEventStreamingResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Source
+					{
+						struct SourceMNSParameters
+						{
+							bool isBase64Decode;
+							std::string regionId;
+							std::string queueName;
+						};
+						struct SourceRabbitMQParameters
+						{
+							std::string virtualHostName;
+							std::string instanceId;
+							std::string regionId;
+							std::string queueName;
+						};
+						struct SourceRocketMQParameters
+						{
+							std::string instanceId;
+							long timestamp;
+							std::string offset;
+							std::string groupID;
+							std::string instancePassword;
+							std::string instanceNetwork;
+							std::string instanceUsername;
+							std::string instanceEndpoint;
+							std::string instanceVpcId;
+							std::string instanceVSwitchIds;
+							std::string instanceSecurityGroupId;
+							std::string regionId;
+							std::string tag;
+							std::string authType;
+							std::string topic;
+							std::string instanceType;
+						};
+						struct SourceKafkaParameters
+						{
+							std::string offsetReset;
+							std::string vpcId;
+							std::string instanceId;
+							std::string vSwitchIds;
+							std::string network;
+							std::string securityGroupId;
+							std::string regionId;
+							std::string topic;
+							std::string consumerGroup;
+						};
+						struct SourceMQTTParameters
+						{
+							std::string instanceId;
+							std::string regionId;
+							std::string topic;
+						};
+						struct SourceDTSParameters
+						{
+							std::string taskId;
+							std::string username;
+							std::string initCheckPoint;
+							std::string topic;
+							std::string brokerUrl;
+							std::string sid;
+							std::string password;
+						};
+						struct SourceSLSParameters
+						{
+							std::string project;
+							std::string roleName;
+							std::string logStore;
+							std::string consumePosition;
+							std::string consumerGroup;
+						};
+						struct SourcePrometheusParameters
+						{
+							std::string clusterId;
+							std::string dataType;
+							std::string labels;
+						};
+						SourceSLSParameters sourceSLSParameters;
+						SourceMQTTParameters sourceMQTTParameters;
+						SourceRabbitMQParameters sourceRabbitMQParameters;
+						SourceMNSParameters sourceMNSParameters;
+						SourceKafkaParameters sourceKafkaParameters;
+						SourceDTSParameters sourceDTSParameters;
+						SourcePrometheusParameters sourcePrometheusParameters;
+						SourceRocketMQParameters sourceRocketMQParameters;
+					};
+					struct Sink
+					{
+						struct SinkMNSParameters
+						{
+							struct QueueName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Body
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct IsBase64Encode
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							IsBase64Encode isBase64Encode;
+							QueueName queueName;
+							Body body;
+						};
+						struct SinkRabbitMQParameters
+						{
+							struct InstanceId
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct VirtualHostName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct TargetType
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Exchange
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct RoutingKey
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct QueueName1
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Body2
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct MessageId
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Properties
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							Exchange exchange;
+							RoutingKey routingKey;
+							QueueName1 queueName1;
+							VirtualHostName virtualHostName;
+							InstanceId instanceId;
+							Body2 body2;
+							TargetType targetType;
+							Properties properties;
+							MessageId messageId;
+						};
+						struct SinkFcParameters
+						{
+							struct ServiceName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct FunctionName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Concurrency
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Qualifier
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct InvocationType
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Body3
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							FunctionName functionName;
+							ServiceName serviceName;
+							Concurrency concurrency;
+							Body3 body3;
+							InvocationType invocationType;
+							Qualifier qualifier;
+						};
+						struct SinkKafkaParameters
+						{
+							struct InstanceId4
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Topic
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Acks
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Key
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Value
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct SaslUser
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							Acks acks;
+							SaslUser saslUser;
+							Value value;
+							InstanceId4 instanceId4;
+							Topic topic;
+							Key key;
+						};
+						struct SinkRocketMQParameters
+						{
+							struct InstanceId5
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Topic6
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Body7
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Properties8
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Keys
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Tags
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							Topic6 topic6;
+							Body7 body7;
+							Keys keys;
+							Properties8 properties8;
+							InstanceId5 instanceId5;
+							Tags tags;
+						};
+						struct SinkSLSParameters
+						{
+							struct Project
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct LogStore
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Topic9
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Body10
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct RoleName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							Project project;
+							RoleName roleName;
+							LogStore logStore;
+							Body10 body10;
+							Topic9 topic9;
+						};
+						struct SinkFnfParameters
+						{
+							struct FlowName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct ExecutionName
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct Input
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							struct RoleName11
+							{
+								std::string _template;
+								std::string form;
+								std::string value;
+							};
+							ExecutionName executionName;
+							Input input;
+							FlowName flowName;
+							RoleName11 roleName11;
+						};
+						SinkMNSParameters sinkMNSParameters;
+						SinkFnfParameters sinkFnfParameters;
+						SinkRocketMQParameters sinkRocketMQParameters;
+						SinkSLSParameters sinkSLSParameters;
+						SinkRabbitMQParameters sinkRabbitMQParameters;
+						SinkFcParameters sinkFcParameters;
+						SinkKafkaParameters sinkKafkaParameters;
+					};
+					struct RunOptions
+					{
+						struct RetryStrategy
+						{
+							std::string pushRetryStrategy;
+							float maximumRetryAttempts;
+							float maximumEventAgeInSeconds;
+						};
+						struct DeadLetterQueue
+						{
+							std::string arn;
+						};
+						struct BatchWindow
+						{
+							int countBasedWindow;
+							int timeBasedWindow;
+						};
+						std::string errorsTolerance;
+						DeadLetterQueue deadLetterQueue;
+						BatchWindow batchWindow;
+						int maximumTasks;
+						RetryStrategy retryStrategy;
+					};
+					struct TransformsItem
+					{
+						std::string arn;
+					};
+					std::string status;
+					std::string filterPattern;
+					std::string description;
+					Sink sink;
+					std::vector<TransformsItem> transforms;
+					std::string tag;
+					std::string eventStreamingName;
+					Source source;
+					RunOptions runOptions;
+				};
+
+
+				GetEventStreamingResult();
+				explicit GetEventStreamingResult(const std::string &payload);
+				~GetEventStreamingResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETEVENTSTREAMINGRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/GetRuleRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETRULEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETRULEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetRuleRequest : public RpcServiceRequest {
+public:
+	GetRuleRequest();
+	~GetRuleRequest();
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string ruleName_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETRULEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/GetRuleResult.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_GETRULERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_GETRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT GetRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct TargetsItem
+					{
+						struct DeadLetterQueue
+						{
+							std::string arn;
+						};
+						struct ParamListItem
+						{
+							std::string _template;
+							std::string form;
+							std::string value;
+							std::string resourceKey;
+						};
+						std::string errorsTolerance;
+						DeadLetterQueue deadLetterQueue;
+						std::string pushRetryStrategy;
+						std::string type;
+						std::string endpoint;
+						std::string id;
+						std::string detailMap;
+						std::string pushSelector;
+						std::vector<TargetsItem::ParamListItem> paramList;
+					};
+					std::string status;
+					std::string eventBusName;
+					std::string filterPattern;
+					std::string description;
+					long createdTimestamp;
+					std::string ruleARN;
+					std::vector<TargetsItem> targets;
+					std::string ruleName;
+				};
+
+
+				GetRuleResult();
+				explicit GetRuleResult(const std::string &payload);
+				~GetRuleResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_GETRULERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListAliyunOfficialEventSourcesRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTALIYUNOFFICIALEVENTSOURCESREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTALIYUNOFFICIALEVENTSOURCESREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListAliyunOfficialEventSourcesRequest : public RpcServiceRequest {
+public:
+	ListAliyunOfficialEventSourcesRequest();
+	~ListAliyunOfficialEventSourcesRequest();
+	std::string getType() const;
+	void setType(const std::string &type);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+	std::string getNamePrefix() const;
+	void setNamePrefix(const std::string &namePrefix);
+
+private:
+	std::string type_;
+	std::string nextToken_;
+	int limit_;
+	std::string namePrefix_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTALIYUNOFFICIALEVENTSOURCESREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListAliyunOfficialEventSourcesResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTALIYUNOFFICIALEVENTSOURCESRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTALIYUNOFFICIALEVENTSOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListAliyunOfficialEventSourcesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct EventSourceListItem
+					{
+						struct EventTypesItem
+						{
+							std::string groupName;
+							std::string description;
+							std::string eventSourceName;
+							std::string shortName;
+							std::string name;
+						};
+						std::string status;
+						std::string eventBusName;
+						std::string type;
+						std::string description;
+						float ctime;
+						std::string fullName;
+						std::vector<EventSourceListItem::EventTypesItem> eventTypes;
+						std::string arn;
+						std::string name;
+					};
+					std::string nextToken;
+					std::vector<EventSourceListItem> eventSourceList;
+					float total;
+				};
+
+
+				ListAliyunOfficialEventSourcesResult();
+				explicit ListAliyunOfficialEventSourcesResult(const std::string &payload);
+				~ListAliyunOfficialEventSourcesResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTALIYUNOFFICIALEVENTSOURCESRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListApiDestinationsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTAPIDESTINATIONSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTAPIDESTINATIONSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListApiDestinationsRequest : public RpcServiceRequest {
+public:
+	ListApiDestinationsRequest();
+	~ListApiDestinationsRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+	long getMaxResults() const;
+	void setMaxResults(long maxResults);
+	std::string getApiDestinationNamePrefix() const;
+	void setApiDestinationNamePrefix(const std::string &apiDestinationNamePrefix);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::string nextToken_;
+	std::string connectionName_;
+	long maxResults_;
+	std::string apiDestinationNamePrefix_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTAPIDESTINATIONSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListApiDestinationsResult.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTAPIDESTINATIONSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTAPIDESTINATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListApiDestinationsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ApiDestinationsItem
+					{
+						struct HttpApiParameters
+						{
+							struct ApiParametersItem
+							{
+								std::string defaultValue;
+								std::string type;
+								std::string description;
+								std::string in;
+								std::string name;
+							};
+							std::string endpoint;
+							std::vector<ApiParametersItem> apiParameters;
+							std::string method;
+						};
+						std::string connectionName;
+						long gmtCreate;
+						std::string description;
+						HttpApiParameters httpApiParameters;
+						std::string apiDestinationName;
+						long invocationRateLimitPerSecond;
+					};
+					std::string nextToken;
+					std::vector<ApiDestinationsItem> apiDestinations;
+					float total;
+					float maxResults;
+				};
+
+
+				ListApiDestinationsResult();
+				explicit ListApiDestinationsResult(const std::string &payload);
+				~ListApiDestinationsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTAPIDESTINATIONSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListConnectionsRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTCONNECTIONSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTCONNECTIONSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListConnectionsRequest : public RpcServiceRequest {
+public:
+	ListConnectionsRequest();
+	~ListConnectionsRequest();
+	std::string getConnectionNamePrefix() const;
+	void setConnectionNamePrefix(const std::string &connectionNamePrefix);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	long getMaxResults() const;
+	void setMaxResults(long maxResults);
+
+private:
+	std::string connectionNamePrefix_;
+	std::string nextToken_;
+	long maxResults_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTCONNECTIONSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListConnectionsResult.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTCONNECTIONSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTCONNECTIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListConnectionsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ConnectionsItem
+					{
+						struct NetworkParameters
+						{
+							std::string vpcId;
+							std::string networkType;
+							std::string securityGroupId;
+							std::string vswitcheId;
+						};
+						struct AuthParameters
+						{
+							struct ApiKeyAuthParameters
+							{
+								std::string apiKeyValue;
+								std::string apiKeyName;
+							};
+							struct BasicAuthParameters
+							{
+								std::string username;
+								std::string password;
+							};
+							struct InvocationHttpParameters
+							{
+								struct BodyParametersItem
+								{
+									std::string isValueSecret;
+									std::string value;
+									std::string key;
+								};
+								struct HeaderParametersItem
+								{
+									std::string isValueSecret;
+									std::string value;
+									std::string key;
+								};
+								struct QueryStringParametersItem
+								{
+									std::string isValueSecret;
+									std::string value;
+									std::string key;
+								};
+								std::vector<HeaderParametersItem> headerParameters;
+								std::vector<QueryStringParametersItem> queryStringParameters;
+								std::vector<BodyParametersItem> bodyParameters;
+							};
+							struct OAuthParameters
+							{
+								struct ClientParameters
+								{
+									std::string clientSecret;
+									std::string clientID;
+								};
+								struct OAuthHttpParameters
+								{
+									struct BodyParametersItem4
+									{
+										std::string isValueSecret;
+										std::string value;
+										std::string key;
+									};
+									struct HeaderParametersItem5
+									{
+										std::string isValueSecret;
+										std::string value;
+										std::string key;
+									};
+									struct QueryStringParametersItem6
+									{
+										std::string isValueSecret;
+										std::string value;
+										std::string key;
+									};
+									std::vector<HeaderParametersItem5> headerParameters2;
+									std::vector<BodyParametersItem4> bodyParameters1;
+									std::vector<QueryStringParametersItem6> queryStringParameters3;
+								};
+								ClientParameters clientParameters;
+								OAuthHttpParameters oAuthHttpParameters;
+								std::string authorizationEndpoint;
+								std::string httpMethod;
+							};
+							InvocationHttpParameters invocationHttpParameters;
+							BasicAuthParameters basicAuthParameters;
+							ApiKeyAuthParameters apiKeyAuthParameters;
+							OAuthParameters oAuthParameters;
+							std::string authorizationType;
+						};
+						std::string connectionName;
+						AuthParameters authParameters;
+						long gmtCreate;
+						std::string description;
+						NetworkParameters networkParameters;
+						long id;
+					};
+					std::vector<ConnectionsItem> connections;
+					std::string nextToken;
+					float total;
+					float maxResults;
+				};
+
+
+				ListConnectionsResult();
+				explicit ListConnectionsResult(const std::string &payload);
+				~ListConnectionsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTCONNECTIONSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListEventBusesRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTBUSESREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTBUSESREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListEventBusesRequest : public RpcServiceRequest {
+public:
+	ListEventBusesRequest();
+	~ListEventBusesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+	std::string getNamePrefix() const;
+	void setNamePrefix(const std::string &namePrefix);
+	std::string getEventBusType() const;
+	void setEventBusType(const std::string &eventBusType);
+
+private:
+	std::string nextToken_;
+	int limit_;
+	std::string namePrefix_;
+	std::string eventBusType_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTBUSESREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListEventBusesResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTBUSESRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTBUSESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListEventBusesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct EventBusesItem
+					{
+						std::string eventBusName;
+						std::string description;
+						long createTimestamp;
+						std::string eventBusARN;
+					};
+					std::vector<EventBusesItem> eventBuses;
+					std::string nextToken;
+					int total;
+				};
+
+
+				ListEventBusesResult();
+				explicit ListEventBusesResult(const std::string &payload);
+				~ListEventBusesResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTBUSESRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListEventStreamingsRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTSTREAMINGSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTSTREAMINGSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListEventStreamingsRequest : public RpcServiceRequest {
+public:
+	ListEventStreamingsRequest();
+	~ListEventStreamingsRequest();
+	std::string getSourceArn() const;
+	void setSourceArn(const std::string &sourceArn);
+	std::string getSinkType() const;
+	void setSinkType(const std::string &sinkType);
+	std::string getSinkArn() const;
+	void setSinkArn(const std::string &sinkArn);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+	std::string getSourceType() const;
+	void setSourceType(const std::string &sourceType);
+	std::string getNamePrefix() const;
+	void setNamePrefix(const std::string &namePrefix);
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+
+private:
+	std::string sourceArn_;
+	std::string sinkType_;
+	std::string sinkArn_;
+	std::string nextToken_;
+	int limit_;
+	std::string sourceType_;
+	std::string namePrefix_;
+	std::string tag_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTSTREAMINGSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListEventStreamingsResult.h

@@ -0,0 +1,484 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTSTREAMINGSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTSTREAMINGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListEventStreamingsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct EventStreamingsItem
+					{
+						struct Source
+						{
+							struct SourceMNSParameters
+							{
+								bool isBase64Decode;
+								std::string regionId;
+								std::string queueName;
+							};
+							struct SourceRabbitMQParameters
+							{
+								std::string virtualHostName;
+								std::string instanceId;
+								std::string regionId;
+								std::string queueName;
+							};
+							struct SourceRocketMQParameters
+							{
+								std::string instanceId;
+								long timestamp;
+								std::string offset;
+								std::string groupID;
+								std::string instancePassword;
+								std::string instanceNetwork;
+								std::string instanceUsername;
+								std::string instanceEndpoint;
+								std::string instanceVpcId;
+								std::string instanceVSwitchIds;
+								std::string instanceSecurityGroupId;
+								std::string regionId;
+								std::string tag;
+								std::string authType;
+								std::string topic;
+								std::string instanceType;
+							};
+							struct SourceKafkaParameters
+							{
+								std::string offsetReset;
+								std::string vpcId;
+								std::string instanceId;
+								std::string vSwitchIds;
+								std::string network;
+								std::string securityGroupId;
+								std::string regionId;
+								std::string topic;
+								std::string consumerGroup;
+							};
+							struct SourceMQTTParameters
+							{
+								std::string instanceId;
+								std::string regionId;
+								std::string topic;
+							};
+							struct SourceDTSParameters
+							{
+								std::string taskId;
+								std::string username;
+								std::string initCheckPoint;
+								std::string topic;
+								std::string brokerUrl;
+								std::string sid;
+								std::string password;
+							};
+							struct SourceSLSParameters
+							{
+								std::string project;
+								std::string roleName;
+								std::string logStore;
+								std::string consumePosition;
+								std::string consumerGroup;
+							};
+							SourceSLSParameters sourceSLSParameters;
+							SourceMQTTParameters sourceMQTTParameters;
+							SourceRabbitMQParameters sourceRabbitMQParameters;
+							SourceMNSParameters sourceMNSParameters;
+							SourceKafkaParameters sourceKafkaParameters;
+							SourceDTSParameters sourceDTSParameters;
+							SourceRocketMQParameters sourceRocketMQParameters;
+						};
+						struct Sink
+						{
+							struct SinkMNSParameters
+							{
+								struct QueueName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Body
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct IsBase64Encode
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								IsBase64Encode isBase64Encode;
+								QueueName queueName;
+								Body body;
+							};
+							struct SinkFcParameters
+							{
+								struct ServiceName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct FunctionName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Concurrency
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Qualifier
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct InvocationType
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Body1
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								FunctionName functionName;
+								ServiceName serviceName;
+								Concurrency concurrency;
+								InvocationType invocationType;
+								Body1 body1;
+								Qualifier qualifier;
+							};
+							struct SinkRabbitMQParameters
+							{
+								struct InstanceId
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct VirtualHostName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct TargetType
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Exchange
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct RoutingKey
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct QueueName2
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Body3
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct MessageId
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Properties
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								Exchange exchange;
+								RoutingKey routingKey;
+								QueueName2 queueName2;
+								VirtualHostName virtualHostName;
+								InstanceId instanceId;
+								Body3 body3;
+								TargetType targetType;
+								Properties properties;
+								MessageId messageId;
+							};
+							struct SinkKafkaParameters
+							{
+								struct InstanceId4
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Topic
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Acks
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Key
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Value
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct SaslUser
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								Acks acks;
+								SaslUser saslUser;
+								Value value;
+								InstanceId4 instanceId4;
+								Topic topic;
+								Key key;
+							};
+							struct SinkRocketMQParameters
+							{
+								struct InstanceId5
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Topic6
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Body7
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Properties8
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Keys
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Tags
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								Topic6 topic6;
+								Body7 body7;
+								Keys keys;
+								Properties8 properties8;
+								InstanceId5 instanceId5;
+								Tags tags;
+							};
+							struct SinkSLSParameters
+							{
+								struct Project
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct LogStore
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Topic9
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Body10
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct RoleName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								Project project;
+								RoleName roleName;
+								LogStore logStore;
+								Body10 body10;
+								Topic9 topic9;
+							};
+							struct SinkFnfParameters
+							{
+								struct FlowName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct ExecutionName
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct Input
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								struct RoleName11
+								{
+									std::string _template;
+									std::string form;
+									std::string value;
+								};
+								ExecutionName executionName;
+								Input input;
+								FlowName flowName;
+								RoleName11 roleName11;
+							};
+							SinkMNSParameters sinkMNSParameters;
+							SinkFnfParameters sinkFnfParameters;
+							SinkRocketMQParameters sinkRocketMQParameters;
+							SinkSLSParameters sinkSLSParameters;
+							SinkRabbitMQParameters sinkRabbitMQParameters;
+							SinkFcParameters sinkFcParameters;
+							SinkKafkaParameters sinkKafkaParameters;
+						};
+						struct RunOptions
+						{
+							struct RetryStrategy
+							{
+								std::string pushRetryStrategy;
+								float maximumRetryAttempts;
+								float maximumEventAgeInSeconds;
+							};
+							struct DeadLetterQueue
+							{
+								std::string arn;
+							};
+							struct BatchWindow
+							{
+								int countBasedWindow;
+								int timeBasedWindow;
+							};
+							std::string errorsTolerance;
+							DeadLetterQueue deadLetterQueue;
+							BatchWindow batchWindow;
+							int maximumTasks;
+							RetryStrategy retryStrategy;
+						};
+						struct TransformsItem
+						{
+							std::string arn;
+						};
+						std::string status;
+						std::string filterPattern;
+						std::string description;
+						Sink sink;
+						std::vector<EventStreamingsItem::TransformsItem> transforms;
+						std::string tag;
+						std::string eventStreamingName;
+						Source source;
+						RunOptions runOptions;
+					};
+					std::vector<EventStreamingsItem> eventStreamings;
+					std::string nextToken;
+					int total;
+				};
+
+
+				ListEventStreamingsResult();
+				explicit ListEventStreamingsResult(const std::string &payload);
+				~ListEventStreamingsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTEVENTSTREAMINGSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListRulesRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTRULESREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTRULESREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListRulesRequest : public RpcServiceRequest {
+public:
+	ListRulesRequest();
+	~ListRulesRequest();
+	std::string getRuleNamePrefix() const;
+	void setRuleNamePrefix(const std::string &ruleNamePrefix);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+
+private:
+	std::string ruleNamePrefix_;
+	std::string eventBusName_;
+	std::string nextToken_;
+	int limit_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTRULESREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListRulesResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTRULESRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListRulesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct RulesItem
+					{
+						struct TargetsItem
+						{
+							std::string errorsTolerance;
+							std::string type;
+							std::string endpoint;
+							std::string id;
+							std::string pushSelector;
+						};
+						std::string status;
+						std::string eventBusName;
+						std::string filterPattern;
+						std::string description;
+						long createdTimestamp;
+						std::string ruleARN;
+						std::vector<RulesItem::TargetsItem> targets;
+						std::string detailMap;
+						std::string ruleName;
+					};
+					std::string nextToken;
+					int total;
+					std::vector<RulesItem> rules;
+				};
+
+
+				ListRulesResult();
+				explicit ListRulesResult(const std::string &payload);
+				~ListRulesResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTRULESRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListTargetsRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTTARGETSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTTARGETSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListTargetsRequest : public RpcServiceRequest {
+public:
+	ListTargetsRequest();
+	~ListTargetsRequest();
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+	std::string getArn() const;
+	void setArn(const std::string &arn);
+
+private:
+	std::string ruleName_;
+	std::string eventBusName_;
+	std::string nextToken_;
+	int limit_;
+	std::string arn_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTTARGETSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListTargetsResult.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTTARGETSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTTARGETSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListTargetsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct TargetsItem
+					{
+						struct ParamListItem
+						{
+							std::string _template;
+							std::string form;
+							std::string value;
+							std::string resourceKey;
+						};
+						std::string errorsTolerance;
+						std::string eventBusName;
+						std::string type;
+						std::string endpoint;
+						std::string id;
+						std::string detailMap;
+						std::string pushSelector;
+						std::vector<TargetsItem::ParamListItem> paramList;
+						std::string ruleName;
+					};
+					std::string nextToken;
+					int total;
+					std::vector<TargetsItem> targets;
+				};
+
+
+				ListTargetsResult();
+				explicit ListTargetsResult(const std::string &payload);
+				~ListTargetsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTTARGETSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/ListUserDefinedEventSourcesRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTUSERDEFINEDEVENTSOURCESREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTUSERDEFINEDEVENTSOURCESREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListUserDefinedEventSourcesRequest : public RpcServiceRequest {
+public:
+	ListUserDefinedEventSourcesRequest();
+	~ListUserDefinedEventSourcesRequest();
+	std::string getType() const;
+	void setType(const std::string &type);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+	std::string getNamePrefix() const;
+	void setNamePrefix(const std::string &namePrefix);
+
+private:
+	std::string type_;
+	std::string eventBusName_;
+	std::string nextToken_;
+	int limit_;
+	std::string namePrefix_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTUSERDEFINEDEVENTSOURCESREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/ListUserDefinedEventSourcesResult.h

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTUSERDEFINEDEVENTSOURCESRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTUSERDEFINEDEVENTSOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT ListUserDefinedEventSourcesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct EventSourceListItem
+					{
+						struct SourceMNSParameters
+						{
+							bool isBase64Decode;
+							std::string regionId;
+							std::string queueName;
+						};
+						struct SourceRocketMQParameters
+						{
+							std::string instanceId;
+							float timestamp;
+							std::string offset;
+							std::string groupId;
+							std::string instanceNetwork;
+							std::string instancePassword;
+							std::string instanceUsername;
+							std::string instanceEndpoint;
+							std::string instanceVpcId;
+							std::string instanceVSwitchIds;
+							std::string instanceSecurityGroupId;
+							std::string regionId;
+							std::string tag;
+							std::string authType;
+							std::string topic;
+							std::string instanceType;
+						};
+						struct SourceRabbitMQParameters
+						{
+							std::string virtualHostName;
+							std::string instanceId;
+							std::string regionId;
+							std::string queueName;
+						};
+						struct SourceSLSParameters
+						{
+							std::string project;
+							std::string roleName;
+							std::string logStore;
+							std::string consumePosition;
+						};
+						struct SourceHttpEventParameters
+						{
+							std::string type;
+							std::string securityConfig;
+							std::vector<std::string> ip;
+							std::vector<std::string> referer;
+							std::vector<std::string> publicWebHookUrl;
+							std::vector<std::string> method;
+							std::vector<std::string> vpcWebHookUrl;
+						};
+						struct SourceKafkaParameters
+						{
+							std::string offsetReset;
+							std::string vpcId;
+							std::string instanceId;
+							int maximumTasks;
+							std::string vSwitchIds;
+							std::string network;
+							std::string securityGroupId;
+							std::string regionId;
+							std::string topic;
+							std::string consumerGroup;
+						};
+						struct SourceScheduledEventParameters
+						{
+							std::string timeZone;
+							std::string userData;
+							std::string schedule;
+						};
+						std::string status;
+						std::string eventBusName;
+						std::string description;
+						SourceRabbitMQParameters sourceRabbitMQParameters;
+						SourceMNSParameters sourceMNSParameters;
+						std::string externalSourceType;
+						std::string externalSourceConfig;
+						SourceHttpEventParameters sourceHttpEventParameters;
+						std::string name;
+						SourceSLSParameters sourceSLSParameters;
+						std::string type;
+						float ctime;
+						SourceKafkaParameters sourceKafkaParameters;
+						SourceScheduledEventParameters sourceScheduledEventParameters;
+						SourceRocketMQParameters sourceRocketMQParameters;
+						std::string arn;
+					};
+					std::string nextToken;
+					std::vector<EventSourceListItem> eventSourceList;
+					float total;
+				};
+
+
+				ListUserDefinedEventSourcesResult();
+				explicit ListUserDefinedEventSourcesResult(const std::string &payload);
+				~ListUserDefinedEventSourcesResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_LISTUSERDEFINEDEVENTSOURCESRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/PauseEventStreamingRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_PAUSEEVENTSTREAMINGREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_PAUSEEVENTSTREAMINGREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT PauseEventStreamingRequest : public RpcServiceRequest {
+public:
+	PauseEventStreamingRequest();
+	~PauseEventStreamingRequest();
+	std::string getEventStreamingName() const;
+	void setEventStreamingName(const std::string &eventStreamingName);
+
+private:
+	std::string eventStreamingName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_PAUSEEVENTSTREAMINGREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/PauseEventStreamingResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_PAUSEEVENTSTREAMINGRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_PAUSEEVENTSTREAMINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT PauseEventStreamingResult : public ServiceResult
+			{
+			public:
+
+
+				PauseEventStreamingResult();
+				explicit PauseEventStreamingResult(const std::string &payload);
+				~PauseEventStreamingResult();
+				std::string getMessage()const;
+				bool getData()const;
+				bool getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				bool code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_PAUSEEVENTSTREAMINGRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/PutTargetsRequest.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_PUTTARGETSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_PUTTARGETSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT PutTargetsRequest : public RpcServiceRequest {
+public:
+	struct Targets {
+		std::string endpoint;
+		std::string pushRetryStrategy;
+		struct ParamListItem {
+			std::string _template;
+			std::string resourceKey;
+			std::string form;
+			std::string value;
+		};
+		ParamListItem paramListItem;
+		std::vector<ParamListItem> paramList;
+		std::string id;
+		struct DeadLetterQueue {
+			std::string arn;
+		};
+		DeadLetterQueue deadLetterQueue;
+		std::string type;
+		std::string errorsTolerance;
+	};
+	PutTargetsRequest();
+	~PutTargetsRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::vector<Targets> getTargets() const;
+	void setTargets(const std::vector<Targets> &targets);
+
+private:
+	std::string clientToken_;
+	std::string ruleName_;
+	std::string eventBusName_;
+	std::vector<Targets> targets_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_PUTTARGETSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/PutTargetsResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_PUTTARGETSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_PUTTARGETSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT PutTargetsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ErrorEntriesItem
+					{
+						std::string entryId;
+						std::string errorCode;
+						std::string errorMessage;
+					};
+					std::vector<ErrorEntriesItem> errorEntries;
+					int errorEntriesCount;
+				};
+
+
+				PutTargetsResult();
+				explicit PutTargetsResult(const std::string &payload);
+				~PutTargetsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_PUTTARGETSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryEventRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryEventRequest : public RpcServiceRequest {
+public:
+	QueryEventRequest();
+	~QueryEventRequest();
+	std::string getEventId() const;
+	void setEventId(const std::string &eventId);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getEventSource() const;
+	void setEventSource(const std::string &eventSource);
+
+private:
+	std::string eventId_;
+	std::string eventBusName_;
+	std::string eventSource_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryEventResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryEventResult : public ServiceResult
+			{
+			public:
+
+
+				QueryEventResult();
+				explicit QueryEventResult(const std::string &payload);
+				~QueryEventResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryEventTracesRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTTRACESREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTTRACESREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryEventTracesRequest : public RpcServiceRequest {
+public:
+	QueryEventTracesRequest();
+	~QueryEventTracesRequest();
+	std::string getEventId() const;
+	void setEventId(const std::string &eventId);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string eventId_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTTRACESREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryEventTracesResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTTRACESRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTTRACESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryEventTracesResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					long actionTime;
+					std::string eventBusName;
+					std::string action;
+					std::string notifyLatency;
+					std::string eventSource;
+					std::string notifyStatus;
+					std::string endpoint;
+					long notifyTime;
+					std::string eventId;
+					long receivedTime;
+					std::string ruleMatchingTime;
+					std::string ruleName;
+				};
+
+
+				QueryEventTracesResult();
+				explicit QueryEventTracesResult(const std::string &payload);
+				~QueryEventTracesResult();
+				std::string getMessage()const;
+				std::vector<DataItem> getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::vector<DataItem> data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYEVENTTRACESRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryTracedEventByEventIdRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTBYEVENTIDREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTBYEVENTIDREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryTracedEventByEventIdRequest : public RpcServiceRequest {
+public:
+	QueryTracedEventByEventIdRequest();
+	~QueryTracedEventByEventIdRequest();
+	std::string getEventId() const;
+	void setEventId(const std::string &eventId);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getEventSource() const;
+	void setEventSource(const std::string &eventSource);
+
+private:
+	std::string eventId_;
+	std::string eventBusName_;
+	std::string eventSource_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTBYEVENTIDREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryTracedEventByEventIdResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTBYEVENTIDRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTBYEVENTIDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryTracedEventByEventIdResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					struct EventsItem
+					{
+						std::string eventBusName;
+						std::string eventSource;
+						std::string eventType;
+						std::string eventId;
+						long eventReceivedTime;
+					};
+					std::string nextToken;
+					std::vector<DataItem::EventsItem> events;
+					int total;
+				};
+
+
+				QueryTracedEventByEventIdResult();
+				explicit QueryTracedEventByEventIdResult(const std::string &payload);
+				~QueryTracedEventByEventIdResult();
+				std::string getMessage()const;
+				std::vector<DataItem> getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::vector<DataItem> data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTBYEVENTIDRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryTracedEventsRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryTracedEventsRequest : public RpcServiceRequest {
+public:
+	QueryTracedEventsRequest();
+	~QueryTracedEventsRequest();
+	std::string getMatchedRule() const;
+	void setMatchedRule(const std::string &matchedRule);
+	long getStartTime() const;
+	void setStartTime(long startTime);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getEventSource() const;
+	void setEventSource(const std::string &eventSource);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getLimit() const;
+	void setLimit(int limit);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	std::string getEventType() const;
+	void setEventType(const std::string &eventType);
+
+private:
+	std::string matchedRule_;
+	long startTime_;
+	std::string eventBusName_;
+	std::string eventSource_;
+	std::string nextToken_;
+	int limit_;
+	long endTime_;
+	std::string eventType_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/QueryTracedEventsResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT QueryTracedEventsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct EventsItem
+					{
+						std::string eventBusName;
+						std::string eventSource;
+						std::string eventType;
+						std::string eventId;
+						long eventReceivedTime;
+					};
+					std::string nextToken;
+					std::vector<EventsItem> events;
+					int total;
+				};
+
+
+				QueryTracedEventsResult();
+				explicit QueryTracedEventsResult(const std::string &payload);
+				~QueryTracedEventsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_QUERYTRACEDEVENTSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/StartEventStreamingRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_STARTEVENTSTREAMINGREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_STARTEVENTSTREAMINGREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT StartEventStreamingRequest : public RpcServiceRequest {
+public:
+	StartEventStreamingRequest();
+	~StartEventStreamingRequest();
+	std::string getEventStreamingName() const;
+	void setEventStreamingName(const std::string &eventStreamingName);
+
+private:
+	std::string eventStreamingName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_STARTEVENTSTREAMINGREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/StartEventStreamingResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_STARTEVENTSTREAMINGRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_STARTEVENTSTREAMINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT StartEventStreamingResult : public ServiceResult
+			{
+			public:
+
+
+				StartEventStreamingResult();
+				explicit StartEventStreamingResult(const std::string &payload);
+				~StartEventStreamingResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_STARTEVENTSTREAMINGRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/TestEventPatternRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_TESTEVENTPATTERNREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_TESTEVENTPATTERNREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT TestEventPatternRequest : public RpcServiceRequest {
+public:
+	TestEventPatternRequest();
+	~TestEventPatternRequest();
+	std::string getEventPattern() const;
+	void setEventPattern(const std::string &eventPattern);
+	std::string getEvent() const;
+	void setEvent(const std::string &event);
+
+private:
+	std::string eventPattern_;
+	std::string event_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_TESTEVENTPATTERNREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/TestEventPatternResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_TESTEVENTPATTERNRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_TESTEVENTPATTERNRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT TestEventPatternResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					bool result;
+				};
+
+
+				TestEventPatternResult();
+				explicit TestEventPatternResult(const std::string &payload);
+				~TestEventPatternResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_TESTEVENTPATTERNRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateApiDestinationRequest.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEAPIDESTINATIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEAPIDESTINATIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateApiDestinationRequest : public RpcServiceRequest {
+public:
+	struct HttpApiParameters {
+		std::string endpoint;
+		std::string method;
+		struct ApiParametersItem {
+			std::string in;
+			std::string name;
+			std::string description;
+			std::string defaultValue;
+			std::string type;
+		};
+		ApiParametersItem apiParametersItem;
+		std::vector<ApiParametersItem> apiParameters;
+	};
+	UpdateApiDestinationRequest();
+	~UpdateApiDestinationRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getApiDestinationName() const;
+	void setApiDestinationName(const std::string &apiDestinationName);
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+	HttpApiParameters getHttpApiParameters() const;
+	void setHttpApiParameters(const HttpApiParameters &httpApiParameters);
+	long getInvocationRateLimitPerSecond() const;
+	void setInvocationRateLimitPerSecond(long invocationRateLimitPerSecond);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::string apiDestinationName_;
+	std::string connectionName_;
+	HttpApiParameters httpApiParameters_;
+	long invocationRateLimitPerSecond_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEAPIDESTINATIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateApiDestinationResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEAPIDESTINATIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEAPIDESTINATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateApiDestinationResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateApiDestinationResult();
+				explicit UpdateApiDestinationResult(const std::string &payload);
+				~UpdateApiDestinationResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+				std::string getApiDestinationName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+				std::string apiDestinationName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEAPIDESTINATIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateConnectionRequest.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATECONNECTIONREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATECONNECTIONREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateConnectionRequest : public RpcServiceRequest {
+public:
+	struct NetworkParameters {
+		std::string vpcId;
+		std::string securityGroupId;
+		std::string networkType;
+		std::string vswitcheId;
+	};
+	struct AuthParameters {
+		struct BasicAuthParameters {
+			std::string password;
+			std::string username;
+		};
+		BasicAuthParameters basicAuthParameters;
+		struct ApiKeyAuthParameters {
+			std::string apiKeyName;
+			std::string apiKeyValue;
+		};
+		ApiKeyAuthParameters apiKeyAuthParameters;
+		std::string authorizationType;
+		struct InvocationHttpParameters {
+			struct BodyParametersItem {
+				std::string isValueSecret;
+				std::string value;
+				std::string key;
+			};
+			BodyParametersItem bodyParametersItem;
+			std::vector<BodyParametersItem> bodyParameters;
+			struct HeaderParametersItem {
+				std::string isValueSecret;
+				std::string value;
+				std::string key;
+			};
+			HeaderParametersItem headerParametersItem;
+			std::vector<HeaderParametersItem> headerParameters;
+			struct QueryStringParametersItem {
+				std::string isValueSecret;
+				std::string value;
+				std::string key;
+			};
+			QueryStringParametersItem queryStringParametersItem;
+			std::vector<QueryStringParametersItem> queryStringParameters;
+		};
+		InvocationHttpParameters invocationHttpParameters;
+		struct OAuthParameters {
+			struct ClientParameters {
+				std::string clientID;
+				std::string clientSecret;
+			};
+			ClientParameters clientParameters;
+			std::string authorizationEndpoint;
+			std::string httpMethod;
+			struct OAuthHttpParameters {
+				struct BodyParametersItem {
+					std::string isValueSecret;
+					std::string value;
+					std::string key;
+				};
+				BodyParametersItem bodyParametersItem;
+				std::vector<BodyParametersItem> bodyParameters;
+				struct HeaderParametersItem {
+					std::string isValueSecret;
+					std::string value;
+					std::string key;
+				};
+				HeaderParametersItem headerParametersItem;
+				std::vector<HeaderParametersItem> headerParameters;
+				struct QueryStringParametersItem {
+					std::string isValueSecret;
+					std::string value;
+					std::string key;
+				};
+				QueryStringParametersItem queryStringParametersItem;
+				std::vector<QueryStringParametersItem> queryStringParameters;
+			};
+			OAuthHttpParameters oAuthHttpParameters;
+		};
+		OAuthParameters oAuthParameters;
+	};
+	UpdateConnectionRequest();
+	~UpdateConnectionRequest();
+	std::string getConnectionName() const;
+	void setConnectionName(const std::string &connectionName);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	NetworkParameters getNetworkParameters() const;
+	void setNetworkParameters(const NetworkParameters &networkParameters);
+	AuthParameters getAuthParameters() const;
+	void setAuthParameters(const AuthParameters &authParameters);
+
+private:
+	std::string connectionName_;
+	std::string description_;
+	NetworkParameters networkParameters_;
+	AuthParameters authParameters_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATECONNECTIONREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateConnectionResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATECONNECTIONRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATECONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateConnectionResult();
+				explicit UpdateConnectionResult(const std::string &payload);
+				~UpdateConnectionResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATECONNECTIONRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateEventBusRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTBUSREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTBUSREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateEventBusRequest : public RpcServiceRequest {
+public:
+	UpdateEventBusRequest();
+	~UpdateEventBusRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+
+private:
+	std::string description_;
+	std::string eventBusName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTBUSREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateEventBusResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTBUSRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTBUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateEventBusResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateEventBusResult();
+				explicit UpdateEventBusResult(const std::string &payload);
+				~UpdateEventBusResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTBUSRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateEventSourceRequest.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSOURCEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSOURCEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateEventSourceRequest : public RpcServiceRequest {
+public:
+	struct SourceMNSParameters {
+		std::string queueName;
+		std::string regionId;
+		bool isBase64Decode;
+	};
+	struct SourceRabbitMQParameters {
+		std::string queueName;
+		std::string virtualHostName;
+		std::string instanceId;
+		std::string regionId;
+	};
+	struct SourceRocketMQParameters {
+		std::string instanceSecurityGroupId;
+		std::string offset;
+		std::string groupID;
+		std::string instanceUsername;
+		std::string authType;
+		std::string instancePassword;
+		std::string instanceNetwork;
+		std::string instanceVSwitchIds;
+		std::string instanceId;
+		std::string instanceVpcId;
+		std::string instanceEndpoint;
+		std::string regionId;
+		std::string topic;
+		std::string instanceType;
+		std::string tag;
+		long timestamp;
+	};
+	struct SourceSLSParameters {
+		std::string roleName;
+		std::string project;
+		std::string logStore;
+		std::string consumePosition;
+	};
+	struct SourceScheduledEventParameters {
+		std::string schedule;
+		std::string userData;
+		std::string timeZone;
+	};
+	struct SourceKafkaParameters {
+		std::string instanceId;
+		std::string consumerGroup;
+		std::string regionId;
+		std::string vSwitchIds;
+		std::string vpcId;
+		std::string securityGroupId;
+		std::string topic;
+		std::string offsetReset;
+		int maximumTasks;
+		std::string network;
+	};
+	struct SourceHttpEventParameters {
+		std::string string;
+		std::vector<std::string> referer;
+		std::string string;
+		std::vector<std::string> method;
+		std::string string;
+		std::vector<std::string> ip;
+		std::string securityConfig;
+		std::string type;
+	};
+	UpdateEventSourceRequest();
+	~UpdateEventSourceRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	SourceMNSParameters getSourceMNSParameters() const;
+	void setSourceMNSParameters(const SourceMNSParameters &sourceMNSParameters);
+	bool getLinkedExternalSource() const;
+	void setLinkedExternalSource(bool linkedExternalSource);
+	std::string getExternalSourceType() const;
+	void setExternalSourceType(const std::string &externalSourceType);
+	std::map<std::string, std::string> getExternalSourceConfig() const;
+	void setExternalSourceConfig(const std::map<std::string, std::string> &externalSourceConfig);
+	SourceRabbitMQParameters getSourceRabbitMQParameters() const;
+	void setSourceRabbitMQParameters(const SourceRabbitMQParameters &sourceRabbitMQParameters);
+	SourceRocketMQParameters getSourceRocketMQParameters() const;
+	void setSourceRocketMQParameters(const SourceRocketMQParameters &sourceRocketMQParameters);
+	SourceSLSParameters getSourceSLSParameters() const;
+	void setSourceSLSParameters(const SourceSLSParameters &sourceSLSParameters);
+	SourceScheduledEventParameters getSourceScheduledEventParameters() const;
+	void setSourceScheduledEventParameters(const SourceScheduledEventParameters &sourceScheduledEventParameters);
+	SourceKafkaParameters getSourceKafkaParameters() const;
+	void setSourceKafkaParameters(const SourceKafkaParameters &sourceKafkaParameters);
+	SourceHttpEventParameters getSourceHttpEventParameters() const;
+	void setSourceHttpEventParameters(const SourceHttpEventParameters &sourceHttpEventParameters);
+	std::string getEventSourceName() const;
+	void setEventSourceName(const std::string &eventSourceName);
+
+private:
+	std::string description_;
+	std::string eventBusName_;
+	SourceMNSParameters sourceMNSParameters_;
+	bool linkedExternalSource_;
+	std::string externalSourceType_;
+	std::map<std::string, std::string> externalSourceConfig_;
+	SourceRabbitMQParameters sourceRabbitMQParameters_;
+	SourceRocketMQParameters sourceRocketMQParameters_;
+	SourceSLSParameters sourceSLSParameters_;
+	SourceScheduledEventParameters sourceScheduledEventParameters_;
+	SourceKafkaParameters sourceKafkaParameters_;
+	SourceHttpEventParameters sourceHttpEventParameters_;
+	std::string eventSourceName_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSOURCEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateEventSourceResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSOURCERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateEventSourceResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateEventSourceResult();
+				explicit UpdateEventSourceResult(const std::string &payload);
+				~UpdateEventSourceResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSOURCERESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateEventStreamingRequest.h

@@ -0,0 +1,471 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSTREAMINGREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSTREAMINGREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateEventStreamingRequest : public RpcServiceRequest {
+public:
+	struct Sink {
+		struct SinkRabbitMQParameters {
+			struct RoutingKey {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoutingKey routingKey;
+			struct QueueName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			QueueName queueName;
+			struct VirtualHostName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VirtualHostName virtualHostName;
+			struct InstanceId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceId instanceId;
+			struct TargetType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			TargetType targetType;
+			struct MessageId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			MessageId messageId;
+			struct Exchange {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Exchange exchange;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct Properties {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Properties properties;
+		};
+		SinkRabbitMQParameters sinkRabbitMQParameters;
+		struct SinkMNSParameters {
+			struct QueueName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			QueueName queueName;
+			struct IsBase64Encode {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			IsBase64Encode isBase64Encode;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+		};
+		SinkMNSParameters sinkMNSParameters;
+		struct SinkKafkaParameters {
+			struct InstanceId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceId instanceId;
+			struct Acks {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Acks acks;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct SaslUser {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			SaslUser saslUser;
+			struct Value {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Value value;
+			struct Key {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Key key;
+		};
+		SinkKafkaParameters sinkKafkaParameters;
+		struct SinkFnfParameters {
+			struct Input {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Input input;
+			struct ExecutionName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			ExecutionName executionName;
+			struct RoleName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoleName roleName;
+			struct FlowName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			FlowName flowName;
+		};
+		SinkFnfParameters sinkFnfParameters;
+		struct SinkFcParameters {
+			struct InvocationType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InvocationType invocationType;
+			struct FunctionName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			FunctionName functionName;
+			struct Qualifier {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Qualifier qualifier;
+			struct ServiceName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			ServiceName serviceName;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct Concurrency {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Concurrency concurrency;
+		};
+		SinkFcParameters sinkFcParameters;
+		struct SinkPrometheusParameters {
+			struct VSwitchId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VSwitchId vSwitchId;
+			struct Password {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Password password;
+			struct Data {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Data data;
+			struct VpcId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			VpcId vpcId;
+			struct SecurityGroupId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			SecurityGroupId securityGroupId;
+			struct AuthorizationType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			AuthorizationType authorizationType;
+			struct NetworkType {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			NetworkType networkType;
+			struct URL {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			URL uRL;
+			struct Username {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Username username;
+		};
+		SinkPrometheusParameters sinkPrometheusParameters;
+		struct SinkSLSParameters {
+			struct RoleName {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			RoleName roleName;
+			struct Project {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Project project;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct LogStore {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			LogStore logStore;
+		};
+		SinkSLSParameters sinkSLSParameters;
+		struct SinkRocketMQParameters {
+			struct InstanceId {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			InstanceId instanceId;
+			struct Keys {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Keys keys;
+			struct Topic {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Topic topic;
+			struct Body {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Body body;
+			struct Properties {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Properties properties;
+			struct Tags {
+				std::string _template;
+				std::string form;
+				std::string value;
+			};
+			Tags tags;
+		};
+		SinkRocketMQParameters sinkRocketMQParameters;
+	};
+	struct Transforms {
+		std::string arn;
+	};
+	struct Source {
+		struct SourceMQTTParameters {
+			std::string instanceId;
+			std::string regionId;
+			std::string topic;
+		};
+		SourceMQTTParameters sourceMQTTParameters;
+		struct SourceRocketMQParameters {
+			std::string instanceSecurityGroupId;
+			std::string offset;
+			std::string groupID;
+			std::string instanceUsername;
+			std::string authType;
+			std::string instancePassword;
+			std::string instanceVSwitchIds;
+			std::string instanceNetwork;
+			std::string instanceId;
+			std::string instanceEndpoint;
+			std::string instanceVpcId;
+			std::string regionId;
+			std::string topic;
+			std::string instanceType;
+			std::string tag;
+			long timestamp;
+		};
+		SourceRocketMQParameters sourceRocketMQParameters;
+		struct SourceSLSParameters {
+			std::string roleName;
+		};
+		SourceSLSParameters sourceSLSParameters;
+		struct SourcePrometheusParameters {
+			std::string dataType;
+			std::string clusterId;
+			std::string labels;
+		};
+		SourcePrometheusParameters sourcePrometheusParameters;
+		struct SourceDTSParameters {
+			std::string brokerUrl;
+			std::string password;
+			long initCheckPoint;
+			std::string topic;
+			std::string taskId;
+			std::string sid;
+			std::string username;
+		};
+		SourceDTSParameters sourceDTSParameters;
+		struct SourceKafkaParameters {
+			std::string instanceId;
+			std::string consumerGroup;
+			std::string regionId;
+			std::string vSwitchIds;
+			std::string vpcId;
+			std::string securityGroupId;
+			std::string topic;
+			std::string offsetReset;
+			std::string network;
+		};
+		SourceKafkaParameters sourceKafkaParameters;
+		struct SourceMNSParameters {
+			std::string queueName;
+			std::string regionId;
+			bool isBase64Decode;
+		};
+		SourceMNSParameters sourceMNSParameters;
+		struct SourceRabbitMQParameters {
+			std::string queueName;
+			std::string virtualHostName;
+			std::string instanceId;
+			std::string regionId;
+		};
+		SourceRabbitMQParameters sourceRabbitMQParameters;
+	};
+	struct RunOptions {
+		struct BatchWindow {
+			int countBasedWindow;
+			int timeBasedWindow;
+		};
+		BatchWindow batchWindow;
+		struct RetryStrategy {
+			std::string pushRetryStrategy;
+			long maximumRetryAttempts;
+			long maximumEventAgeInSeconds;
+		};
+		RetryStrategy retryStrategy;
+		struct DeadLetterQueue {
+			std::string arn;
+		};
+		DeadLetterQueue deadLetterQueue;
+		long maximumTasks;
+		std::string errorsTolerance;
+	};
+	UpdateEventStreamingRequest();
+	~UpdateEventStreamingRequest();
+	Sink getSink() const;
+	void setSink(const Sink &sink);
+	std::vector<Transforms> getTransforms() const;
+	void setTransforms(const std::vector<Transforms> &transforms);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getFilterPattern() const;
+	void setFilterPattern(const std::string &filterPattern);
+	Source getSource() const;
+	void setSource(const Source &source);
+	RunOptions getRunOptions() const;
+	void setRunOptions(const RunOptions &runOptions);
+	std::string getEventStreamingName() const;
+	void setEventStreamingName(const std::string &eventStreamingName);
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+
+private:
+	Sink sink_;
+	std::vector<Transforms> transforms_;
+	std::string description_;
+	std::string filterPattern_;
+	Source source_;
+	RunOptions runOptions_;
+	std::string eventStreamingName_;
+	std::string tag_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSTREAMINGREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateEventStreamingResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSTREAMINGRESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSTREAMINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateEventStreamingResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateEventStreamingResult();
+				explicit UpdateEventStreamingResult(const std::string &payload);
+				~UpdateEventStreamingResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATEEVENTSTREAMINGRESULT_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateRuleRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATERULEREQUEST_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATERULEREQUEST_H_
+
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eventbridge {
+namespace Model {
+class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateRuleRequest : public RpcServiceRequest {
+public:
+	UpdateRuleRequest();
+	~UpdateRuleRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getEventBusName() const;
+	void setEventBusName(const std::string &eventBusName);
+	std::string getFilterPattern() const;
+	void setFilterPattern(const std::string &filterPattern);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::string ruleName_;
+	std::string eventBusName_;
+	std::string filterPattern_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eventbridge
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATERULEREQUEST_H_

eventbridge/include/alibabacloud/eventbridge/model/UpdateRuleResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATERULERESULT_H_
+#define ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATERULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eventbridge/EventbridgeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eventbridge
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EVENTBRIDGE_EXPORT UpdateRuleResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateRuleResult();
+				explicit UpdateRuleResult(const std::string &payload);
+				~UpdateRuleResult();
+				std::string getMessage()const;
+				bool getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				bool data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EVENTBRIDGE_MODEL_UPDATERULERESULT_H_

eventbridge/src/EventbridgeClient.cc

@@ -0,0 +1,1601 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/EventbridgeClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Eventbridge;
+using namespace AlibabaCloud::Eventbridge::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "eventbridge";
+}
+
+EventbridgeClient::EventbridgeClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+EventbridgeClient::EventbridgeClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+EventbridgeClient::EventbridgeClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+EventbridgeClient::~EventbridgeClient()
+{}
+
+EventbridgeClient::CreateApiDestinationOutcome EventbridgeClient::createApiDestination(const CreateApiDestinationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateApiDestinationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateApiDestinationOutcome(CreateApiDestinationResult(outcome.result()));
+	else
+		return CreateApiDestinationOutcome(outcome.error());
+}
+
+void EventbridgeClient::createApiDestinationAsync(const CreateApiDestinationRequest& request, const CreateApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createApiDestination(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateApiDestinationOutcomeCallable EventbridgeClient::createApiDestinationCallable(const CreateApiDestinationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateApiDestinationOutcome()>>(
+			[this, request]()
+			{
+			return this->createApiDestination(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::CreateConnectionOutcome EventbridgeClient::createConnection(const CreateConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateConnectionOutcome(CreateConnectionResult(outcome.result()));
+	else
+		return CreateConnectionOutcome(outcome.error());
+}
+
+void EventbridgeClient::createConnectionAsync(const CreateConnectionRequest& request, const CreateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateConnectionOutcomeCallable EventbridgeClient::createConnectionCallable(const CreateConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->createConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::CreateEventBusOutcome EventbridgeClient::createEventBus(const CreateEventBusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateEventBusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateEventBusOutcome(CreateEventBusResult(outcome.result()));
+	else
+		return CreateEventBusOutcome(outcome.error());
+}
+
+void EventbridgeClient::createEventBusAsync(const CreateEventBusRequest& request, const CreateEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createEventBus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateEventBusOutcomeCallable EventbridgeClient::createEventBusCallable(const CreateEventBusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateEventBusOutcome()>>(
+			[this, request]()
+			{
+			return this->createEventBus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::CreateEventSourceOutcome EventbridgeClient::createEventSource(const CreateEventSourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateEventSourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateEventSourceOutcome(CreateEventSourceResult(outcome.result()));
+	else
+		return CreateEventSourceOutcome(outcome.error());
+}
+
+void EventbridgeClient::createEventSourceAsync(const CreateEventSourceRequest& request, const CreateEventSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createEventSource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateEventSourceOutcomeCallable EventbridgeClient::createEventSourceCallable(const CreateEventSourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateEventSourceOutcome()>>(
+			[this, request]()
+			{
+			return this->createEventSource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::CreateEventStreamingOutcome EventbridgeClient::createEventStreaming(const CreateEventStreamingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateEventStreamingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateEventStreamingOutcome(CreateEventStreamingResult(outcome.result()));
+	else
+		return CreateEventStreamingOutcome(outcome.error());
+}
+
+void EventbridgeClient::createEventStreamingAsync(const CreateEventStreamingRequest& request, const CreateEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createEventStreaming(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateEventStreamingOutcomeCallable EventbridgeClient::createEventStreamingCallable(const CreateEventStreamingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateEventStreamingOutcome()>>(
+			[this, request]()
+			{
+			return this->createEventStreaming(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::CreateRuleOutcome EventbridgeClient::createRule(const CreateRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateRuleOutcome(CreateRuleResult(outcome.result()));
+	else
+		return CreateRuleOutcome(outcome.error());
+}
+
+void EventbridgeClient::createRuleAsync(const CreateRuleRequest& request, const CreateRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateRuleOutcomeCallable EventbridgeClient::createRuleCallable(const CreateRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::CreateServiceLinkedRoleForProductOutcome EventbridgeClient::createServiceLinkedRoleForProduct(const CreateServiceLinkedRoleForProductRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServiceLinkedRoleForProductOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServiceLinkedRoleForProductOutcome(CreateServiceLinkedRoleForProductResult(outcome.result()));
+	else
+		return CreateServiceLinkedRoleForProductOutcome(outcome.error());
+}
+
+void EventbridgeClient::createServiceLinkedRoleForProductAsync(const CreateServiceLinkedRoleForProductRequest& request, const CreateServiceLinkedRoleForProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServiceLinkedRoleForProduct(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::CreateServiceLinkedRoleForProductOutcomeCallable EventbridgeClient::createServiceLinkedRoleForProductCallable(const CreateServiceLinkedRoleForProductRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServiceLinkedRoleForProductOutcome()>>(
+			[this, request]()
+			{
+			return this->createServiceLinkedRoleForProduct(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteApiDestinationOutcome EventbridgeClient::deleteApiDestination(const DeleteApiDestinationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteApiDestinationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteApiDestinationOutcome(DeleteApiDestinationResult(outcome.result()));
+	else
+		return DeleteApiDestinationOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteApiDestinationAsync(const DeleteApiDestinationRequest& request, const DeleteApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteApiDestination(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteApiDestinationOutcomeCallable EventbridgeClient::deleteApiDestinationCallable(const DeleteApiDestinationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteApiDestinationOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteApiDestination(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteConnectionOutcome EventbridgeClient::deleteConnection(const DeleteConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteConnectionOutcome(DeleteConnectionResult(outcome.result()));
+	else
+		return DeleteConnectionOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteConnectionAsync(const DeleteConnectionRequest& request, const DeleteConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteConnectionOutcomeCallable EventbridgeClient::deleteConnectionCallable(const DeleteConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteEventBusOutcome EventbridgeClient::deleteEventBus(const DeleteEventBusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteEventBusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteEventBusOutcome(DeleteEventBusResult(outcome.result()));
+	else
+		return DeleteEventBusOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteEventBusAsync(const DeleteEventBusRequest& request, const DeleteEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteEventBus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteEventBusOutcomeCallable EventbridgeClient::deleteEventBusCallable(const DeleteEventBusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteEventBusOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteEventBus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteEventSourceOutcome EventbridgeClient::deleteEventSource(const DeleteEventSourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteEventSourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteEventSourceOutcome(DeleteEventSourceResult(outcome.result()));
+	else
+		return DeleteEventSourceOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteEventSourceAsync(const DeleteEventSourceRequest& request, const DeleteEventSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteEventSource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteEventSourceOutcomeCallable EventbridgeClient::deleteEventSourceCallable(const DeleteEventSourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteEventSourceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteEventSource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteEventStreamingOutcome EventbridgeClient::deleteEventStreaming(const DeleteEventStreamingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteEventStreamingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteEventStreamingOutcome(DeleteEventStreamingResult(outcome.result()));
+	else
+		return DeleteEventStreamingOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteEventStreamingAsync(const DeleteEventStreamingRequest& request, const DeleteEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteEventStreaming(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteEventStreamingOutcomeCallable EventbridgeClient::deleteEventStreamingCallable(const DeleteEventStreamingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteEventStreamingOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteEventStreaming(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteRuleOutcome EventbridgeClient::deleteRule(const DeleteRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteRuleOutcome(DeleteRuleResult(outcome.result()));
+	else
+		return DeleteRuleOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteRuleAsync(const DeleteRuleRequest& request, const DeleteRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteRuleOutcomeCallable EventbridgeClient::deleteRuleCallable(const DeleteRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DeleteTargetsOutcome EventbridgeClient::deleteTargets(const DeleteTargetsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTargetsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTargetsOutcome(DeleteTargetsResult(outcome.result()));
+	else
+		return DeleteTargetsOutcome(outcome.error());
+}
+
+void EventbridgeClient::deleteTargetsAsync(const DeleteTargetsRequest& request, const DeleteTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTargets(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DeleteTargetsOutcomeCallable EventbridgeClient::deleteTargetsCallable(const DeleteTargetsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTargetsOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTargets(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::DisableRuleOutcome EventbridgeClient::disableRule(const DisableRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableRuleOutcome(DisableRuleResult(outcome.result()));
+	else
+		return DisableRuleOutcome(outcome.error());
+}
+
+void EventbridgeClient::disableRuleAsync(const DisableRuleRequest& request, const DisableRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::DisableRuleOutcomeCallable EventbridgeClient::disableRuleCallable(const DisableRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->disableRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::EnableRuleOutcome EventbridgeClient::enableRule(const EnableRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableRuleOutcome(EnableRuleResult(outcome.result()));
+	else
+		return EnableRuleOutcome(outcome.error());
+}
+
+void EventbridgeClient::enableRuleAsync(const EnableRuleRequest& request, const EnableRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::EnableRuleOutcomeCallable EventbridgeClient::enableRuleCallable(const EnableRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->enableRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::GetApiDestinationOutcome EventbridgeClient::getApiDestination(const GetApiDestinationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetApiDestinationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetApiDestinationOutcome(GetApiDestinationResult(outcome.result()));
+	else
+		return GetApiDestinationOutcome(outcome.error());
+}
+
+void EventbridgeClient::getApiDestinationAsync(const GetApiDestinationRequest& request, const GetApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getApiDestination(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::GetApiDestinationOutcomeCallable EventbridgeClient::getApiDestinationCallable(const GetApiDestinationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetApiDestinationOutcome()>>(
+			[this, request]()
+			{
+			return this->getApiDestination(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::GetConnectionOutcome EventbridgeClient::getConnection(const GetConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetConnectionOutcome(GetConnectionResult(outcome.result()));
+	else
+		return GetConnectionOutcome(outcome.error());
+}
+
+void EventbridgeClient::getConnectionAsync(const GetConnectionRequest& request, const GetConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::GetConnectionOutcomeCallable EventbridgeClient::getConnectionCallable(const GetConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->getConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::GetEventBusOutcome EventbridgeClient::getEventBus(const GetEventBusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetEventBusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetEventBusOutcome(GetEventBusResult(outcome.result()));
+	else
+		return GetEventBusOutcome(outcome.error());
+}
+
+void EventbridgeClient::getEventBusAsync(const GetEventBusRequest& request, const GetEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getEventBus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::GetEventBusOutcomeCallable EventbridgeClient::getEventBusCallable(const GetEventBusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetEventBusOutcome()>>(
+			[this, request]()
+			{
+			return this->getEventBus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::GetEventStreamingOutcome EventbridgeClient::getEventStreaming(const GetEventStreamingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetEventStreamingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetEventStreamingOutcome(GetEventStreamingResult(outcome.result()));
+	else
+		return GetEventStreamingOutcome(outcome.error());
+}
+
+void EventbridgeClient::getEventStreamingAsync(const GetEventStreamingRequest& request, const GetEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getEventStreaming(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::GetEventStreamingOutcomeCallable EventbridgeClient::getEventStreamingCallable(const GetEventStreamingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetEventStreamingOutcome()>>(
+			[this, request]()
+			{
+			return this->getEventStreaming(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::GetRuleOutcome EventbridgeClient::getRule(const GetRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRuleOutcome(GetRuleResult(outcome.result()));
+	else
+		return GetRuleOutcome(outcome.error());
+}
+
+void EventbridgeClient::getRuleAsync(const GetRuleRequest& request, const GetRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::GetRuleOutcomeCallable EventbridgeClient::getRuleCallable(const GetRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->getRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListAliyunOfficialEventSourcesOutcome EventbridgeClient::listAliyunOfficialEventSources(const ListAliyunOfficialEventSourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAliyunOfficialEventSourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAliyunOfficialEventSourcesOutcome(ListAliyunOfficialEventSourcesResult(outcome.result()));
+	else
+		return ListAliyunOfficialEventSourcesOutcome(outcome.error());
+}
+
+void EventbridgeClient::listAliyunOfficialEventSourcesAsync(const ListAliyunOfficialEventSourcesRequest& request, const ListAliyunOfficialEventSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAliyunOfficialEventSources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListAliyunOfficialEventSourcesOutcomeCallable EventbridgeClient::listAliyunOfficialEventSourcesCallable(const ListAliyunOfficialEventSourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAliyunOfficialEventSourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listAliyunOfficialEventSources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListApiDestinationsOutcome EventbridgeClient::listApiDestinations(const ListApiDestinationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApiDestinationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApiDestinationsOutcome(ListApiDestinationsResult(outcome.result()));
+	else
+		return ListApiDestinationsOutcome(outcome.error());
+}
+
+void EventbridgeClient::listApiDestinationsAsync(const ListApiDestinationsRequest& request, const ListApiDestinationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApiDestinations(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListApiDestinationsOutcomeCallable EventbridgeClient::listApiDestinationsCallable(const ListApiDestinationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApiDestinationsOutcome()>>(
+			[this, request]()
+			{
+			return this->listApiDestinations(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListConnectionsOutcome EventbridgeClient::listConnections(const ListConnectionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListConnectionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListConnectionsOutcome(ListConnectionsResult(outcome.result()));
+	else
+		return ListConnectionsOutcome(outcome.error());
+}
+
+void EventbridgeClient::listConnectionsAsync(const ListConnectionsRequest& request, const ListConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listConnections(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListConnectionsOutcomeCallable EventbridgeClient::listConnectionsCallable(const ListConnectionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListConnectionsOutcome()>>(
+			[this, request]()
+			{
+			return this->listConnections(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListEventBusesOutcome EventbridgeClient::listEventBuses(const ListEventBusesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListEventBusesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListEventBusesOutcome(ListEventBusesResult(outcome.result()));
+	else
+		return ListEventBusesOutcome(outcome.error());
+}
+
+void EventbridgeClient::listEventBusesAsync(const ListEventBusesRequest& request, const ListEventBusesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listEventBuses(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListEventBusesOutcomeCallable EventbridgeClient::listEventBusesCallable(const ListEventBusesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListEventBusesOutcome()>>(
+			[this, request]()
+			{
+			return this->listEventBuses(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListEventStreamingsOutcome EventbridgeClient::listEventStreamings(const ListEventStreamingsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListEventStreamingsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListEventStreamingsOutcome(ListEventStreamingsResult(outcome.result()));
+	else
+		return ListEventStreamingsOutcome(outcome.error());
+}
+
+void EventbridgeClient::listEventStreamingsAsync(const ListEventStreamingsRequest& request, const ListEventStreamingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listEventStreamings(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListEventStreamingsOutcomeCallable EventbridgeClient::listEventStreamingsCallable(const ListEventStreamingsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListEventStreamingsOutcome()>>(
+			[this, request]()
+			{
+			return this->listEventStreamings(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListRulesOutcome EventbridgeClient::listRules(const ListRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListRulesOutcome(ListRulesResult(outcome.result()));
+	else
+		return ListRulesOutcome(outcome.error());
+}
+
+void EventbridgeClient::listRulesAsync(const ListRulesRequest& request, const ListRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListRulesOutcomeCallable EventbridgeClient::listRulesCallable(const ListRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListTargetsOutcome EventbridgeClient::listTargets(const ListTargetsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTargetsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTargetsOutcome(ListTargetsResult(outcome.result()));
+	else
+		return ListTargetsOutcome(outcome.error());
+}
+
+void EventbridgeClient::listTargetsAsync(const ListTargetsRequest& request, const ListTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTargets(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListTargetsOutcomeCallable EventbridgeClient::listTargetsCallable(const ListTargetsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTargetsOutcome()>>(
+			[this, request]()
+			{
+			return this->listTargets(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::ListUserDefinedEventSourcesOutcome EventbridgeClient::listUserDefinedEventSources(const ListUserDefinedEventSourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUserDefinedEventSourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUserDefinedEventSourcesOutcome(ListUserDefinedEventSourcesResult(outcome.result()));
+	else
+		return ListUserDefinedEventSourcesOutcome(outcome.error());
+}
+
+void EventbridgeClient::listUserDefinedEventSourcesAsync(const ListUserDefinedEventSourcesRequest& request, const ListUserDefinedEventSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUserDefinedEventSources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::ListUserDefinedEventSourcesOutcomeCallable EventbridgeClient::listUserDefinedEventSourcesCallable(const ListUserDefinedEventSourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUserDefinedEventSourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listUserDefinedEventSources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::PauseEventStreamingOutcome EventbridgeClient::pauseEventStreaming(const PauseEventStreamingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PauseEventStreamingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PauseEventStreamingOutcome(PauseEventStreamingResult(outcome.result()));
+	else
+		return PauseEventStreamingOutcome(outcome.error());
+}
+
+void EventbridgeClient::pauseEventStreamingAsync(const PauseEventStreamingRequest& request, const PauseEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pauseEventStreaming(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::PauseEventStreamingOutcomeCallable EventbridgeClient::pauseEventStreamingCallable(const PauseEventStreamingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PauseEventStreamingOutcome()>>(
+			[this, request]()
+			{
+			return this->pauseEventStreaming(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::PutTargetsOutcome EventbridgeClient::putTargets(const PutTargetsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PutTargetsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PutTargetsOutcome(PutTargetsResult(outcome.result()));
+	else
+		return PutTargetsOutcome(outcome.error());
+}
+
+void EventbridgeClient::putTargetsAsync(const PutTargetsRequest& request, const PutTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, putTargets(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::PutTargetsOutcomeCallable EventbridgeClient::putTargetsCallable(const PutTargetsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PutTargetsOutcome()>>(
+			[this, request]()
+			{
+			return this->putTargets(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::QueryEventOutcome EventbridgeClient::queryEvent(const QueryEventRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryEventOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryEventOutcome(QueryEventResult(outcome.result()));
+	else
+		return QueryEventOutcome(outcome.error());
+}
+
+void EventbridgeClient::queryEventAsync(const QueryEventRequest& request, const QueryEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryEvent(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::QueryEventOutcomeCallable EventbridgeClient::queryEventCallable(const QueryEventRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryEventOutcome()>>(
+			[this, request]()
+			{
+			return this->queryEvent(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::QueryEventTracesOutcome EventbridgeClient::queryEventTraces(const QueryEventTracesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryEventTracesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryEventTracesOutcome(QueryEventTracesResult(outcome.result()));
+	else
+		return QueryEventTracesOutcome(outcome.error());
+}
+
+void EventbridgeClient::queryEventTracesAsync(const QueryEventTracesRequest& request, const QueryEventTracesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryEventTraces(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::QueryEventTracesOutcomeCallable EventbridgeClient::queryEventTracesCallable(const QueryEventTracesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryEventTracesOutcome()>>(
+			[this, request]()
+			{
+			return this->queryEventTraces(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::QueryTracedEventByEventIdOutcome EventbridgeClient::queryTracedEventByEventId(const QueryTracedEventByEventIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryTracedEventByEventIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryTracedEventByEventIdOutcome(QueryTracedEventByEventIdResult(outcome.result()));
+	else
+		return QueryTracedEventByEventIdOutcome(outcome.error());
+}
+
+void EventbridgeClient::queryTracedEventByEventIdAsync(const QueryTracedEventByEventIdRequest& request, const QueryTracedEventByEventIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryTracedEventByEventId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::QueryTracedEventByEventIdOutcomeCallable EventbridgeClient::queryTracedEventByEventIdCallable(const QueryTracedEventByEventIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryTracedEventByEventIdOutcome()>>(
+			[this, request]()
+			{
+			return this->queryTracedEventByEventId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::QueryTracedEventsOutcome EventbridgeClient::queryTracedEvents(const QueryTracedEventsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryTracedEventsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryTracedEventsOutcome(QueryTracedEventsResult(outcome.result()));
+	else
+		return QueryTracedEventsOutcome(outcome.error());
+}
+
+void EventbridgeClient::queryTracedEventsAsync(const QueryTracedEventsRequest& request, const QueryTracedEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryTracedEvents(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::QueryTracedEventsOutcomeCallable EventbridgeClient::queryTracedEventsCallable(const QueryTracedEventsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryTracedEventsOutcome()>>(
+			[this, request]()
+			{
+			return this->queryTracedEvents(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::StartEventStreamingOutcome EventbridgeClient::startEventStreaming(const StartEventStreamingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartEventStreamingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartEventStreamingOutcome(StartEventStreamingResult(outcome.result()));
+	else
+		return StartEventStreamingOutcome(outcome.error());
+}
+
+void EventbridgeClient::startEventStreamingAsync(const StartEventStreamingRequest& request, const StartEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startEventStreaming(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::StartEventStreamingOutcomeCallable EventbridgeClient::startEventStreamingCallable(const StartEventStreamingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartEventStreamingOutcome()>>(
+			[this, request]()
+			{
+			return this->startEventStreaming(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::TestEventPatternOutcome EventbridgeClient::testEventPattern(const TestEventPatternRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TestEventPatternOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TestEventPatternOutcome(TestEventPatternResult(outcome.result()));
+	else
+		return TestEventPatternOutcome(outcome.error());
+}
+
+void EventbridgeClient::testEventPatternAsync(const TestEventPatternRequest& request, const TestEventPatternAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, testEventPattern(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::TestEventPatternOutcomeCallable EventbridgeClient::testEventPatternCallable(const TestEventPatternRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TestEventPatternOutcome()>>(
+			[this, request]()
+			{
+			return this->testEventPattern(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::UpdateApiDestinationOutcome EventbridgeClient::updateApiDestination(const UpdateApiDestinationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateApiDestinationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateApiDestinationOutcome(UpdateApiDestinationResult(outcome.result()));
+	else
+		return UpdateApiDestinationOutcome(outcome.error());
+}
+
+void EventbridgeClient::updateApiDestinationAsync(const UpdateApiDestinationRequest& request, const UpdateApiDestinationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateApiDestination(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::UpdateApiDestinationOutcomeCallable EventbridgeClient::updateApiDestinationCallable(const UpdateApiDestinationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateApiDestinationOutcome()>>(
+			[this, request]()
+			{
+			return this->updateApiDestination(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::UpdateConnectionOutcome EventbridgeClient::updateConnection(const UpdateConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateConnectionOutcome(UpdateConnectionResult(outcome.result()));
+	else
+		return UpdateConnectionOutcome(outcome.error());
+}
+
+void EventbridgeClient::updateConnectionAsync(const UpdateConnectionRequest& request, const UpdateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::UpdateConnectionOutcomeCallable EventbridgeClient::updateConnectionCallable(const UpdateConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->updateConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::UpdateEventBusOutcome EventbridgeClient::updateEventBus(const UpdateEventBusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateEventBusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateEventBusOutcome(UpdateEventBusResult(outcome.result()));
+	else
+		return UpdateEventBusOutcome(outcome.error());
+}
+
+void EventbridgeClient::updateEventBusAsync(const UpdateEventBusRequest& request, const UpdateEventBusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateEventBus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::UpdateEventBusOutcomeCallable EventbridgeClient::updateEventBusCallable(const UpdateEventBusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateEventBusOutcome()>>(
+			[this, request]()
+			{
+			return this->updateEventBus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::UpdateEventSourceOutcome EventbridgeClient::updateEventSource(const UpdateEventSourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateEventSourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateEventSourceOutcome(UpdateEventSourceResult(outcome.result()));
+	else
+		return UpdateEventSourceOutcome(outcome.error());
+}
+
+void EventbridgeClient::updateEventSourceAsync(const UpdateEventSourceRequest& request, const UpdateEventSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateEventSource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::UpdateEventSourceOutcomeCallable EventbridgeClient::updateEventSourceCallable(const UpdateEventSourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateEventSourceOutcome()>>(
+			[this, request]()
+			{
+			return this->updateEventSource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::UpdateEventStreamingOutcome EventbridgeClient::updateEventStreaming(const UpdateEventStreamingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateEventStreamingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateEventStreamingOutcome(UpdateEventStreamingResult(outcome.result()));
+	else
+		return UpdateEventStreamingOutcome(outcome.error());
+}
+
+void EventbridgeClient::updateEventStreamingAsync(const UpdateEventStreamingRequest& request, const UpdateEventStreamingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateEventStreaming(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::UpdateEventStreamingOutcomeCallable EventbridgeClient::updateEventStreamingCallable(const UpdateEventStreamingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateEventStreamingOutcome()>>(
+			[this, request]()
+			{
+			return this->updateEventStreaming(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EventbridgeClient::UpdateRuleOutcome EventbridgeClient::updateRule(const UpdateRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateRuleOutcome(UpdateRuleResult(outcome.result()));
+	else
+		return UpdateRuleOutcome(outcome.error());
+}
+
+void EventbridgeClient::updateRuleAsync(const UpdateRuleRequest& request, const UpdateRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EventbridgeClient::UpdateRuleOutcomeCallable EventbridgeClient::updateRuleCallable(const UpdateRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->updateRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

eventbridge/src/model/CreateApiDestinationRequest.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateApiDestinationRequest.h>
+
+using AlibabaCloud::Eventbridge::Model::CreateApiDestinationRequest;
+
+CreateApiDestinationRequest::CreateApiDestinationRequest()
+    : RpcServiceRequest("eventbridge", "2020-04-01", "CreateApiDestination") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateApiDestinationRequest::~CreateApiDestinationRequest() {}
+
+std::string CreateApiDestinationRequest::getConnectionName() const {
+  return connectionName_;
+}
+
+void CreateApiDestinationRequest::setConnectionName(const std::string &connectionName) {
+  connectionName_ = connectionName;
+  setParameter(std::string("ConnectionName"), connectionName);
+}
+
+std::string CreateApiDestinationRequest::getDescription() const {
+  return description_;
+}
+
+void CreateApiDestinationRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+CreateApiDestinationRequest::HttpApiParameters CreateApiDestinationRequest::getHttpApiParameters() const {
+  return httpApiParameters_;
+}
+
+void CreateApiDestinationRequest::setHttpApiParameters(const CreateApiDestinationRequest::HttpApiParameters &httpApiParameters) {
+  httpApiParameters_ = httpApiParameters;
+  setParameter(std::string("HttpApiParameters") + ".Endpoint", httpApiParameters.endpoint);
+  setParameter(std::string("HttpApiParameters") + ".Method", httpApiParameters.method);
+  for(int dep1 = 0; dep1 != httpApiParameters.apiParameters.size(); dep1++) {
+    setParameter(std::string("HttpApiParameters") + ".ApiParameters." + std::to_string(dep1 + 1) + ".In", httpApiParameters.apiParameters[dep1].in);
+    setParameter(std::string("HttpApiParameters") + ".ApiParameters." + std::to_string(dep1 + 1) + ".Name", httpApiParameters.apiParameters[dep1].name);
+    setParameter(std::string("HttpApiParameters") + ".ApiParameters." + std::to_string(dep1 + 1) + ".Description", httpApiParameters.apiParameters[dep1].description);
+    setParameter(std::string("HttpApiParameters") + ".ApiParameters." + std::to_string(dep1 + 1) + ".DefaultValue", httpApiParameters.apiParameters[dep1].defaultValue);
+    setParameter(std::string("HttpApiParameters") + ".ApiParameters." + std::to_string(dep1 + 1) + ".Type", httpApiParameters.apiParameters[dep1].type);
+  }
+}
+
+std::string CreateApiDestinationRequest::getApiDestinationName() const {
+  return apiDestinationName_;
+}
+
+void CreateApiDestinationRequest::setApiDestinationName(const std::string &apiDestinationName) {
+  apiDestinationName_ = apiDestinationName;
+  setParameter(std::string("ApiDestinationName"), apiDestinationName);
+}
+
+long CreateApiDestinationRequest::getInvocationRateLimitPerSecond() const {
+  return invocationRateLimitPerSecond_;
+}
+
+void CreateApiDestinationRequest::setInvocationRateLimitPerSecond(long invocationRateLimitPerSecond) {
+  invocationRateLimitPerSecond_ = invocationRateLimitPerSecond;
+  setParameter(std::string("InvocationRateLimitPerSecond"), std::to_string(invocationRateLimitPerSecond));
+}
+

eventbridge/src/model/CreateApiDestinationResult.cc

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateApiDestinationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Eventbridge;
+using namespace AlibabaCloud::Eventbridge::Model;
+
+CreateApiDestinationResult::CreateApiDestinationResult() :
+	ServiceResult()
+{}
+
+CreateApiDestinationResult::CreateApiDestinationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateApiDestinationResult::~CreateApiDestinationResult()
+{}
+
+void CreateApiDestinationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dateNode = value["Date"];
+	if(!dateNode["ApiDestinationName"].isNull())
+		date_.apiDestinationName = dateNode["ApiDestinationName"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+
+}
+
+std::string CreateApiDestinationResult::getMessage()const
+{
+	return message_;
+}
+
+std::string CreateApiDestinationResult::getCode()const
+{
+	return code_;
+}
+
+CreateApiDestinationResult::Date CreateApiDestinationResult::getDate()const
+{
+	return date_;
+}
+

eventbridge/src/model/CreateConnectionRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateConnectionRequest.h>
+
+using AlibabaCloud::Eventbridge::Model::CreateConnectionRequest;
+
+CreateConnectionRequest::CreateConnectionRequest()
+    : RpcServiceRequest("eventbridge", "2020-04-01", "CreateConnection") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateConnectionRequest::~CreateConnectionRequest() {}
+
+std::string CreateConnectionRequest::getConnectionName() const {
+  return connectionName_;
+}
+
+void CreateConnectionRequest::setConnectionName(const std::string &connectionName) {
+  connectionName_ = connectionName;
+  setParameter(std::string("ConnectionName"), connectionName);
+}
+
+std::string CreateConnectionRequest::getDescription() const {
+  return description_;
+}
+
+void CreateConnectionRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+CreateConnectionRequest::NetworkParameters CreateConnectionRequest::getNetworkParameters() const {
+  return networkParameters_;
+}
+
+void CreateConnectionRequest::setNetworkParameters(const CreateConnectionRequest::NetworkParameters &networkParameters) {
+  networkParameters_ = networkParameters;
+  setParameter(std::string("NetworkParameters") + ".VpcId", networkParameters.vpcId);
+  setParameter(std::string("NetworkParameters") + ".SecurityGroupId", networkParameters.securityGroupId);
+  setParameter(std::string("NetworkParameters") + ".NetworkType", networkParameters.networkType);
+  setParameter(std::string("NetworkParameters") + ".VswitcheId", networkParameters.vswitcheId);
+}
+
+CreateConnectionRequest::AuthParameters CreateConnectionRequest::getAuthParameters() const {
+  return authParameters_;
+}
+
+void CreateConnectionRequest::setAuthParameters(const CreateConnectionRequest::AuthParameters &authParameters) {
+  authParameters_ = authParameters;
+  setParameter(std::string("AuthParameters") + ".BasicAuthParameters.Password", authParameters.basicAuthParameters.password);
+  setParameter(std::string("AuthParameters") + ".BasicAuthParameters.Username", authParameters.basicAuthParameters.username);
+  setParameter(std::string("AuthParameters") + ".ApiKeyAuthParameters.ApiKeyName", authParameters.apiKeyAuthParameters.apiKeyName);
+  setParameter(std::string("AuthParameters") + ".ApiKeyAuthParameters.ApiKeyValue", authParameters.apiKeyAuthParameters.apiKeyValue);
+  setParameter(std::string("AuthParameters") + ".AuthorizationType", authParameters.authorizationType);
+  for(int dep1 = 0; dep1 != authParameters.invocationHttpParameters.bodyParameters.size(); dep1++) {
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.BodyParameters." + std::to_string(dep1 + 1) + ".IsValueSecret", authParameters.invocationHttpParameters.bodyParameters[dep1].isValueSecret);
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.BodyParameters." + std::to_string(dep1 + 1) + ".Value", authParameters.invocationHttpParameters.bodyParameters[dep1].value);
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.BodyParameters." + std::to_string(dep1 + 1) + ".Key", authParameters.invocationHttpParameters.bodyParameters[dep1].key);
+  }
+  for(int dep1 = 0; dep1 != authParameters.invocationHttpParameters.headerParameters.size(); dep1++) {
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.HeaderParameters." + std::to_string(dep1 + 1) + ".IsValueSecret", authParameters.invocationHttpParameters.headerParameters[dep1].isValueSecret);
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.HeaderParameters." + std::to_string(dep1 + 1) + ".Value", authParameters.invocationHttpParameters.headerParameters[dep1].value);
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.HeaderParameters." + std::to_string(dep1 + 1) + ".Key", authParameters.invocationHttpParameters.headerParameters[dep1].key);
+  }
+  for(int dep1 = 0; dep1 != authParameters.invocationHttpParameters.queryStringParameters.size(); dep1++) {
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.QueryStringParameters." + std::to_string(dep1 + 1) + ".IsValueSecret", authParameters.invocationHttpParameters.queryStringParameters[dep1].isValueSecret);
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.QueryStringParameters." + std::to_string(dep1 + 1) + ".Value", authParameters.invocationHttpParameters.queryStringParameters[dep1].value);
+    setParameter(std::string("AuthParameters") + ".InvocationHttpParameters.QueryStringParameters." + std::to_string(dep1 + 1) + ".Key", authParameters.invocationHttpParameters.queryStringParameters[dep1].key);
+  }
+  setParameter(std::string("AuthParameters") + ".OAuthParameters.ClientParameters.ClientID", authParameters.oAuthParameters.clientParameters.clientID);
+  setParameter(std::string("AuthParameters") + ".OAuthParameters.ClientParameters.ClientSecret", authParameters.oAuthParameters.clientParameters.clientSecret);
+  setParameter(std::string("AuthParameters") + ".OAuthParameters.AuthorizationEndpoint", authParameters.oAuthParameters.authorizationEndpoint);
+  setParameter(std::string("AuthParameters") + ".OAuthParameters.HttpMethod", authParameters.oAuthParameters.httpMethod);
+  for(int dep1 = 0; dep1 != authParameters.oAuthParameters.oAuthHttpParameters.bodyParameters.size(); dep1++) {
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.BodyParameters." + std::to_string(dep1 + 1) + ".IsValueSecret", authParameters.oAuthParameters.oAuthHttpParameters.bodyParameters[dep1].isValueSecret);
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.BodyParameters." + std::to_string(dep1 + 1) + ".Value", authParameters.oAuthParameters.oAuthHttpParameters.bodyParameters[dep1].value);
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.BodyParameters." + std::to_string(dep1 + 1) + ".Key", authParameters.oAuthParameters.oAuthHttpParameters.bodyParameters[dep1].key);
+  }
+  for(int dep1 = 0; dep1 != authParameters.oAuthParameters.oAuthHttpParameters.headerParameters.size(); dep1++) {
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.HeaderParameters." + std::to_string(dep1 + 1) + ".IsValueSecret", authParameters.oAuthParameters.oAuthHttpParameters.headerParameters[dep1].isValueSecret);
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.HeaderParameters." + std::to_string(dep1 + 1) + ".Value", authParameters.oAuthParameters.oAuthHttpParameters.headerParameters[dep1].value);
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.HeaderParameters." + std::to_string(dep1 + 1) + ".Key", authParameters.oAuthParameters.oAuthHttpParameters.headerParameters[dep1].key);
+  }
+  for(int dep1 = 0; dep1 != authParameters.oAuthParameters.oAuthHttpParameters.queryStringParameters.size(); dep1++) {
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.QueryStringParameters." + std::to_string(dep1 + 1) + ".IsValueSecret", authParameters.oAuthParameters.oAuthHttpParameters.queryStringParameters[dep1].isValueSecret);
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.QueryStringParameters." + std::to_string(dep1 + 1) + ".Value", authParameters.oAuthParameters.oAuthHttpParameters.queryStringParameters[dep1].value);
+    setParameter(std::string("AuthParameters") + ".OAuthParameters.OAuthHttpParameters.QueryStringParameters." + std::to_string(dep1 + 1) + ".Key", authParameters.oAuthParameters.oAuthHttpParameters.queryStringParameters[dep1].key);
+  }
+}
+

eventbridge/src/model/CreateConnectionResult.cc

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateConnectionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Eventbridge;
+using namespace AlibabaCloud::Eventbridge::Model;
+
+CreateConnectionResult::CreateConnectionResult() :
+	ServiceResult()
+{}
+
+CreateConnectionResult::CreateConnectionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateConnectionResult::~CreateConnectionResult()
+{}
+
+void CreateConnectionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ConnectionName"].isNull())
+		data_.connectionName = dataNode["ConnectionName"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+
+}
+
+std::string CreateConnectionResult::getMessage()const
+{
+	return message_;
+}
+
+CreateConnectionResult::Data CreateConnectionResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateConnectionResult::getCode()const
+{
+	return code_;
+}
+

eventbridge/src/model/CreateEventBusRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateEventBusRequest.h>
+
+using AlibabaCloud::Eventbridge::Model::CreateEventBusRequest;
+
+CreateEventBusRequest::CreateEventBusRequest()
+    : RpcServiceRequest("eventbridge", "2020-04-01", "CreateEventBus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateEventBusRequest::~CreateEventBusRequest() {}
+
+std::string CreateEventBusRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateEventBusRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateEventBusRequest::getDescription() const {
+  return description_;
+}
+
+void CreateEventBusRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateEventBusRequest::getEventBusName() const {
+  return eventBusName_;
+}
+
+void CreateEventBusRequest::setEventBusName(const std::string &eventBusName) {
+  eventBusName_ = eventBusName;
+  setParameter(std::string("EventBusName"), eventBusName);
+}
+

eventbridge/src/model/CreateEventBusResult.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateEventBusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Eventbridge;
+using namespace AlibabaCloud::Eventbridge::Model;
+
+CreateEventBusResult::CreateEventBusResult() :
+	ServiceResult()
+{}
+
+CreateEventBusResult::CreateEventBusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateEventBusResult::~CreateEventBusResult()
+{}
+
+void CreateEventBusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["EventBusARN"].isNull())
+		data_.eventBusARN = dataNode["EventBusARN"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string CreateEventBusResult::getMessage()const
+{
+	return message_;
+}
+
+CreateEventBusResult::Data CreateEventBusResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateEventBusResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateEventBusResult::getSuccess()const
+{
+	return success_;
+}
+

eventbridge/src/model/CreateEventSourceRequest.cc

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateEventSourceRequest.h>
+
+using AlibabaCloud::Eventbridge::Model::CreateEventSourceRequest;
+
+CreateEventSourceRequest::CreateEventSourceRequest()
+    : RpcServiceRequest("eventbridge", "2020-04-01", "CreateEventSource") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateEventSourceRequest::~CreateEventSourceRequest() {}
+
+std::string CreateEventSourceRequest::getDescription() const {
+  return description_;
+}
+
+void CreateEventSourceRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string CreateEventSourceRequest::getEventBusName() const {
+  return eventBusName_;
+}
+
+void CreateEventSourceRequest::setEventBusName(const std::string &eventBusName) {
+  eventBusName_ = eventBusName;
+  setBodyParameter(std::string("EventBusName"), eventBusName);
+}
+
+CreateEventSourceRequest::SourceMNSParameters CreateEventSourceRequest::getSourceMNSParameters() const {
+  return sourceMNSParameters_;
+}
+
+void CreateEventSourceRequest::setSourceMNSParameters(const CreateEventSourceRequest::SourceMNSParameters &sourceMNSParameters) {
+  sourceMNSParameters_ = sourceMNSParameters;
+  setBodyParameter(std::string("SourceMNSParameters") + ".QueueName", sourceMNSParameters.queueName);
+  setBodyParameter(std::string("SourceMNSParameters") + ".RegionId", sourceMNSParameters.regionId);
+  setBodyParameter(std::string("SourceMNSParameters") + ".IsBase64Decode", sourceMNSParameters.isBase64Decode ? "true" : "false");
+}
+
+bool CreateEventSourceRequest::getLinkedExternalSource() const {
+  return linkedExternalSource_;
+}
+
+void CreateEventSourceRequest::setLinkedExternalSource(bool linkedExternalSource) {
+  linkedExternalSource_ = linkedExternalSource;
+  setBodyParameter(std::string("LinkedExternalSource"), linkedExternalSource ? "true" : "false");
+}
+
+std::string CreateEventSourceRequest::getExternalSourceType() const {
+  return externalSourceType_;
+}
+
+void CreateEventSourceRequest::setExternalSourceType(const std::string &externalSourceType) {
+  externalSourceType_ = externalSourceType;
+  setBodyParameter(std::string("ExternalSourceType"), externalSourceType);
+}
+
+std::string CreateEventSourceRequest::getExternalSourceConfig() const {
+  return externalSourceConfig_;
+}
+
+void CreateEventSourceRequest::setExternalSourceConfig(const std::string &externalSourceConfig) {
+  externalSourceConfig_ = externalSourceConfig;
+  setBodyParameter(std::string("ExternalSourceConfig"), externalSourceConfig);
+}
+
+CreateEventSourceRequest::SourceRabbitMQParameters CreateEventSourceRequest::getSourceRabbitMQParameters() const {
+  return sourceRabbitMQParameters_;
+}
+
+void CreateEventSourceRequest::setSourceRabbitMQParameters(const CreateEventSourceRequest::SourceRabbitMQParameters &sourceRabbitMQParameters) {
+  sourceRabbitMQParameters_ = sourceRabbitMQParameters;
+  setBodyParameter(std::string("SourceRabbitMQParameters") + ".QueueName", sourceRabbitMQParameters.queueName);
+  setBodyParameter(std::string("SourceRabbitMQParameters") + ".VirtualHostName", sourceRabbitMQParameters.virtualHostName);
+  setBodyParameter(std::string("SourceRabbitMQParameters") + ".InstanceId", sourceRabbitMQParameters.instanceId);
+  setBodyParameter(std::string("SourceRabbitMQParameters") + ".RegionId", sourceRabbitMQParameters.regionId);
+}
+
+CreateEventSourceRequest::SourceRocketMQParameters CreateEventSourceRequest::getSourceRocketMQParameters() const {
+  return sourceRocketMQParameters_;
+}
+
+void CreateEventSourceRequest::setSourceRocketMQParameters(const CreateEventSourceRequest::SourceRocketMQParameters &sourceRocketMQParameters) {
+  sourceRocketMQParameters_ = sourceRocketMQParameters;
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceSecurityGroupId", sourceRocketMQParameters.instanceSecurityGroupId);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".Offset", sourceRocketMQParameters.offset);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".GroupID", sourceRocketMQParameters.groupID);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceUsername", sourceRocketMQParameters.instanceUsername);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".AuthType", sourceRocketMQParameters.authType);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstancePassword", sourceRocketMQParameters.instancePassword);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceNetwork", sourceRocketMQParameters.instanceNetwork);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceVSwitchIds", sourceRocketMQParameters.instanceVSwitchIds);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceId", sourceRocketMQParameters.instanceId);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceVpcId", sourceRocketMQParameters.instanceVpcId);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceEndpoint", sourceRocketMQParameters.instanceEndpoint);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".RegionId", sourceRocketMQParameters.regionId);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".Topic", sourceRocketMQParameters.topic);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".InstanceType", sourceRocketMQParameters.instanceType);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".Tag", sourceRocketMQParameters.tag);
+  setBodyParameter(std::string("SourceRocketMQParameters") + ".Timestamp", std::to_string(sourceRocketMQParameters.timestamp));
+}
+
+CreateEventSourceRequest::SourceSLSParameters CreateEventSourceRequest::getSourceSLSParameters() const {
+  return sourceSLSParameters_;
+}
+
+void CreateEventSourceRequest::setSourceSLSParameters(const CreateEventSourceRequest::SourceSLSParameters &sourceSLSParameters) {
+  sourceSLSParameters_ = sourceSLSParameters;
+  setBodyParameter(std::string("SourceSLSParameters") + ".RoleName", sourceSLSParameters.roleName);
+  setBodyParameter(std::string("SourceSLSParameters") + ".Project", sourceSLSParameters.project);
+  setBodyParameter(std::string("SourceSLSParameters") + ".LogStore", sourceSLSParameters.logStore);
+  setBodyParameter(std::string("SourceSLSParameters") + ".ConsumePosition", sourceSLSParameters.consumePosition);
+}
+
+CreateEventSourceRequest::SourceScheduledEventParameters CreateEventSourceRequest::getSourceScheduledEventParameters() const {
+  return sourceScheduledEventParameters_;
+}
+
+void CreateEventSourceRequest::setSourceScheduledEventParameters(const CreateEventSourceRequest::SourceScheduledEventParameters &sourceScheduledEventParameters) {
+  sourceScheduledEventParameters_ = sourceScheduledEventParameters;
+  setBodyParameter(std::string("SourceScheduledEventParameters") + ".Schedule", sourceScheduledEventParameters.schedule);
+  setBodyParameter(std::string("SourceScheduledEventParameters") + ".UserData", sourceScheduledEventParameters.userData);
+  setBodyParameter(std::string("SourceScheduledEventParameters") + ".TimeZone", sourceScheduledEventParameters.timeZone);
+}
+
+CreateEventSourceRequest::SourceKafkaParameters CreateEventSourceRequest::getSourceKafkaParameters() const {
+  return sourceKafkaParameters_;
+}
+
+void CreateEventSourceRequest::setSourceKafkaParameters(const CreateEventSourceRequest::SourceKafkaParameters &sourceKafkaParameters) {
+  sourceKafkaParameters_ = sourceKafkaParameters;
+  setBodyParameter(std::string("SourceKafkaParameters") + ".InstanceId", sourceKafkaParameters.instanceId);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".ConsumerGroup", sourceKafkaParameters.consumerGroup);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".RegionId", sourceKafkaParameters.regionId);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".VSwitchIds", sourceKafkaParameters.vSwitchIds);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".VpcId", sourceKafkaParameters.vpcId);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".SecurityGroupId", sourceKafkaParameters.securityGroupId);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".Topic", sourceKafkaParameters.topic);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".OffsetReset", sourceKafkaParameters.offsetReset);
+  setBodyParameter(std::string("SourceKafkaParameters") + ".MaximumTasks", std::to_string(sourceKafkaParameters.maximumTasks));
+  setBodyParameter(std::string("SourceKafkaParameters") + ".Network", sourceKafkaParameters.network);
+}
+
+CreateEventSourceRequest::SourceHttpEventParameters CreateEventSourceRequest::getSourceHttpEventParameters() const {
+  return sourceHttpEventParameters_;
+}
+
+void CreateEventSourceRequest::setSourceHttpEventParameters(const CreateEventSourceRequest::SourceHttpEventParameters &sourceHttpEventParameters) {
+  sourceHttpEventParameters_ = sourceHttpEventParameters;
+  for(int dep1 = 0; dep1 != sourceHttpEventParameters.referer.size(); dep1++) {
+    setBodyParameter(std::string("SourceHttpEventParameters") + ".Referer." + std::to_string(dep1 + 1), sourceHttpEventParameters.referer[dep1]);
+  }
+  for(int dep1 = 0; dep1 != sourceHttpEventParameters.method.size(); dep1++) {
+    setBodyParameter(std::string("SourceHttpEventParameters") + ".Method." + std::to_string(dep1 + 1), sourceHttpEventParameters.method[dep1]);
+  }
+  for(int dep1 = 0; dep1 != sourceHttpEventParameters.ip.size(); dep1++) {
+    setBodyParameter(std::string("SourceHttpEventParameters") + ".Ip." + std::to_string(dep1 + 1), sourceHttpEventParameters.ip[dep1]);
+  }
+  setBodyParameter(std::string("SourceHttpEventParameters") + ".SecurityConfig", sourceHttpEventParameters.securityConfig);
+  setBodyParameter(std::string("SourceHttpEventParameters") + ".Type", sourceHttpEventParameters.type);
+}
+
+std::string CreateEventSourceRequest::getEventSourceName() const {
+  return eventSourceName_;
+}
+
+void CreateEventSourceRequest::setEventSourceName(const std::string &eventSourceName) {
+  eventSourceName_ = eventSourceName;
+  setBodyParameter(std::string("EventSourceName"), eventSourceName);
+}
+

eventbridge/src/model/CreateEventSourceResult.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateEventSourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Eventbridge;
+using namespace AlibabaCloud::Eventbridge::Model;
+
+CreateEventSourceResult::CreateEventSourceResult() :
+	ServiceResult()
+{}
+
+CreateEventSourceResult::CreateEventSourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateEventSourceResult::~CreateEventSourceResult()
+{}
+
+void CreateEventSourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["EventSourceARN"].isNull())
+		data_.eventSourceARN = dataNode["EventSourceARN"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string CreateEventSourceResult::getMessage()const
+{
+	return message_;
+}
+
+CreateEventSourceResult::Data CreateEventSourceResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateEventSourceResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateEventSourceResult::getSuccess()const
+{
+	return success_;
+}
+

eventbridge/src/model/CreateEventStreamingRequest.cc

@@ -0,0 +1,347 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eventbridge/model/CreateEventStreamingRequest.h>
+
+using AlibabaCloud::Eventbridge::Model::CreateEventStreamingRequest;
+
+CreateEventStreamingRequest::CreateEventStreamingRequest()
+    : RpcServiceRequest("eventbridge", "2020-04-01", "CreateEventStreaming") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateEventStreamingRequest::~CreateEventStreamingRequest() {}
+
+CreateEventStreamingRequest::Sink CreateEventStreamingRequest::getSink() const {
+  return sink_;
+}
+
+void CreateEventStreamingRequest::setSink(const CreateEventStreamingRequest::Sink &sink) {
+  sink_ = sink;
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.RoutingKey.Template", sink.sinkRabbitMQParameters.routingKey._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.RoutingKey.Form", sink.sinkRabbitMQParameters.routingKey.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.RoutingKey.Value", sink.sinkRabbitMQParameters.routingKey.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.QueueName.Template", sink.sinkRabbitMQParameters.queueName._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.QueueName.Form", sink.sinkRabbitMQParameters.queueName.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.QueueName.Value", sink.sinkRabbitMQParameters.queueName.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.VirtualHostName.Template", sink.sinkRabbitMQParameters.virtualHostName._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.VirtualHostName.Form", sink.sinkRabbitMQParameters.virtualHostName.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.VirtualHostName.Value", sink.sinkRabbitMQParameters.virtualHostName.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.InstanceId.Template", sink.sinkRabbitMQParameters.instanceId._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.InstanceId.Form", sink.sinkRabbitMQParameters.instanceId.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.InstanceId.Value", sink.sinkRabbitMQParameters.instanceId.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.TargetType.Template", sink.sinkRabbitMQParameters.targetType._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.TargetType.Form", sink.sinkRabbitMQParameters.targetType.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.TargetType.Value", sink.sinkRabbitMQParameters.targetType.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.MessageId.Template", sink.sinkRabbitMQParameters.messageId._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.MessageId.Form", sink.sinkRabbitMQParameters.messageId.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.MessageId.Value", sink.sinkRabbitMQParameters.messageId.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Exchange.Template", sink.sinkRabbitMQParameters.exchange._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Exchange.Form", sink.sinkRabbitMQParameters.exchange.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Exchange.Value", sink.sinkRabbitMQParameters.exchange.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Body.Template", sink.sinkRabbitMQParameters.body._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Body.Form", sink.sinkRabbitMQParameters.body.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Body.Value", sink.sinkRabbitMQParameters.body.value);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Properties.Template", sink.sinkRabbitMQParameters.properties._template);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Properties.Form", sink.sinkRabbitMQParameters.properties.form);
+  setBodyParameter(std::string("Sink") + ".SinkRabbitMQParameters.Properties.Value", sink.sinkRabbitMQParameters.properties.value);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.QueueName.Template", sink.sinkMNSParameters.queueName._template);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.QueueName.Form", sink.sinkMNSParameters.queueName.form);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.QueueName.Value", sink.sinkMNSParameters.queueName.value);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.IsBase64Encode.Template", sink.sinkMNSParameters.isBase64Encode._template);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.IsBase64Encode.Form", sink.sinkMNSParameters.isBase64Encode.form);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.IsBase64Encode.Value", sink.sinkMNSParameters.isBase64Encode.value);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.Body.Template", sink.sinkMNSParameters.body._template);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.Body.Form", sink.sinkMNSParameters.body.form);
+  setBodyParameter(std::string("Sink") + ".SinkMNSParameters.Body.Value", sink.sinkMNSParameters.body.value);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.RoleName.Template", sink.sinkDataHubParameters.roleName._template);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.RoleName.Form", sink.sinkDataHubParameters.roleName.form);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.RoleName.Value", sink.sinkDataHubParameters.roleName.value);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Project.Template", sink.sinkDataHubParameters.project._template);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Project.Form", sink.sinkDataHubParameters.project.form);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Project.Value", sink.sinkDataHubParameters.project.value);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Topic.Template", sink.sinkDataHubParameters.topic._template);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Topic.Form", sink.sinkDataHubParameters.topic.form);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Topic.Value", sink.sinkDataHubParameters.topic.value);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.TopicType.Template", sink.sinkDataHubParameters.topicType._template);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.TopicType.Form", sink.sinkDataHubParameters.topicType.form);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.TopicType.Value", sink.sinkDataHubParameters.topicType.value);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Body.Template", sink.sinkDataHubParameters.body._template);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Body.Form", sink.sinkDataHubParameters.body.form);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.Body.Value", sink.sinkDataHubParameters.body.value);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.TopicSchema.Template", sink.sinkDataHubParameters.topicSchema._template);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.TopicSchema.Form", sink.sinkDataHubParameters.topicSchema.form);
+  setBodyParameter(std::string("Sink") + ".SinkDataHubParameters.TopicSchema.Value", sink.sinkDataHubParameters.topicSchema.value);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.InstanceId.Template", sink.sinkKafkaParameters.instanceId._template);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.InstanceId.Form", sink.sinkKafkaParameters.instanceId.form);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.InstanceId.Value", sink.sinkKafkaParameters.instanceId.value);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Acks.Template", sink.sinkKafkaParameters.acks._template);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Acks.Form", sink.sinkKafkaParameters.acks.form);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Acks.Value", sink.sinkKafkaParameters.acks.value);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Topic.Template", sink.sinkKafkaParameters.topic._template);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Topic.Form", sink.sinkKafkaParameters.topic.form);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Topic.Value", sink.sinkKafkaParameters.topic.value);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.SaslUser.Template", sink.sinkKafkaParameters.saslUser._template);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.SaslUser.Form", sink.sinkKafkaParameters.saslUser.form);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.SaslUser.Value", sink.sinkKafkaParameters.saslUser.value);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Value.Template", sink.sinkKafkaParameters.value._template);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Value.Form", sink.sinkKafkaParameters.value.form);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Value.Value", sink.sinkKafkaParameters.value.value);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Key.Template", sink.sinkKafkaParameters.key._template);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Key.Form", sink.sinkKafkaParameters.key.form);
+  setBodyParameter(std::string("Sink") + ".SinkKafkaParameters.Key.Value", sink.sinkKafkaParameters.key.value);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.Input.Template", sink.sinkFnfParameters.input._template);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.Input.Form", sink.sinkFnfParameters.input.form);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.Input.Value", sink.sinkFnfParameters.input.value);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.ExecutionName.Template", sink.sinkFnfParameters.executionName._template);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.ExecutionName.Form", sink.sinkFnfParameters.executionName.form);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.ExecutionName.Value", sink.sinkFnfParameters.executionName.value);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.RoleName.Template", sink.sinkFnfParameters.roleName._template);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.RoleName.Form", sink.sinkFnfParameters.roleName.form);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.RoleName.Value", sink.sinkFnfParameters.roleName.value);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.FlowName.Template", sink.sinkFnfParameters.flowName._template);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.FlowName.Form", sink.sinkFnfParameters.flowName.form);
+  setBodyParameter(std::string("Sink") + ".SinkFnfParameters.FlowName.Value", sink.sinkFnfParameters.flowName.value);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.InvocationType.Template", sink.sinkFcParameters.invocationType._template);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.InvocationType.Form", sink.sinkFcParameters.invocationType.form);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.InvocationType.Value", sink.sinkFcParameters.invocationType.value);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.FunctionName.Template", sink.sinkFcParameters.functionName._template);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.FunctionName.Form", sink.sinkFcParameters.functionName.form);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.FunctionName.Value", sink.sinkFcParameters.functionName.value);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Qualifier.Template", sink.sinkFcParameters.qualifier._template);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Qualifier.Form", sink.sinkFcParameters.qualifier.form);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Qualifier.Value", sink.sinkFcParameters.qualifier.value);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.ServiceName.Template", sink.sinkFcParameters.serviceName._template);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.ServiceName.Form", sink.sinkFcParameters.serviceName.form);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.ServiceName.Value", sink.sinkFcParameters.serviceName.value);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Body.Template", sink.sinkFcParameters.body._template);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Body.Form", sink.sinkFcParameters.body.form);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Body.Value", sink.sinkFcParameters.body.value);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Concurrency.Template", sink.sinkFcParameters.concurrency._template);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Concurrency.Form", sink.sinkFcParameters.concurrency.form);
+  setBodyParameter(std::string("Sink") + ".SinkFcParameters.Concurrency.Value", sink.sinkFcParameters.concurrency.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.VSwitchId.Template", sink.sinkPrometheusParameters.vSwitchId._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.VSwitchId.Form", sink.sinkPrometheusParameters.vSwitchId.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.VSwitchId.Value", sink.sinkPrometheusParameters.vSwitchId.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Password.Template", sink.sinkPrometheusParameters.password._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Password.Form", sink.sinkPrometheusParameters.password.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Password.Value", sink.sinkPrometheusParameters.password.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Data.Template", sink.sinkPrometheusParameters.data._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Data.Form", sink.sinkPrometheusParameters.data.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Data.Value", sink.sinkPrometheusParameters.data.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.VpcId.Template", sink.sinkPrometheusParameters.vpcId._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.VpcId.Form", sink.sinkPrometheusParameters.vpcId.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.VpcId.Value", sink.sinkPrometheusParameters.vpcId.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.SecurityGroupId.Template", sink.sinkPrometheusParameters.securityGroupId._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.SecurityGroupId.Form", sink.sinkPrometheusParameters.securityGroupId.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.SecurityGroupId.Value", sink.sinkPrometheusParameters.securityGroupId.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.AuthorizationType.Template", sink.sinkPrometheusParameters.authorizationType._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.AuthorizationType.Form", sink.sinkPrometheusParameters.authorizationType.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.AuthorizationType.Value", sink.sinkPrometheusParameters.authorizationType.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.NetworkType.Template", sink.sinkPrometheusParameters.networkType._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.NetworkType.Form", sink.sinkPrometheusParameters.networkType.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.NetworkType.Value", sink.sinkPrometheusParameters.networkType.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.URL.Template", sink.sinkPrometheusParameters.uRL._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.URL.Form", sink.sinkPrometheusParameters.uRL.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.URL.Value", sink.sinkPrometheusParameters.uRL.value);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Username.Template", sink.sinkPrometheusParameters.username._template);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Username.Form", sink.sinkPrometheusParameters.username.form);
+  setBodyParameter(std::string("Sink") + ".SinkPrometheusParameters.Username.Value", sink.sinkPrometheusParameters.username.value);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.RoleName.Template", sink.sinkSLSParameters.roleName._template);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.RoleName.Form", sink.sinkSLSParameters.roleName.form);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.RoleName.Value", sink.sinkSLSParameters.roleName.value);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Project.Template", sink.sinkSLSParameters.project._template);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Project.Form", sink.sinkSLSParameters.project.form);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Project.Value", sink.sinkSLSParameters.project.value);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Topic.Template", sink.sinkSLSParameters.topic._template);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Topic.Form", sink.sinkSLSParameters.topic.form);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Topic.Value", sink.sinkSLSParameters.topic.value);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Body.Template", sink.sinkSLSParameters.body._template);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Body.Form", sink.sinkSLSParameters.body.form);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.Body.Value", sink.sinkSLSParameters.body.value);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.LogStore.Template", sink.sinkSLSParameters.logStore._template);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.LogStore.Form", sink.sinkSLSParameters.logStore.form);
+  setBodyParameter(std::string("Sink") + ".SinkSLSParameters.LogStore.Value", sink.sinkSLSParameters.logStore.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Keys.Template", sink.sinkRocketMQParameters.keys._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Keys.Form", sink.sinkRocketMQParameters.keys.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Keys.Value", sink.sinkRocketMQParameters.keys.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.VSwitchIds.Template", sink.sinkRocketMQParameters.vSwitchIds._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.VSwitchIds.Form", sink.sinkRocketMQParameters.vSwitchIds.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.VSwitchIds.Value", sink.sinkRocketMQParameters.vSwitchIds.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.SecurityGroupId.Template", sink.sinkRocketMQParameters.securityGroupId._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.SecurityGroupId.Form", sink.sinkRocketMQParameters.securityGroupId.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.SecurityGroupId.Value", sink.sinkRocketMQParameters.securityGroupId.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceUsername.Template", sink.sinkRocketMQParameters.instanceUsername._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceUsername.Form", sink.sinkRocketMQParameters.instanceUsername.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceUsername.Value", sink.sinkRocketMQParameters.instanceUsername.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Body.Template", sink.sinkRocketMQParameters.body._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Body.Form", sink.sinkRocketMQParameters.body.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Body.Value", sink.sinkRocketMQParameters.body.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Tags.Template", sink.sinkRocketMQParameters.tags._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Tags.Form", sink.sinkRocketMQParameters.tags.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Tags.Value", sink.sinkRocketMQParameters.tags.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Network.Template", sink.sinkRocketMQParameters.network._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Network.Form", sink.sinkRocketMQParameters.network.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Network.Value", sink.sinkRocketMQParameters.network.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstancePassword.Template", sink.sinkRocketMQParameters.instancePassword._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstancePassword.Form", sink.sinkRocketMQParameters.instancePassword.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstancePassword.Value", sink.sinkRocketMQParameters.instancePassword.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceId.Template", sink.sinkRocketMQParameters.instanceId._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceId.Form", sink.sinkRocketMQParameters.instanceId.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceId.Value", sink.sinkRocketMQParameters.instanceId.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceEndpoint.Template", sink.sinkRocketMQParameters.instanceEndpoint._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceEndpoint.Form", sink.sinkRocketMQParameters.instanceEndpoint.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceEndpoint.Value", sink.sinkRocketMQParameters.instanceEndpoint.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.VpcId.Template", sink.sinkRocketMQParameters.vpcId._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.VpcId.Form", sink.sinkRocketMQParameters.vpcId.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.VpcId.Value", sink.sinkRocketMQParameters.vpcId.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Topic.Template", sink.sinkRocketMQParameters.topic._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Topic.Form", sink.sinkRocketMQParameters.topic.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Topic.Value", sink.sinkRocketMQParameters.topic.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceType.Template", sink.sinkRocketMQParameters.instanceType._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceType.Form", sink.sinkRocketMQParameters.instanceType.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.InstanceType.Value", sink.sinkRocketMQParameters.instanceType.value);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Properties.Template", sink.sinkRocketMQParameters.properties._template);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Properties.Form", sink.sinkRocketMQParameters.properties.form);
+  setBodyParameter(std::string("Sink") + ".SinkRocketMQParameters.Properties.Value", sink.sinkRocketMQParameters.properties.value);
+}
+
+std::vector<CreateEventStreamingRequest::Transforms> CreateEventStreamingRequest::getTransforms() const {
+  return transforms_;
+}
+
+void CreateEventStreamingRequest::setTransforms(const std::vector<CreateEventStreamingRequest::Transforms> &transforms) {
+  transforms_ = transforms;
+  for(int dep1 = 0; dep1 != transforms.size(); dep1++) {
+    setBodyParameter(std::string("Transforms") + "." + std::to_string(dep1 + 1) + ".Arn", transforms[dep1].arn);
+  }
+}
+
+std::string CreateEventStreamingRequest::getDescription() const {
+  return description_;
+}
+
+void CreateEventStreamingRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string CreateEventStreamingRequest::getFilterPattern() const {
+  return filterPattern_;
+}
+
+void CreateEventStreamingRequest::setFilterPattern(const std::string &filterPattern) {
+  filterPattern_ = filterPattern;
+  setBodyParameter(std::string("FilterPattern"), filterPattern);
+}
+
+CreateEventStreamingRequest::Source CreateEventStreamingRequest::getSource() const {
+  return source_;
+}
+
+void CreateEventStreamingRequest::setSource(const CreateEventStreamingRequest::Source &source) {
+  source_ = source;
+  setBodyParameter(std::string("Source") + ".SourceMQTTParameters.InstanceId", source.sourceMQTTParameters.instanceId);
+  setBodyParameter(std::string("Source") + ".SourceMQTTParameters.RegionId", source.sourceMQTTParameters.regionId);
+  setBodyParameter(std::string("Source") + ".SourceMQTTParameters.Topic", source.sourceMQTTParameters.topic);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.FilterSql", source.sourceRocketMQParameters.filterSql);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceSecurityGroupId", source.sourceRocketMQParameters.instanceSecurityGroupId);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.Offset", source.sourceRocketMQParameters.offset);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.VSwitchIds", source.sourceRocketMQParameters.vSwitchIds);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.GroupID", source.sourceRocketMQParameters.groupID);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.SecurityGroupId", source.sourceRocketMQParameters.securityGroupId);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceUsername", source.sourceRocketMQParameters.instanceUsername);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.FilterType", source.sourceRocketMQParameters.filterType);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.Network", source.sourceRocketMQParameters.network);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.AuthType", source.sourceRocketMQParameters.authType);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstancePassword", source.sourceRocketMQParameters.instancePassword);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceVSwitchIds", source.sourceRocketMQParameters.instanceVSwitchIds);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceNetwork", source.sourceRocketMQParameters.instanceNetwork);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceId", source.sourceRocketMQParameters.instanceId);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceEndpoint", source.sourceRocketMQParameters.instanceEndpoint);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceVpcId", source.sourceRocketMQParameters.instanceVpcId);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.RegionId", source.sourceRocketMQParameters.regionId);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.VpcId", source.sourceRocketMQParameters.vpcId);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.Topic", source.sourceRocketMQParameters.topic);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.InstanceType", source.sourceRocketMQParameters.instanceType);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.Tag", source.sourceRocketMQParameters.tag);
+  setBodyParameter(std::string("Source") + ".SourceRocketMQParameters.Timestamp", std::to_string(source.sourceRocketMQParameters.timestamp));
+  setBodyParameter(std::string("Source") + ".SourceSLSParameters.RoleName", source.sourceSLSParameters.roleName);
+  setBodyParameter(std::string("Source") + ".SourceSLSParameters.Project", source.sourceSLSParameters.project);
+  setBodyParameter(std::string("Source") + ".SourceSLSParameters.LogStore", source.sourceSLSParameters.logStore);
+  setBodyParameter(std::string("Source") + ".SourceSLSParameters.ConsumePosition", source.sourceSLSParameters.consumePosition);
+  setBodyParameter(std::string("Source") + ".SourcePrometheusParameters.DataType", source.sourcePrometheusParameters.dataType);
+  setBodyParameter(std::string("Source") + ".SourcePrometheusParameters.ClusterId", source.sourcePrometheusParameters.clusterId);
+  setBodyParameter(std::string("Source") + ".SourcePrometheusParameters.Labels", source.sourcePrometheusParameters.labels);
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.BrokerUrl", source.sourceDTSParameters.brokerUrl);
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.Password", source.sourceDTSParameters.password);
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.InitCheckPoint", std::to_string(source.sourceDTSParameters.initCheckPoint));
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.Topic", source.sourceDTSParameters.topic);
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.TaskId", source.sourceDTSParameters.taskId);
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.Sid", source.sourceDTSParameters.sid);
+  setBodyParameter(std::string("Source") + ".SourceDTSParameters.Username", source.sourceDTSParameters.username);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.InstanceId", source.sourceKafkaParameters.instanceId);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.ConsumerGroup", source.sourceKafkaParameters.consumerGroup);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.RegionId", source.sourceKafkaParameters.regionId);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.VSwitchIds", source.sourceKafkaParameters.vSwitchIds);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.VpcId", source.sourceKafkaParameters.vpcId);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.SecurityGroupId", source.sourceKafkaParameters.securityGroupId);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.Topic", source.sourceKafkaParameters.topic);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.OffsetReset", source.sourceKafkaParameters.offsetReset);
+  setBodyParameter(std::string("Source") + ".SourceKafkaParameters.Network", source.sourceKafkaParameters.network);
+  setBodyParameter(std::string("Source") + ".SourceMNSParameters.QueueName", source.sourceMNSParameters.queueName);
+  setBodyParameter(std::string("Source") + ".SourceMNSParameters.RegionId", source.sourceMNSParameters.regionId);
+  setBodyParameter(std::string("Source") + ".SourceMNSParameters.IsBase64Decode", source.sourceMNSParameters.isBase64Decode ? "true" : "false");
+  setBodyParameter(std::string("Source") + ".SourceRabbitMQParameters.QueueName", source.sourceRabbitMQParameters.queueName);
+  setBodyParameter(std::string("Source") + ".SourceRabbitMQParameters.VirtualHostName", source.sourceRabbitMQParameters.virtualHostName);
+  setBodyParameter(std::string("Source") + ".SourceRabbitMQParameters.InstanceId", source.sourceRabbitMQParameters.instanceId);
+  setBodyParameter(std::string("Source") + ".SourceRabbitMQParameters.RegionId", source.sourceRabbitMQParameters.regionId);
+}
+
+CreateEventStreamingRequest::RunOptions CreateEventStreamingRequest::getRunOptions() const {
+  return runOptions_;
+}
+
+void CreateEventStreamingRequest::setRunOptions(const CreateEventStreamingRequest::RunOptions &runOptions) {
+  runOptions_ = runOptions;
+  setBodyParameter(std::string("RunOptions") + ".BatchWindow.CountBasedWindow", std::to_string(runOptions.batchWindow.countBasedWindow));
+  setBodyParameter(std::string("RunOptions") + ".BatchWindow.TimeBasedWindow", std::to_string(runOptions.batchWindow.timeBasedWindow));
+  setBodyParameter(std::string("RunOptions") + ".RetryStrategy.PushRetryStrategy", runOptions.retryStrategy.pushRetryStrategy);
+  setBodyParameter(std::string("RunOptions") + ".RetryStrategy.MaximumRetryAttempts", std::to_string(runOptions.retryStrategy.maximumRetryAttempts));
+  setBodyParameter(std::string("RunOptions") + ".RetryStrategy.MaximumEventAgeInSeconds", std::to_string(runOptions.retryStrategy.maximumEventAgeInSeconds));
+  setBodyParameter(std::string("RunOptions") + ".DeadLetterQueue.Arn", runOptions.deadLetterQueue.arn);
+  setBodyParameter(std::string("RunOptions") + ".MaximumTasks", std::to_string(runOptions.maximumTasks));
+  setBodyParameter(std::string("RunOptions") + ".ErrorsTolerance", runOptions.errorsTolerance);
+}
+
+std::string CreateEventStreamingRequest::getEventStreamingName() const {
+  return eventStreamingName_;
+}
+
+void CreateEventStreamingRequest::setEventStreamingName(const std::string &eventStreamingName) {
+  eventStreamingName_ = eventStreamingName;
+  setBodyParameter(std::string("EventStreamingName"), eventStreamingName);
+}
+
+std::string CreateEventStreamingRequest::getTag() const {
+  return tag_;
+}
+
+void CreateEventStreamingRequest::setTag(const std::string &tag) {
+  tag_ = tag;
+  setBodyParameter(std::string("Tag"), tag);
+}
+