✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantClient.h

@@ -0,0 +1,302 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/ConnectParticipantErrors.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/connectparticipant/model/CreateParticipantConnectionResult.h>
+#include <aws/connectparticipant/model/DisconnectParticipantResult.h>
+#include <aws/connectparticipant/model/GetTranscriptResult.h>
+#include <aws/connectparticipant/model/SendEventResult.h>
+#include <aws/connectparticipant/model/SendMessageResult.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/http/HttpTypes.h>
+#include <future>
+#include <functional>
+
+namespace Aws
+{
+
+namespace Http
+{
+  class HttpClient;
+  class HttpClientFactory;
+} // namespace Http
+
+namespace Utils
+{
+  template< typename R, typename E> class Outcome;
+namespace Threading
+{
+  class Executor;
+} // namespace Threading
+} // namespace Utils
+
+namespace Auth
+{
+  class AWSCredentials;
+  class AWSCredentialsProvider;
+} // namespace Auth
+
+namespace Client
+{
+  class RetryStrategy;
+} // namespace Client
+
+namespace ConnectParticipant
+{
+
+namespace Model
+{
+        class CreateParticipantConnectionRequest;
+        class DisconnectParticipantRequest;
+        class GetTranscriptRequest;
+        class SendEventRequest;
+        class SendMessageRequest;
+
+        typedef Aws::Utils::Outcome<CreateParticipantConnectionResult, ConnectParticipantError> CreateParticipantConnectionOutcome;
+        typedef Aws::Utils::Outcome<DisconnectParticipantResult, ConnectParticipantError> DisconnectParticipantOutcome;
+        typedef Aws::Utils::Outcome<GetTranscriptResult, ConnectParticipantError> GetTranscriptOutcome;
+        typedef Aws::Utils::Outcome<SendEventResult, ConnectParticipantError> SendEventOutcome;
+        typedef Aws::Utils::Outcome<SendMessageResult, ConnectParticipantError> SendMessageOutcome;
+
+        typedef std::future<CreateParticipantConnectionOutcome> CreateParticipantConnectionOutcomeCallable;
+        typedef std::future<DisconnectParticipantOutcome> DisconnectParticipantOutcomeCallable;
+        typedef std::future<GetTranscriptOutcome> GetTranscriptOutcomeCallable;
+        typedef std::future<SendEventOutcome> SendEventOutcomeCallable;
+        typedef std::future<SendMessageOutcome> SendMessageOutcomeCallable;
+} // namespace Model
+
+  class ConnectParticipantClient;
+
+    typedef std::function<void(const ConnectParticipantClient*, const Model::CreateParticipantConnectionRequest&, const Model::CreateParticipantConnectionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateParticipantConnectionResponseReceivedHandler;
+    typedef std::function<void(const ConnectParticipantClient*, const Model::DisconnectParticipantRequest&, const Model::DisconnectParticipantOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisconnectParticipantResponseReceivedHandler;
+    typedef std::function<void(const ConnectParticipantClient*, const Model::GetTranscriptRequest&, const Model::GetTranscriptOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetTranscriptResponseReceivedHandler;
+    typedef std::function<void(const ConnectParticipantClient*, const Model::SendEventRequest&, const Model::SendEventOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SendEventResponseReceivedHandler;
+    typedef std::function<void(const ConnectParticipantClient*, const Model::SendMessageRequest&, const Model::SendMessageOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SendMessageResponseReceivedHandler;
+
+  /**
+   * <p>Amazon Connect is a cloud-based contact center solution that makes it easy to
+   * set up and manage a customer contact center and provide reliable customer
+   * engagement at any scale.</p> <p>Amazon Connect enables customer contacts through
+   * voice or chat.</p> <p>The APIs described here are used by chat participants,
+   * such as agents and customers.</p>
+   */
+  class AWS_CONNECTPARTICIPANT_API ConnectParticipantClient : public Aws::Client::AWSJsonClient
+  {
+    public:
+      typedef Aws::Client::AWSJsonClient BASECLASS;
+
+       /**
+        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        ConnectParticipantClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
+        * is not specified, it will be initialized to default values.
+        */
+        ConnectParticipantClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+       /**
+        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
+        * the default http client factory will be used
+        */
+        ConnectParticipantClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
+            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
+
+        virtual ~ConnectParticipantClient();
+
+
+        /**
+         * <p>Creates the participant's connection. Note that ParticipantToken is used for
+         * invoking this API instead of ConnectionToken.</p> <p>The participant token is
+         * valid for the lifetime of the participant – until the they are part of a
+         * contact.</p> <p>The response URL for <code>WEBSOCKET</code> Type has a connect
+         * expiry timeout of 100s. Clients must manually connect to the returned websocket
+         * URL and subscribe to the desired topic. </p> <p>For chat, you need to publish
+         * the following on the established websocket connection:</p> <p>
+         * <code>{"topic":"aws/subscribe","content":{"topics":["aws/chat"]}}</code> </p>
+         * <p>Upon websocket URL expiry, as specified in the response ConnectionExpiry
+         * parameter, clients need to call this API again to obtain a new websocket URL and
+         * perform the same steps as before.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/CreateParticipantConnection">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::CreateParticipantConnectionOutcome CreateParticipantConnection(const Model::CreateParticipantConnectionRequest& request) const;
+
+        /**
+         * <p>Creates the participant's connection. Note that ParticipantToken is used for
+         * invoking this API instead of ConnectionToken.</p> <p>The participant token is
+         * valid for the lifetime of the participant – until the they are part of a
+         * contact.</p> <p>The response URL for <code>WEBSOCKET</code> Type has a connect
+         * expiry timeout of 100s. Clients must manually connect to the returned websocket
+         * URL and subscribe to the desired topic. </p> <p>For chat, you need to publish
+         * the following on the established websocket connection:</p> <p>
+         * <code>{"topic":"aws/subscribe","content":{"topics":["aws/chat"]}}</code> </p>
+         * <p>Upon websocket URL expiry, as specified in the response ConnectionExpiry
+         * parameter, clients need to call this API again to obtain a new websocket URL and
+         * perform the same steps as before.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/CreateParticipantConnection">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::CreateParticipantConnectionOutcomeCallable CreateParticipantConnectionCallable(const Model::CreateParticipantConnectionRequest& request) const;
+
+        /**
+         * <p>Creates the participant's connection. Note that ParticipantToken is used for
+         * invoking this API instead of ConnectionToken.</p> <p>The participant token is
+         * valid for the lifetime of the participant – until the they are part of a
+         * contact.</p> <p>The response URL for <code>WEBSOCKET</code> Type has a connect
+         * expiry timeout of 100s. Clients must manually connect to the returned websocket
+         * URL and subscribe to the desired topic. </p> <p>For chat, you need to publish
+         * the following on the established websocket connection:</p> <p>
+         * <code>{"topic":"aws/subscribe","content":{"topics":["aws/chat"]}}</code> </p>
+         * <p>Upon websocket URL expiry, as specified in the response ConnectionExpiry
+         * parameter, clients need to call this API again to obtain a new websocket URL and
+         * perform the same steps as before.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/CreateParticipantConnection">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void CreateParticipantConnectionAsync(const Model::CreateParticipantConnectionRequest& request, const CreateParticipantConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Disconnects a participant. Note that ConnectionToken is used for invoking
+         * this API instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/DisconnectParticipant">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::DisconnectParticipantOutcome DisconnectParticipant(const Model::DisconnectParticipantRequest& request) const;
+
+        /**
+         * <p>Disconnects a participant. Note that ConnectionToken is used for invoking
+         * this API instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/DisconnectParticipant">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::DisconnectParticipantOutcomeCallable DisconnectParticipantCallable(const Model::DisconnectParticipantRequest& request) const;
+
+        /**
+         * <p>Disconnects a participant. Note that ConnectionToken is used for invoking
+         * this API instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/DisconnectParticipant">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void DisconnectParticipantAsync(const Model::DisconnectParticipantRequest& request, const DisconnectParticipantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Retrieves a transcript of the session. Note that ConnectionToken is used for
+         * invoking this API instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/GetTranscript">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetTranscriptOutcome GetTranscript(const Model::GetTranscriptRequest& request) const;
+
+        /**
+         * <p>Retrieves a transcript of the session. Note that ConnectionToken is used for
+         * invoking this API instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/GetTranscript">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::GetTranscriptOutcomeCallable GetTranscriptCallable(const Model::GetTranscriptRequest& request) const;
+
+        /**
+         * <p>Retrieves a transcript of the session. Note that ConnectionToken is used for
+         * invoking this API instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/GetTranscript">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void GetTranscriptAsync(const Model::GetTranscriptRequest& request, const GetTranscriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Sends an event. Note that ConnectionToken is used for invoking this API
+         * instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/SendEvent">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::SendEventOutcome SendEvent(const Model::SendEventRequest& request) const;
+
+        /**
+         * <p>Sends an event. Note that ConnectionToken is used for invoking this API
+         * instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/SendEvent">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::SendEventOutcomeCallable SendEventCallable(const Model::SendEventRequest& request) const;
+
+        /**
+         * <p>Sends an event. Note that ConnectionToken is used for invoking this API
+         * instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/SendEvent">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void SendEventAsync(const Model::SendEventRequest& request, const SendEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+        /**
+         * <p>Sends a message. Note that ConnectionToken is used for invoking this API
+         * instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/SendMessage">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::SendMessageOutcome SendMessage(const Model::SendMessageRequest& request) const;
+
+        /**
+         * <p>Sends a message. Note that ConnectionToken is used for invoking this API
+         * instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/SendMessage">AWS
+         * API Reference</a></p>
+         *
+         * returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        virtual Model::SendMessageOutcomeCallable SendMessageCallable(const Model::SendMessageRequest& request) const;
+
+        /**
+         * <p>Sends a message. Note that ConnectionToken is used for invoking this API
+         * instead of ParticipantToken.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/SendMessage">AWS
+         * API Reference</a></p>
+         *
+         * Queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        virtual void SendMessageAsync(const Model::SendMessageRequest& request, const SendMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
+
+
+      void OverrideEndpoint(const Aws::String& endpoint);
+    private:
+      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
+        void CreateParticipantConnectionAsyncHelper(const Model::CreateParticipantConnectionRequest& request, const CreateParticipantConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void DisconnectParticipantAsyncHelper(const Model::DisconnectParticipantRequest& request, const DisconnectParticipantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void GetTranscriptAsyncHelper(const Model::GetTranscriptRequest& request, const GetTranscriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void SendEventAsyncHelper(const Model::SendEventRequest& request, const SendEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+        void SendMessageAsyncHelper(const Model::SendMessageRequest& request, const SendMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
+
+      Aws::String m_uri;
+      Aws::String m_configScheme;
+      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
+  };
+
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantEndpoint.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/Region.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+
+namespace ConnectParticipant
+{
+namespace ConnectParticipantEndpoint
+{
+AWS_CONNECTPARTICIPANT_API Aws::String ForRegion(const Aws::String& regionName, bool useDualStack = false);
+} // namespace ConnectParticipantEndpoint
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantErrorMarshaller.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_CONNECTPARTICIPANT_API ConnectParticipantErrorMarshaller : public Aws::Client::JsonErrorMarshaller
+{
+public:
+  Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
+};
+
+} // namespace Client
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantErrors.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+enum class ConnectParticipantErrors
+{
+  //From Core//
+  //////////////////////////////////////////////////////////////////////////////////////////
+  INCOMPLETE_SIGNATURE = 0,
+  INTERNAL_FAILURE = 1,
+  INVALID_ACTION = 2,
+  INVALID_CLIENT_TOKEN_ID = 3,
+  INVALID_PARAMETER_COMBINATION = 4,
+  INVALID_QUERY_PARAMETER = 5,
+  INVALID_PARAMETER_VALUE = 6,
+  MISSING_ACTION = 7, // SDK should never allow
+  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
+  MISSING_PARAMETER = 9, // SDK should never allow
+  OPT_IN_REQUIRED = 10,
+  REQUEST_EXPIRED = 11,
+  SERVICE_UNAVAILABLE = 12,
+  THROTTLING = 13,
+  VALIDATION = 14,
+  ACCESS_DENIED = 15,
+  RESOURCE_NOT_FOUND = 16,
+  UNRECOGNIZED_CLIENT = 17,
+  MALFORMED_QUERY_STRING = 18,
+  SLOW_DOWN = 19,
+  REQUEST_TIME_TOO_SKEWED = 20,
+  INVALID_SIGNATURE = 21,
+  SIGNATURE_DOES_NOT_MATCH = 22,
+  INVALID_ACCESS_KEY_ID = 23,
+  REQUEST_TIMEOUT = 24,
+  NETWORK_CONNECTION = 99,
+
+  UNKNOWN = 100,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  INTERNAL_SERVER= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1
+};
+
+class AWS_CONNECTPARTICIPANT_API ConnectParticipantError : public Aws::Client::AWSError<ConnectParticipantErrors>
+{
+public:
+  ConnectParticipantError() {}
+  ConnectParticipantError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<ConnectParticipantErrors>(rhs) {}
+  ConnectParticipantError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<ConnectParticipantErrors>(rhs) {}
+  ConnectParticipantError(const Aws::Client::AWSError<ConnectParticipantErrors>& rhs) : Aws::Client::AWSError<ConnectParticipantErrors>(rhs) {}
+  ConnectParticipantError(Aws::Client::AWSError<ConnectParticipantErrors>&& rhs) : Aws::Client::AWSError<ConnectParticipantErrors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace ConnectParticipantErrorMapper
+{
+  AWS_CONNECTPARTICIPANT_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantRequest.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+  class AWS_CONNECTPARTICIPANT_API ConnectParticipantRequest : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    virtual ~ConnectParticipantRequest () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_1 ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2018-09-07"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipant_EXPORTS.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#ifdef _MSC_VER
+    //disable windows complaining about max template size.
+    #pragma warning (disable : 4503)
+#endif // _MSC_VER
+
+#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
+    #ifdef _MSC_VER
+        #pragma warning(disable : 4251)
+    #endif // _MSC_VER
+
+    #ifdef USE_IMPORT_EXPORT
+        #ifdef AWS_CONNECTPARTICIPANT_EXPORTS
+            #define AWS_CONNECTPARTICIPANT_API __declspec(dllexport)
+        #else
+            #define AWS_CONNECTPARTICIPANT_API __declspec(dllimport)
+        #endif /* AWS_CONNECTPARTICIPANT_EXPORTS */
+    #else
+        #define AWS_CONNECTPARTICIPANT_API
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_CONNECTPARTICIPANT_API
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/ChatItemType.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+  enum class ChatItemType
+  {
+    NOT_SET,
+    MESSAGE,
+    EVENT,
+    CONNECTION_ACK
+  };
+
+namespace ChatItemTypeMapper
+{
+AWS_CONNECTPARTICIPANT_API ChatItemType GetChatItemTypeForName(const Aws::String& name);
+
+AWS_CONNECTPARTICIPANT_API Aws::String GetNameForChatItemType(ChatItemType value);
+} // namespace ChatItemTypeMapper
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/ConnectionCredentials.h

@@ -0,0 +1,140 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   * <p>Connection credentials. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/ConnectionCredentials">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CONNECTPARTICIPANT_API ConnectionCredentials
+  {
+  public:
+    ConnectionCredentials();
+    ConnectionCredentials(Aws::Utils::Json::JsonView jsonValue);
+    ConnectionCredentials& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline const Aws::String& GetConnectionToken() const{ return m_connectionToken; }
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline bool ConnectionTokenHasBeenSet() const { return m_connectionTokenHasBeenSet; }
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline void SetConnectionToken(const Aws::String& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = value; }
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline void SetConnectionToken(Aws::String&& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = std::move(value); }
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline void SetConnectionToken(const char* value) { m_connectionTokenHasBeenSet = true; m_connectionToken.assign(value); }
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline ConnectionCredentials& WithConnectionToken(const Aws::String& value) { SetConnectionToken(value); return *this;}
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline ConnectionCredentials& WithConnectionToken(Aws::String&& value) { SetConnectionToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The connection token.</p>
+     */
+    inline ConnectionCredentials& WithConnectionToken(const char* value) { SetConnectionToken(value); return *this;}
+
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline const Aws::String& GetExpiry() const{ return m_expiry; }
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline bool ExpiryHasBeenSet() const { return m_expiryHasBeenSet; }
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetExpiry(const Aws::String& value) { m_expiryHasBeenSet = true; m_expiry = value; }
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetExpiry(Aws::String&& value) { m_expiryHasBeenSet = true; m_expiry = std::move(value); }
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetExpiry(const char* value) { m_expiryHasBeenSet = true; m_expiry.assign(value); }
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline ConnectionCredentials& WithExpiry(const Aws::String& value) { SetExpiry(value); return *this;}
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline ConnectionCredentials& WithExpiry(Aws::String&& value) { SetExpiry(std::move(value)); return *this;}
+
+    /**
+     * <p>The expiration of the token.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline ConnectionCredentials& WithExpiry(const char* value) { SetExpiry(value); return *this;}
+
+  private:
+
+    Aws::String m_connectionToken;
+    bool m_connectionTokenHasBeenSet;
+
+    Aws::String m_expiry;
+    bool m_expiryHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/ConnectionType.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+  enum class ConnectionType
+  {
+    NOT_SET,
+    WEBSOCKET,
+    CONNECTION_CREDENTIALS
+  };
+
+namespace ConnectionTypeMapper
+{
+AWS_CONNECTPARTICIPANT_API ConnectionType GetConnectionTypeForName(const Aws::String& name);
+
+AWS_CONNECTPARTICIPANT_API Aws::String GetNameForConnectionType(ConnectionType value);
+} // namespace ConnectionTypeMapper
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/CreateParticipantConnectionRequest.h

@@ -0,0 +1,147 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/ConnectParticipantRequest.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/connectparticipant/model/ConnectionType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CONNECTPARTICIPANT_API CreateParticipantConnectionRequest : public ConnectParticipantRequest
+  {
+  public:
+    CreateParticipantConnectionRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateParticipantConnection"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline const Aws::Vector<ConnectionType>& GetType() const{ return m_type; }
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline void SetType(const Aws::Vector<ConnectionType>& value) { m_typeHasBeenSet = true; m_type = value; }
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline void SetType(Aws::Vector<ConnectionType>&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline CreateParticipantConnectionRequest& WithType(const Aws::Vector<ConnectionType>& value) { SetType(value); return *this;}
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline CreateParticipantConnectionRequest& WithType(Aws::Vector<ConnectionType>&& value) { SetType(std::move(value)); return *this;}
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline CreateParticipantConnectionRequest& AddType(const ConnectionType& value) { m_typeHasBeenSet = true; m_type.push_back(value); return *this; }
+
+    /**
+     * <p>Type of connection information required.</p>
+     */
+    inline CreateParticipantConnectionRequest& AddType(ConnectionType&& value) { m_typeHasBeenSet = true; m_type.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline const Aws::String& GetParticipantToken() const{ return m_participantToken; }
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline bool ParticipantTokenHasBeenSet() const { return m_participantTokenHasBeenSet; }
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline void SetParticipantToken(const Aws::String& value) { m_participantTokenHasBeenSet = true; m_participantToken = value; }
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline void SetParticipantToken(Aws::String&& value) { m_participantTokenHasBeenSet = true; m_participantToken = std::move(value); }
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline void SetParticipantToken(const char* value) { m_participantTokenHasBeenSet = true; m_participantToken.assign(value); }
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline CreateParticipantConnectionRequest& WithParticipantToken(const Aws::String& value) { SetParticipantToken(value); return *this;}
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline CreateParticipantConnectionRequest& WithParticipantToken(Aws::String&& value) { SetParticipantToken(std::move(value)); return *this;}
+
+    /**
+     * <p>Participant Token as obtained from <a
+     * href="https://docs.aws.amazon.com/connect/latest/APIReference/API_StartChatContactResponse.html">StartChatContact</a>
+     * API response.</p>
+     */
+    inline CreateParticipantConnectionRequest& WithParticipantToken(const char* value) { SetParticipantToken(value); return *this;}
+
+  private:
+
+    Aws::Vector<ConnectionType> m_type;
+    bool m_typeHasBeenSet;
+
+    Aws::String m_participantToken;
+    bool m_participantTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/CreateParticipantConnectionResult.h

@@ -0,0 +1,101 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/model/Websocket.h>
+#include <aws/connectparticipant/model/ConnectionCredentials.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+  class AWS_CONNECTPARTICIPANT_API CreateParticipantConnectionResult
+  {
+  public:
+    CreateParticipantConnectionResult();
+    CreateParticipantConnectionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    CreateParticipantConnectionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>Creates the participant's websocket connection.</p>
+     */
+    inline const Websocket& GetWebsocket() const{ return m_websocket; }
+
+    /**
+     * <p>Creates the participant's websocket connection.</p>
+     */
+    inline void SetWebsocket(const Websocket& value) { m_websocket = value; }
+
+    /**
+     * <p>Creates the participant's websocket connection.</p>
+     */
+    inline void SetWebsocket(Websocket&& value) { m_websocket = std::move(value); }
+
+    /**
+     * <p>Creates the participant's websocket connection.</p>
+     */
+    inline CreateParticipantConnectionResult& WithWebsocket(const Websocket& value) { SetWebsocket(value); return *this;}
+
+    /**
+     * <p>Creates the participant's websocket connection.</p>
+     */
+    inline CreateParticipantConnectionResult& WithWebsocket(Websocket&& value) { SetWebsocket(std::move(value)); return *this;}
+
+
+    /**
+     * <p>Creates the participant's connection credentials. The authentication token
+     * associated with the participant's connection.</p>
+     */
+    inline const ConnectionCredentials& GetConnectionCredentials() const{ return m_connectionCredentials; }
+
+    /**
+     * <p>Creates the participant's connection credentials. The authentication token
+     * associated with the participant's connection.</p>
+     */
+    inline void SetConnectionCredentials(const ConnectionCredentials& value) { m_connectionCredentials = value; }
+
+    /**
+     * <p>Creates the participant's connection credentials. The authentication token
+     * associated with the participant's connection.</p>
+     */
+    inline void SetConnectionCredentials(ConnectionCredentials&& value) { m_connectionCredentials = std::move(value); }
+
+    /**
+     * <p>Creates the participant's connection credentials. The authentication token
+     * associated with the participant's connection.</p>
+     */
+    inline CreateParticipantConnectionResult& WithConnectionCredentials(const ConnectionCredentials& value) { SetConnectionCredentials(value); return *this;}
+
+    /**
+     * <p>Creates the participant's connection credentials. The authentication token
+     * associated with the participant's connection.</p>
+     */
+    inline CreateParticipantConnectionResult& WithConnectionCredentials(ConnectionCredentials&& value) { SetConnectionCredentials(std::move(value)); return *this;}
+
+  private:
+
+    Websocket m_websocket;
+
+    ConnectionCredentials m_connectionCredentials;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/DisconnectParticipantRequest.h

@@ -0,0 +1,138 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/ConnectParticipantRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+#include <aws/core/utils/UUID.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CONNECTPARTICIPANT_API DisconnectParticipantRequest : public ConnectParticipantRequest
+  {
+  public:
+    DisconnectParticipantRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DisconnectParticipant"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline const Aws::String& GetClientToken() const{ return m_clientToken; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = std::move(value); }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline DisconnectParticipantRequest& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline DisconnectParticipantRequest& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline DisconnectParticipantRequest& WithClientToken(const char* value) { SetClientToken(value); return *this;}
+
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline const Aws::String& GetConnectionToken() const{ return m_connectionToken; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline bool ConnectionTokenHasBeenSet() const { return m_connectionTokenHasBeenSet; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(const Aws::String& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = value; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(Aws::String&& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = std::move(value); }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(const char* value) { m_connectionTokenHasBeenSet = true; m_connectionToken.assign(value); }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline DisconnectParticipantRequest& WithConnectionToken(const Aws::String& value) { SetConnectionToken(value); return *this;}
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline DisconnectParticipantRequest& WithConnectionToken(Aws::String&& value) { SetConnectionToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline DisconnectParticipantRequest& WithConnectionToken(const char* value) { SetConnectionToken(value); return *this;}
+
+  private:
+
+    Aws::String m_clientToken;
+    bool m_clientTokenHasBeenSet;
+
+    Aws::String m_connectionToken;
+    bool m_connectionTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/DisconnectParticipantResult.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+  class AWS_CONNECTPARTICIPANT_API DisconnectParticipantResult
+  {
+  public:
+    DisconnectParticipantResult();
+    DisconnectParticipantResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    DisconnectParticipantResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/GetTranscriptRequest.h

@@ -0,0 +1,324 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/ConnectParticipantRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/connectparticipant/model/ScanDirection.h>
+#include <aws/connectparticipant/model/SortKey.h>
+#include <aws/connectparticipant/model/StartPosition.h>
+#include <utility>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CONNECTPARTICIPANT_API GetTranscriptRequest : public ConnectParticipantRequest
+  {
+  public:
+    GetTranscriptRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetTranscript"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline const Aws::String& GetContactId() const{ return m_contactId; }
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline bool ContactIdHasBeenSet() const { return m_contactIdHasBeenSet; }
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline void SetContactId(const Aws::String& value) { m_contactIdHasBeenSet = true; m_contactId = value; }
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline void SetContactId(Aws::String&& value) { m_contactIdHasBeenSet = true; m_contactId = std::move(value); }
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline void SetContactId(const char* value) { m_contactIdHasBeenSet = true; m_contactId.assign(value); }
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline GetTranscriptRequest& WithContactId(const Aws::String& value) { SetContactId(value); return *this;}
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline GetTranscriptRequest& WithContactId(Aws::String&& value) { SetContactId(std::move(value)); return *this;}
+
+    /**
+     * <p>The contactId from the current contact chain for which transcript is
+     * needed.</p>
+     */
+    inline GetTranscriptRequest& WithContactId(const char* value) { SetContactId(value); return *this;}
+
+
+    /**
+     * <p>The maximum number of results to return in the page. Default: 10. </p>
+     */
+    inline int GetMaxResults() const{ return m_maxResults; }
+
+    /**
+     * <p>The maximum number of results to return in the page. Default: 10. </p>
+     */
+    inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+
+    /**
+     * <p>The maximum number of results to return in the page. Default: 10. </p>
+     */
+    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
+
+    /**
+     * <p>The maximum number of results to return in the page. Default: 10. </p>
+     */
+    inline GetTranscriptRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
+
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline GetTranscriptRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline GetTranscriptRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline GetTranscriptRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+
+    /**
+     * <p>The direction from StartPosition from which to retrieve message. Default:
+     * BACKWARD when no StartPosition is provided, FORWARD with StartPosition. </p>
+     */
+    inline const ScanDirection& GetScanDirection() const{ return m_scanDirection; }
+
+    /**
+     * <p>The direction from StartPosition from which to retrieve message. Default:
+     * BACKWARD when no StartPosition is provided, FORWARD with StartPosition. </p>
+     */
+    inline bool ScanDirectionHasBeenSet() const { return m_scanDirectionHasBeenSet; }
+
+    /**
+     * <p>The direction from StartPosition from which to retrieve message. Default:
+     * BACKWARD when no StartPosition is provided, FORWARD with StartPosition. </p>
+     */
+    inline void SetScanDirection(const ScanDirection& value) { m_scanDirectionHasBeenSet = true; m_scanDirection = value; }
+
+    /**
+     * <p>The direction from StartPosition from which to retrieve message. Default:
+     * BACKWARD when no StartPosition is provided, FORWARD with StartPosition. </p>
+     */
+    inline void SetScanDirection(ScanDirection&& value) { m_scanDirectionHasBeenSet = true; m_scanDirection = std::move(value); }
+
+    /**
+     * <p>The direction from StartPosition from which to retrieve message. Default:
+     * BACKWARD when no StartPosition is provided, FORWARD with StartPosition. </p>
+     */
+    inline GetTranscriptRequest& WithScanDirection(const ScanDirection& value) { SetScanDirection(value); return *this;}
+
+    /**
+     * <p>The direction from StartPosition from which to retrieve message. Default:
+     * BACKWARD when no StartPosition is provided, FORWARD with StartPosition. </p>
+     */
+    inline GetTranscriptRequest& WithScanDirection(ScanDirection&& value) { SetScanDirection(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The sort order for the records. Default: DESCENDING.</p>
+     */
+    inline const SortKey& GetSortOrder() const{ return m_sortOrder; }
+
+    /**
+     * <p>The sort order for the records. Default: DESCENDING.</p>
+     */
+    inline bool SortOrderHasBeenSet() const { return m_sortOrderHasBeenSet; }
+
+    /**
+     * <p>The sort order for the records. Default: DESCENDING.</p>
+     */
+    inline void SetSortOrder(const SortKey& value) { m_sortOrderHasBeenSet = true; m_sortOrder = value; }
+
+    /**
+     * <p>The sort order for the records. Default: DESCENDING.</p>
+     */
+    inline void SetSortOrder(SortKey&& value) { m_sortOrderHasBeenSet = true; m_sortOrder = std::move(value); }
+
+    /**
+     * <p>The sort order for the records. Default: DESCENDING.</p>
+     */
+    inline GetTranscriptRequest& WithSortOrder(const SortKey& value) { SetSortOrder(value); return *this;}
+
+    /**
+     * <p>The sort order for the records. Default: DESCENDING.</p>
+     */
+    inline GetTranscriptRequest& WithSortOrder(SortKey&& value) { SetSortOrder(std::move(value)); return *this;}
+
+
+    /**
+     * <p>A filtering option for where to start.</p>
+     */
+    inline const StartPosition& GetStartPosition() const{ return m_startPosition; }
+
+    /**
+     * <p>A filtering option for where to start.</p>
+     */
+    inline bool StartPositionHasBeenSet() const { return m_startPositionHasBeenSet; }
+
+    /**
+     * <p>A filtering option for where to start.</p>
+     */
+    inline void SetStartPosition(const StartPosition& value) { m_startPositionHasBeenSet = true; m_startPosition = value; }
+
+    /**
+     * <p>A filtering option for where to start.</p>
+     */
+    inline void SetStartPosition(StartPosition&& value) { m_startPositionHasBeenSet = true; m_startPosition = std::move(value); }
+
+    /**
+     * <p>A filtering option for where to start.</p>
+     */
+    inline GetTranscriptRequest& WithStartPosition(const StartPosition& value) { SetStartPosition(value); return *this;}
+
+    /**
+     * <p>A filtering option for where to start.</p>
+     */
+    inline GetTranscriptRequest& WithStartPosition(StartPosition&& value) { SetStartPosition(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline const Aws::String& GetConnectionToken() const{ return m_connectionToken; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline bool ConnectionTokenHasBeenSet() const { return m_connectionTokenHasBeenSet; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(const Aws::String& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = value; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(Aws::String&& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = std::move(value); }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(const char* value) { m_connectionTokenHasBeenSet = true; m_connectionToken.assign(value); }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline GetTranscriptRequest& WithConnectionToken(const Aws::String& value) { SetConnectionToken(value); return *this;}
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline GetTranscriptRequest& WithConnectionToken(Aws::String&& value) { SetConnectionToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline GetTranscriptRequest& WithConnectionToken(const char* value) { SetConnectionToken(value); return *this;}
+
+  private:
+
+    Aws::String m_contactId;
+    bool m_contactIdHasBeenSet;
+
+    int m_maxResults;
+    bool m_maxResultsHasBeenSet;
+
+    Aws::String m_nextToken;
+    bool m_nextTokenHasBeenSet;
+
+    ScanDirection m_scanDirection;
+    bool m_scanDirectionHasBeenSet;
+
+    SortKey m_sortOrder;
+    bool m_sortOrderHasBeenSet;
+
+    StartPosition m_startPosition;
+    bool m_startPositionHasBeenSet;
+
+    Aws::String m_connectionToken;
+    bool m_connectionTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/GetTranscriptResult.h

@@ -0,0 +1,162 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/connectparticipant/model/Item.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+  class AWS_CONNECTPARTICIPANT_API GetTranscriptResult
+  {
+  public:
+    GetTranscriptResult();
+    GetTranscriptResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    GetTranscriptResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline const Aws::String& GetInitialContactId() const{ return m_initialContactId; }
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline void SetInitialContactId(const Aws::String& value) { m_initialContactId = value; }
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline void SetInitialContactId(Aws::String&& value) { m_initialContactId = std::move(value); }
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline void SetInitialContactId(const char* value) { m_initialContactId.assign(value); }
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline GetTranscriptResult& WithInitialContactId(const Aws::String& value) { SetInitialContactId(value); return *this;}
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline GetTranscriptResult& WithInitialContactId(Aws::String&& value) { SetInitialContactId(std::move(value)); return *this;}
+
+    /**
+     * <p>The initial contact ID for the contact. </p>
+     */
+    inline GetTranscriptResult& WithInitialContactId(const char* value) { SetInitialContactId(value); return *this;}
+
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline const Aws::Vector<Item>& GetTranscript() const{ return m_transcript; }
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline void SetTranscript(const Aws::Vector<Item>& value) { m_transcript = value; }
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline void SetTranscript(Aws::Vector<Item>&& value) { m_transcript = std::move(value); }
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline GetTranscriptResult& WithTranscript(const Aws::Vector<Item>& value) { SetTranscript(value); return *this;}
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline GetTranscriptResult& WithTranscript(Aws::Vector<Item>&& value) { SetTranscript(std::move(value)); return *this;}
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline GetTranscriptResult& AddTranscript(const Item& value) { m_transcript.push_back(value); return *this; }
+
+    /**
+     * <p>The list of messages in the session.</p>
+     */
+    inline GetTranscriptResult& AddTranscript(Item&& value) { m_transcript.push_back(std::move(value)); return *this; }
+
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline const Aws::String& GetNextToken() const{ return m_nextToken; }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline GetTranscriptResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline GetTranscriptResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The pagination token. Use the value returned previously in the next
+     * subsequent request to retrieve the next set of results.</p>
+     */
+    inline GetTranscriptResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
+
+  private:
+
+    Aws::String m_initialContactId;
+
+    Aws::Vector<Item> m_transcript;
+
+    Aws::String m_nextToken;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/Item.h

@@ -0,0 +1,395 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/connectparticipant/model/ChatItemType.h>
+#include <aws/connectparticipant/model/ParticipantRole.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   * <p>An item - message or event - that has been sent. </p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/Item">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CONNECTPARTICIPANT_API Item
+  {
+  public:
+    Item();
+    Item(Aws::Utils::Json::JsonView jsonValue);
+    Item& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline const Aws::String& GetAbsoluteTime() const{ return m_absoluteTime; }
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline bool AbsoluteTimeHasBeenSet() const { return m_absoluteTimeHasBeenSet; }
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const Aws::String& value) { m_absoluteTimeHasBeenSet = true; m_absoluteTime = value; }
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(Aws::String&& value) { m_absoluteTimeHasBeenSet = true; m_absoluteTime = std::move(value); }
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const char* value) { m_absoluteTimeHasBeenSet = true; m_absoluteTime.assign(value); }
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline Item& WithAbsoluteTime(const Aws::String& value) { SetAbsoluteTime(value); return *this;}
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline Item& WithAbsoluteTime(Aws::String&& value) { SetAbsoluteTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The time when the message or event was sent.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline Item& WithAbsoluteTime(const char* value) { SetAbsoluteTime(value); return *this;}
+
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline const Aws::String& GetContent() const{ return m_content; }
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline bool ContentHasBeenSet() const { return m_contentHasBeenSet; }
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline void SetContent(const Aws::String& value) { m_contentHasBeenSet = true; m_content = value; }
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline void SetContent(Aws::String&& value) { m_contentHasBeenSet = true; m_content = std::move(value); }
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline void SetContent(const char* value) { m_contentHasBeenSet = true; m_content.assign(value); }
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline Item& WithContent(const Aws::String& value) { SetContent(value); return *this;}
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline Item& WithContent(Aws::String&& value) { SetContent(std::move(value)); return *this;}
+
+    /**
+     * <p>The content of the message or event.</p>
+     */
+    inline Item& WithContent(const char* value) { SetContent(value); return *this;}
+
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline const Aws::String& GetContentType() const{ return m_contentType; }
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline bool ContentTypeHasBeenSet() const { return m_contentTypeHasBeenSet; }
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline void SetContentType(const Aws::String& value) { m_contentTypeHasBeenSet = true; m_contentType = value; }
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline void SetContentType(Aws::String&& value) { m_contentTypeHasBeenSet = true; m_contentType = std::move(value); }
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline void SetContentType(const char* value) { m_contentTypeHasBeenSet = true; m_contentType.assign(value); }
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline Item& WithContentType(const Aws::String& value) { SetContentType(value); return *this;}
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline Item& WithContentType(Aws::String&& value) { SetContentType(std::move(value)); return *this;}
+
+    /**
+     * <p>The type of content of the item.</p>
+     */
+    inline Item& WithContentType(const char* value) { SetContentType(value); return *this;}
+
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline Item& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline Item& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the item.</p>
+     */
+    inline Item& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>Type of the item: message or event. </p>
+     */
+    inline const ChatItemType& GetType() const{ return m_type; }
+
+    /**
+     * <p>Type of the item: message or event. </p>
+     */
+    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+
+    /**
+     * <p>Type of the item: message or event. </p>
+     */
+    inline void SetType(const ChatItemType& value) { m_typeHasBeenSet = true; m_type = value; }
+
+    /**
+     * <p>Type of the item: message or event. </p>
+     */
+    inline void SetType(ChatItemType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
+
+    /**
+     * <p>Type of the item: message or event. </p>
+     */
+    inline Item& WithType(const ChatItemType& value) { SetType(value); return *this;}
+
+    /**
+     * <p>Type of the item: message or event. </p>
+     */
+    inline Item& WithType(ChatItemType&& value) { SetType(std::move(value)); return *this;}
+
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline const Aws::String& GetParticipantId() const{ return m_participantId; }
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline bool ParticipantIdHasBeenSet() const { return m_participantIdHasBeenSet; }
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline void SetParticipantId(const Aws::String& value) { m_participantIdHasBeenSet = true; m_participantId = value; }
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline void SetParticipantId(Aws::String&& value) { m_participantIdHasBeenSet = true; m_participantId = std::move(value); }
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline void SetParticipantId(const char* value) { m_participantIdHasBeenSet = true; m_participantId.assign(value); }
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline Item& WithParticipantId(const Aws::String& value) { SetParticipantId(value); return *this;}
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline Item& WithParticipantId(Aws::String&& value) { SetParticipantId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the sender in the session.</p>
+     */
+    inline Item& WithParticipantId(const char* value) { SetParticipantId(value); return *this;}
+
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline const Aws::String& GetDisplayName() const{ return m_displayName; }
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline bool DisplayNameHasBeenSet() const { return m_displayNameHasBeenSet; }
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline void SetDisplayName(const Aws::String& value) { m_displayNameHasBeenSet = true; m_displayName = value; }
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline void SetDisplayName(Aws::String&& value) { m_displayNameHasBeenSet = true; m_displayName = std::move(value); }
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline void SetDisplayName(const char* value) { m_displayNameHasBeenSet = true; m_displayName.assign(value); }
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline Item& WithDisplayName(const Aws::String& value) { SetDisplayName(value); return *this;}
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline Item& WithDisplayName(Aws::String&& value) { SetDisplayName(std::move(value)); return *this;}
+
+    /**
+     * <p>The chat display name of the sender.</p>
+     */
+    inline Item& WithDisplayName(const char* value) { SetDisplayName(value); return *this;}
+
+
+    /**
+     * <p>The role of the sender. For example, is it a customer, agent, or system.</p>
+     */
+    inline const ParticipantRole& GetParticipantRole() const{ return m_participantRole; }
+
+    /**
+     * <p>The role of the sender. For example, is it a customer, agent, or system.</p>
+     */
+    inline bool ParticipantRoleHasBeenSet() const { return m_participantRoleHasBeenSet; }
+
+    /**
+     * <p>The role of the sender. For example, is it a customer, agent, or system.</p>
+     */
+    inline void SetParticipantRole(const ParticipantRole& value) { m_participantRoleHasBeenSet = true; m_participantRole = value; }
+
+    /**
+     * <p>The role of the sender. For example, is it a customer, agent, or system.</p>
+     */
+    inline void SetParticipantRole(ParticipantRole&& value) { m_participantRoleHasBeenSet = true; m_participantRole = std::move(value); }
+
+    /**
+     * <p>The role of the sender. For example, is it a customer, agent, or system.</p>
+     */
+    inline Item& WithParticipantRole(const ParticipantRole& value) { SetParticipantRole(value); return *this;}
+
+    /**
+     * <p>The role of the sender. For example, is it a customer, agent, or system.</p>
+     */
+    inline Item& WithParticipantRole(ParticipantRole&& value) { SetParticipantRole(std::move(value)); return *this;}
+
+  private:
+
+    Aws::String m_absoluteTime;
+    bool m_absoluteTimeHasBeenSet;
+
+    Aws::String m_content;
+    bool m_contentHasBeenSet;
+
+    Aws::String m_contentType;
+    bool m_contentTypeHasBeenSet;
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    ChatItemType m_type;
+    bool m_typeHasBeenSet;
+
+    Aws::String m_participantId;
+    bool m_participantIdHasBeenSet;
+
+    Aws::String m_displayName;
+    bool m_displayNameHasBeenSet;
+
+    ParticipantRole m_participantRole;
+    bool m_participantRoleHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/ParticipantRole.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+  enum class ParticipantRole
+  {
+    NOT_SET,
+    AGENT,
+    CUSTOMER,
+    SYSTEM
+  };
+
+namespace ParticipantRoleMapper
+{
+AWS_CONNECTPARTICIPANT_API ParticipantRole GetParticipantRoleForName(const Aws::String& name);
+
+AWS_CONNECTPARTICIPANT_API Aws::String GetNameForParticipantRole(ParticipantRole value);
+} // namespace ParticipantRoleMapper
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/ScanDirection.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+  enum class ScanDirection
+  {
+    NOT_SET,
+    FORWARD,
+    BACKWARD
+  };
+
+namespace ScanDirectionMapper
+{
+AWS_CONNECTPARTICIPANT_API ScanDirection GetScanDirectionForName(const Aws::String& name);
+
+AWS_CONNECTPARTICIPANT_API Aws::String GetNameForScanDirection(ScanDirection value);
+} // namespace ScanDirectionMapper
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/SendEventRequest.h

@@ -0,0 +1,258 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/ConnectParticipantRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+#include <aws/core/utils/UUID.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CONNECTPARTICIPANT_API SendEventRequest : public ConnectParticipantRequest
+  {
+  public:
+    SendEventRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "SendEvent"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline const Aws::String& GetContentType() const{ return m_contentType; }
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline bool ContentTypeHasBeenSet() const { return m_contentTypeHasBeenSet; }
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline void SetContentType(const Aws::String& value) { m_contentTypeHasBeenSet = true; m_contentType = value; }
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline void SetContentType(Aws::String&& value) { m_contentTypeHasBeenSet = true; m_contentType = std::move(value); }
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline void SetContentType(const char* value) { m_contentTypeHasBeenSet = true; m_contentType.assign(value); }
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline SendEventRequest& WithContentType(const Aws::String& value) { SetContentType(value); return *this;}
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline SendEventRequest& WithContentType(Aws::String&& value) { SetContentType(std::move(value)); return *this;}
+
+    /**
+     * <p>The content type of the request. Supported types are:</p> <ul> <li>
+     * <p>application/vnd.amazonaws.connect.event.typing</p> </li> <li>
+     * <p>application/vnd.amazonaws.connect.event.connection.acknowledged</p> </li>
+     * </ul>
+     */
+    inline SendEventRequest& WithContentType(const char* value) { SetContentType(value); return *this;}
+
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline const Aws::String& GetContent() const{ return m_content; }
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline bool ContentHasBeenSet() const { return m_contentHasBeenSet; }
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline void SetContent(const Aws::String& value) { m_contentHasBeenSet = true; m_content = value; }
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline void SetContent(Aws::String&& value) { m_contentHasBeenSet = true; m_content = std::move(value); }
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline void SetContent(const char* value) { m_contentHasBeenSet = true; m_content.assign(value); }
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline SendEventRequest& WithContent(const Aws::String& value) { SetContent(value); return *this;}
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline SendEventRequest& WithContent(Aws::String&& value) { SetContent(std::move(value)); return *this;}
+
+    /**
+     * <p>The content of the event to be sent (for example, message text). This is not
+     * yet supported.</p>
+     */
+    inline SendEventRequest& WithContent(const char* value) { SetContent(value); return *this;}
+
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline const Aws::String& GetClientToken() const{ return m_clientToken; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = std::move(value); }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline SendEventRequest& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline SendEventRequest& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline SendEventRequest& WithClientToken(const char* value) { SetClientToken(value); return *this;}
+
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline const Aws::String& GetConnectionToken() const{ return m_connectionToken; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline bool ConnectionTokenHasBeenSet() const { return m_connectionTokenHasBeenSet; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(const Aws::String& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = value; }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(Aws::String&& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = std::move(value); }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline void SetConnectionToken(const char* value) { m_connectionTokenHasBeenSet = true; m_connectionToken.assign(value); }
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline SendEventRequest& WithConnectionToken(const Aws::String& value) { SetConnectionToken(value); return *this;}
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline SendEventRequest& WithConnectionToken(Aws::String&& value) { SetConnectionToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The authentication token associated with the participant's connection.</p>
+     */
+    inline SendEventRequest& WithConnectionToken(const char* value) { SetConnectionToken(value); return *this;}
+
+  private:
+
+    Aws::String m_contentType;
+    bool m_contentTypeHasBeenSet;
+
+    Aws::String m_content;
+    bool m_contentHasBeenSet;
+
+    Aws::String m_clientToken;
+    bool m_clientTokenHasBeenSet;
+
+    Aws::String m_connectionToken;
+    bool m_connectionTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/SendEventResult.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+  class AWS_CONNECTPARTICIPANT_API SendEventResult
+  {
+  public:
+    SendEventResult();
+    SendEventResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    SendEventResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_id = value; }
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_id = std::move(value); }
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline void SetId(const char* value) { m_id.assign(value); }
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline SendEventResult& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline SendEventResult& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the response.</p>
+     */
+    inline SendEventResult& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline const Aws::String& GetAbsoluteTime() const{ return m_absoluteTime; }
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const Aws::String& value) { m_absoluteTime = value; }
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(Aws::String&& value) { m_absoluteTime = std::move(value); }
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const char* value) { m_absoluteTime.assign(value); }
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline SendEventResult& WithAbsoluteTime(const Aws::String& value) { SetAbsoluteTime(value); return *this;}
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline SendEventResult& WithAbsoluteTime(Aws::String&& value) { SetAbsoluteTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The time when the event was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline SendEventResult& WithAbsoluteTime(const char* value) { SetAbsoluteTime(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+
+    Aws::String m_absoluteTime;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/SendMessageRequest.h

@@ -0,0 +1,226 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/connectparticipant/ConnectParticipantRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+#include <aws/core/utils/UUID.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   */
+  class AWS_CONNECTPARTICIPANT_API SendMessageRequest : public ConnectParticipantRequest
+  {
+  public:
+    SendMessageRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "SendMessage"; }
+
+    Aws::String SerializePayload() const override;
+
+    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline const Aws::String& GetContentType() const{ return m_contentType; }
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline bool ContentTypeHasBeenSet() const { return m_contentTypeHasBeenSet; }
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline void SetContentType(const Aws::String& value) { m_contentTypeHasBeenSet = true; m_contentType = value; }
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline void SetContentType(Aws::String&& value) { m_contentTypeHasBeenSet = true; m_contentType = std::move(value); }
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline void SetContentType(const char* value) { m_contentTypeHasBeenSet = true; m_contentType.assign(value); }
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline SendMessageRequest& WithContentType(const Aws::String& value) { SetContentType(value); return *this;}
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline SendMessageRequest& WithContentType(Aws::String&& value) { SetContentType(std::move(value)); return *this;}
+
+    /**
+     * <p>The type of the content. Supported types are text/plain.</p>
+     */
+    inline SendMessageRequest& WithContentType(const char* value) { SetContentType(value); return *this;}
+
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline const Aws::String& GetContent() const{ return m_content; }
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline bool ContentHasBeenSet() const { return m_contentHasBeenSet; }
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline void SetContent(const Aws::String& value) { m_contentHasBeenSet = true; m_content = value; }
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline void SetContent(Aws::String&& value) { m_contentHasBeenSet = true; m_content = std::move(value); }
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline void SetContent(const char* value) { m_contentHasBeenSet = true; m_content.assign(value); }
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline SendMessageRequest& WithContent(const Aws::String& value) { SetContent(value); return *this;}
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline SendMessageRequest& WithContent(Aws::String&& value) { SetContent(std::move(value)); return *this;}
+
+    /**
+     * <p>The content of the message.</p>
+     */
+    inline SendMessageRequest& WithContent(const char* value) { SetContent(value); return *this;}
+
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline const Aws::String& GetClientToken() const{ return m_clientToken; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = std::move(value); }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); }
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline SendMessageRequest& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline SendMessageRequest& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;}
+
+    /**
+     * <p>A unique, case-sensitive identifier that you provide to ensure the
+     * idempotency of the request.</p>
+     */
+    inline SendMessageRequest& WithClientToken(const char* value) { SetClientToken(value); return *this;}
+
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline const Aws::String& GetConnectionToken() const{ return m_connectionToken; }
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline bool ConnectionTokenHasBeenSet() const { return m_connectionTokenHasBeenSet; }
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline void SetConnectionToken(const Aws::String& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = value; }
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline void SetConnectionToken(Aws::String&& value) { m_connectionTokenHasBeenSet = true; m_connectionToken = std::move(value); }
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline void SetConnectionToken(const char* value) { m_connectionTokenHasBeenSet = true; m_connectionToken.assign(value); }
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline SendMessageRequest& WithConnectionToken(const Aws::String& value) { SetConnectionToken(value); return *this;}
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline SendMessageRequest& WithConnectionToken(Aws::String&& value) { SetConnectionToken(std::move(value)); return *this;}
+
+    /**
+     * <p>The authentication token associated with the connection.</p>
+     */
+    inline SendMessageRequest& WithConnectionToken(const char* value) { SetConnectionToken(value); return *this;}
+
+  private:
+
+    Aws::String m_contentType;
+    bool m_contentTypeHasBeenSet;
+
+    Aws::String m_content;
+    bool m_contentHasBeenSet;
+
+    Aws::String m_clientToken;
+    bool m_clientTokenHasBeenSet;
+
+    Aws::String m_connectionToken;
+    bool m_connectionTokenHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/SendMessageResult.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+  class AWS_CONNECTPARTICIPANT_API SendMessageResult
+  {
+  public:
+    SendMessageResult();
+    SendMessageResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+    SendMessageResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
+
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline void SetId(const Aws::String& value) { m_id = value; }
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline void SetId(Aws::String&& value) { m_id = std::move(value); }
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline void SetId(const char* value) { m_id.assign(value); }
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline SendMessageResult& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline SendMessageResult& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the message.</p>
+     */
+    inline SendMessageResult& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline const Aws::String& GetAbsoluteTime() const{ return m_absoluteTime; }
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const Aws::String& value) { m_absoluteTime = value; }
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(Aws::String&& value) { m_absoluteTime = std::move(value); }
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const char* value) { m_absoluteTime.assign(value); }
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline SendMessageResult& WithAbsoluteTime(const Aws::String& value) { SetAbsoluteTime(value); return *this;}
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline SendMessageResult& WithAbsoluteTime(Aws::String&& value) { SetAbsoluteTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The time when the message was sent.</p> <p>It's specified in ISO 8601 format:
+     * yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline SendMessageResult& WithAbsoluteTime(const char* value) { SetAbsoluteTime(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+
+    Aws::String m_absoluteTime;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/SortKey.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace ConnectParticipant
+{
+namespace Model
+{
+  enum class SortKey
+  {
+    NOT_SET,
+    DESCENDING,
+    ASCENDING
+  };
+
+namespace SortKeyMapper
+{
+AWS_CONNECTPARTICIPANT_API SortKey GetSortKeyForName(const Aws::String& name);
+
+AWS_CONNECTPARTICIPANT_API Aws::String GetNameForSortKey(SortKey value);
+} // namespace SortKeyMapper
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/StartPosition.h

@@ -0,0 +1,165 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   * <p>A filtering option for where to start. For example, if you sent 100 messages,
+   * start with message 50. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/StartPosition">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CONNECTPARTICIPANT_API StartPosition
+  {
+  public:
+    StartPosition();
+    StartPosition(Aws::Utils::Json::JsonView jsonValue);
+    StartPosition& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline StartPosition& WithId(const Aws::String& value) { SetId(value); return *this;}
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline StartPosition& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+
+    /**
+     * <p>The ID of the message or event where to start. </p>
+     */
+    inline StartPosition& WithId(const char* value) { SetId(value); return *this;}
+
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline const Aws::String& GetAbsoluteTime() const{ return m_absoluteTime; }
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline bool AbsoluteTimeHasBeenSet() const { return m_absoluteTimeHasBeenSet; }
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const Aws::String& value) { m_absoluteTimeHasBeenSet = true; m_absoluteTime = value; }
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(Aws::String&& value) { m_absoluteTimeHasBeenSet = true; m_absoluteTime = std::move(value); }
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetAbsoluteTime(const char* value) { m_absoluteTimeHasBeenSet = true; m_absoluteTime.assign(value); }
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline StartPosition& WithAbsoluteTime(const Aws::String& value) { SetAbsoluteTime(value); return *this;}
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline StartPosition& WithAbsoluteTime(Aws::String&& value) { SetAbsoluteTime(std::move(value)); return *this;}
+
+    /**
+     * <p>The time in ISO format where to start.</p> <p>It's specified in ISO 8601
+     * format: yyyy-MM-ddThh:mm:ss.SSSZ. For example, 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline StartPosition& WithAbsoluteTime(const char* value) { SetAbsoluteTime(value); return *this;}
+
+
+    /**
+     * <p>The start position of the most recent message where you want to start. </p>
+     */
+    inline int GetMostRecent() const{ return m_mostRecent; }
+
+    /**
+     * <p>The start position of the most recent message where you want to start. </p>
+     */
+    inline bool MostRecentHasBeenSet() const { return m_mostRecentHasBeenSet; }
+
+    /**
+     * <p>The start position of the most recent message where you want to start. </p>
+     */
+    inline void SetMostRecent(int value) { m_mostRecentHasBeenSet = true; m_mostRecent = value; }
+
+    /**
+     * <p>The start position of the most recent message where you want to start. </p>
+     */
+    inline StartPosition& WithMostRecent(int value) { SetMostRecent(value); return *this;}
+
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet;
+
+    Aws::String m_absoluteTime;
+    bool m_absoluteTimeHasBeenSet;
+
+    int m_mostRecent;
+    bool m_mostRecentHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/model/Websocket.h

@@ -0,0 +1,148 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectparticipant/ConnectParticipant_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace ConnectParticipant
+{
+namespace Model
+{
+
+  /**
+   * <p>The websocket for the participant's connection.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/connectparticipant-2018-09-07/Websocket">AWS
+   * API Reference</a></p>
+   */
+  class AWS_CONNECTPARTICIPANT_API Websocket
+  {
+  public:
+    Websocket();
+    Websocket(Aws::Utils::Json::JsonView jsonValue);
+    Websocket& operator=(Aws::Utils::Json::JsonView jsonValue);
+    Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline const Aws::String& GetUrl() const{ return m_url; }
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline bool UrlHasBeenSet() const { return m_urlHasBeenSet; }
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline void SetUrl(const Aws::String& value) { m_urlHasBeenSet = true; m_url = value; }
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline void SetUrl(Aws::String&& value) { m_urlHasBeenSet = true; m_url = std::move(value); }
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline void SetUrl(const char* value) { m_urlHasBeenSet = true; m_url.assign(value); }
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline Websocket& WithUrl(const Aws::String& value) { SetUrl(value); return *this;}
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline Websocket& WithUrl(Aws::String&& value) { SetUrl(std::move(value)); return *this;}
+
+    /**
+     * <p>The URL of the websocket.</p>
+     */
+    inline Websocket& WithUrl(const char* value) { SetUrl(value); return *this;}
+
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline const Aws::String& GetConnectionExpiry() const{ return m_connectionExpiry; }
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline bool ConnectionExpiryHasBeenSet() const { return m_connectionExpiryHasBeenSet; }
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetConnectionExpiry(const Aws::String& value) { m_connectionExpiryHasBeenSet = true; m_connectionExpiry = value; }
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetConnectionExpiry(Aws::String&& value) { m_connectionExpiryHasBeenSet = true; m_connectionExpiry = std::move(value); }
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline void SetConnectionExpiry(const char* value) { m_connectionExpiryHasBeenSet = true; m_connectionExpiry.assign(value); }
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline Websocket& WithConnectionExpiry(const Aws::String& value) { SetConnectionExpiry(value); return *this;}
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline Websocket& WithConnectionExpiry(Aws::String&& value) { SetConnectionExpiry(std::move(value)); return *this;}
+
+    /**
+     * <p>The URL expiration timestamp in ISO date format.</p> <p>It's specified in ISO
+     * 8601 format: yyyy-MM-ddThh:mm:ss.SSSZ. For example,
+     * 2019-11-08T02:41:28.172Z.</p>
+     */
+    inline Websocket& WithConnectionExpiry(const char* value) { SetConnectionExpiry(value); return *this;}
+
+  private:
+
+    Aws::String m_url;
+    bool m_urlHasBeenSet;
+
+    Aws::String m_connectionExpiry;
+    bool m_connectionExpiryHasBeenSet;
+  };
+
+} // namespace Model
+} // namespace ConnectParticipant
+} // namespace Aws