1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test

Browse Source
This commit is contained in:
sdk-team
2023-04-04 07:39:28 +00:00
parent ff586b38ea
commit 8cfb9f0b4d
61 changed files with 4612 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
avatar/include/alibabacloud/avatar/AvatarClient.h Normal file
View File

@@ -0,0 +1,158 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_AVATARCLIENT_H_
#define ALIBABACLOUD_AVATAR_AVATARCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "AvatarExport.h"
#include "model/CancelVideoTaskRequest.h"
#include "model/CancelVideoTaskResult.h"
#include "model/CloseTimedResetOperateRequest.h"
#include "model/CloseTimedResetOperateResult.h"
#include "model/DuplexDecisionRequest.h"
#include "model/DuplexDecisionResult.h"
#include "model/GetVideoTaskInfoRequest.h"
#include "model/GetVideoTaskInfoResult.h"
#include "model/LicenseAuthRequest.h"
#include "model/LicenseAuthResult.h"
#include "model/QueryRunningInstanceRequest.h"
#include "model/QueryRunningInstanceResult.h"
#include "model/QueryTimedResetOperateStatusRequest.h"
#include "model/QueryTimedResetOperateStatusResult.h"
#include "model/SendMessageRequest.h"
#include "model/SendMessageResult.h"
#include "model/StartInstanceRequest.h"
#include "model/StartInstanceResult.h"
#include "model/StartTimedResetOperateRequest.h"
#include "model/StartTimedResetOperateResult.h"
#include "model/StopInstanceRequest.h"
#include "model/StopInstanceResult.h"
#include "model/SubmitTextTo2DAvatarVideoTaskRequest.h"
#include "model/SubmitTextTo2DAvatarVideoTaskResult.h"
#include "model/SubmitTextTo3DAvatarVideoTaskRequest.h"
#include "model/SubmitTextTo3DAvatarVideoTaskResult.h"
#include "model/SubmitTextToSignVideoTaskRequest.h"
#include "model/SubmitTextToSignVideoTaskResult.h"
namespace AlibabaCloud
{
namespace Avatar
{
class ALIBABACLOUD_AVATAR_EXPORT AvatarClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CancelVideoTaskResult> CancelVideoTaskOutcome;
typedef std::future<CancelVideoTaskOutcome> CancelVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::CancelVideoTaskRequest&, const CancelVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelVideoTaskAsyncHandler;
typedef Outcome<Error, Model::CloseTimedResetOperateResult> CloseTimedResetOperateOutcome;
typedef std::future<CloseTimedResetOperateOutcome> CloseTimedResetOperateOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::CloseTimedResetOperateRequest&, const CloseTimedResetOperateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloseTimedResetOperateAsyncHandler;
typedef Outcome<Error, Model::DuplexDecisionResult> DuplexDecisionOutcome;
typedef std::future<DuplexDecisionOutcome> DuplexDecisionOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::DuplexDecisionRequest&, const DuplexDecisionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DuplexDecisionAsyncHandler;
typedef Outcome<Error, Model::GetVideoTaskInfoResult> GetVideoTaskInfoOutcome;
typedef std::future<GetVideoTaskInfoOutcome> GetVideoTaskInfoOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::GetVideoTaskInfoRequest&, const GetVideoTaskInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoTaskInfoAsyncHandler;
typedef Outcome<Error, Model::LicenseAuthResult> LicenseAuthOutcome;
typedef std::future<LicenseAuthOutcome> LicenseAuthOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::LicenseAuthRequest&, const LicenseAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LicenseAuthAsyncHandler;
typedef Outcome<Error, Model::QueryRunningInstanceResult> QueryRunningInstanceOutcome;
typedef std::future<QueryRunningInstanceOutcome> QueryRunningInstanceOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::QueryRunningInstanceRequest&, const QueryRunningInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryRunningInstanceAsyncHandler;
typedef Outcome<Error, Model::QueryTimedResetOperateStatusResult> QueryTimedResetOperateStatusOutcome;
typedef std::future<QueryTimedResetOperateStatusOutcome> QueryTimedResetOperateStatusOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::QueryTimedResetOperateStatusRequest&, const QueryTimedResetOperateStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTimedResetOperateStatusAsyncHandler;
typedef Outcome<Error, Model::SendMessageResult> SendMessageOutcome;
typedef std::future<SendMessageOutcome> SendMessageOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SendMessageRequest&, const SendMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendMessageAsyncHandler;
typedef Outcome<Error, Model::StartInstanceResult> StartInstanceOutcome;
typedef std::future<StartInstanceOutcome> StartInstanceOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::StartInstanceRequest&, const StartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstanceAsyncHandler;
typedef Outcome<Error, Model::StartTimedResetOperateResult> StartTimedResetOperateOutcome;
typedef std::future<StartTimedResetOperateOutcome> StartTimedResetOperateOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::StartTimedResetOperateRequest&, const StartTimedResetOperateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartTimedResetOperateAsyncHandler;
typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
typedef Outcome<Error, Model::SubmitTextTo2DAvatarVideoTaskResult> SubmitTextTo2DAvatarVideoTaskOutcome;
typedef std::future<SubmitTextTo2DAvatarVideoTaskOutcome> SubmitTextTo2DAvatarVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SubmitTextTo2DAvatarVideoTaskRequest&, const SubmitTextTo2DAvatarVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitTextTo2DAvatarVideoTaskAsyncHandler;
typedef Outcome<Error, Model::SubmitTextTo3DAvatarVideoTaskResult> SubmitTextTo3DAvatarVideoTaskOutcome;
typedef std::future<SubmitTextTo3DAvatarVideoTaskOutcome> SubmitTextTo3DAvatarVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SubmitTextTo3DAvatarVideoTaskRequest&, const SubmitTextTo3DAvatarVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitTextTo3DAvatarVideoTaskAsyncHandler;
typedef Outcome<Error, Model::SubmitTextToSignVideoTaskResult> SubmitTextToSignVideoTaskOutcome;
typedef std::future<SubmitTextToSignVideoTaskOutcome> SubmitTextToSignVideoTaskOutcomeCallable;
typedef std::function<void(const AvatarClient*, const Model::SubmitTextToSignVideoTaskRequest&, const SubmitTextToSignVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitTextToSignVideoTaskAsyncHandler;
AvatarClient(const Credentials &credentials, const ClientConfiguration &configuration);
AvatarClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
AvatarClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~AvatarClient();
CancelVideoTaskOutcome cancelVideoTask(const Model::CancelVideoTaskRequest &request)const;
void cancelVideoTaskAsync(const Model::CancelVideoTaskRequest& request, const CancelVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelVideoTaskOutcomeCallable cancelVideoTaskCallable(const Model::CancelVideoTaskRequest& request) const;
CloseTimedResetOperateOutcome closeTimedResetOperate(const Model::CloseTimedResetOperateRequest &request)const;
void closeTimedResetOperateAsync(const Model::CloseTimedResetOperateRequest& request, const CloseTimedResetOperateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CloseTimedResetOperateOutcomeCallable closeTimedResetOperateCallable(const Model::CloseTimedResetOperateRequest& request) const;
DuplexDecisionOutcome duplexDecision(const Model::DuplexDecisionRequest &request)const;
void duplexDecisionAsync(const Model::DuplexDecisionRequest& request, const DuplexDecisionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DuplexDecisionOutcomeCallable duplexDecisionCallable(const Model::DuplexDecisionRequest& request) const;
GetVideoTaskInfoOutcome getVideoTaskInfo(const Model::GetVideoTaskInfoRequest &request)const;
void getVideoTaskInfoAsync(const Model::GetVideoTaskInfoRequest& request, const GetVideoTaskInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVideoTaskInfoOutcomeCallable getVideoTaskInfoCallable(const Model::GetVideoTaskInfoRequest& request) const;
LicenseAuthOutcome licenseAuth(const Model::LicenseAuthRequest &request)const;
void licenseAuthAsync(const Model::LicenseAuthRequest& request, const LicenseAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
LicenseAuthOutcomeCallable licenseAuthCallable(const Model::LicenseAuthRequest& request) const;
QueryRunningInstanceOutcome queryRunningInstance(const Model::QueryRunningInstanceRequest &request)const;
void queryRunningInstanceAsync(const Model::QueryRunningInstanceRequest& request, const QueryRunningInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryRunningInstanceOutcomeCallable queryRunningInstanceCallable(const Model::QueryRunningInstanceRequest& request) const;
QueryTimedResetOperateStatusOutcome queryTimedResetOperateStatus(const Model::QueryTimedResetOperateStatusRequest &request)const;
void queryTimedResetOperateStatusAsync(const Model::QueryTimedResetOperateStatusRequest& request, const QueryTimedResetOperateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryTimedResetOperateStatusOutcomeCallable queryTimedResetOperateStatusCallable(const Model::QueryTimedResetOperateStatusRequest& request) const;
SendMessageOutcome sendMessage(const Model::SendMessageRequest &request)const;
void sendMessageAsync(const Model::SendMessageRequest& request, const SendMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SendMessageOutcomeCallable sendMessageCallable(const Model::SendMessageRequest& request) const;
StartInstanceOutcome startInstance(const Model::StartInstanceRequest &request)const;
void startInstanceAsync(const Model::StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartInstanceOutcomeCallable startInstanceCallable(const Model::StartInstanceRequest& request) const;
StartTimedResetOperateOutcome startTimedResetOperate(const Model::StartTimedResetOperateRequest &request)const;
void startTimedResetOperateAsync(const Model::StartTimedResetOperateRequest& request, const StartTimedResetOperateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartTimedResetOperateOutcomeCallable startTimedResetOperateCallable(const Model::StartTimedResetOperateRequest& request) const;
StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;
SubmitTextTo2DAvatarVideoTaskOutcome submitTextTo2DAvatarVideoTask(const Model::SubmitTextTo2DAvatarVideoTaskRequest &request)const;
void submitTextTo2DAvatarVideoTaskAsync(const Model::SubmitTextTo2DAvatarVideoTaskRequest& request, const SubmitTextTo2DAvatarVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SubmitTextTo2DAvatarVideoTaskOutcomeCallable submitTextTo2DAvatarVideoTaskCallable(const Model::SubmitTextTo2DAvatarVideoTaskRequest& request) const;
SubmitTextTo3DAvatarVideoTaskOutcome submitTextTo3DAvatarVideoTask(const Model::SubmitTextTo3DAvatarVideoTaskRequest &request)const;
void submitTextTo3DAvatarVideoTaskAsync(const Model::SubmitTextTo3DAvatarVideoTaskRequest& request, const SubmitTextTo3DAvatarVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SubmitTextTo3DAvatarVideoTaskOutcomeCallable submitTextTo3DAvatarVideoTaskCallable(const Model::SubmitTextTo3DAvatarVideoTaskRequest& request) const;
SubmitTextToSignVideoTaskOutcome submitTextToSignVideoTask(const Model::SubmitTextToSignVideoTaskRequest &request)const;
void submitTextToSignVideoTaskAsync(const Model::SubmitTextToSignVideoTaskRequest& request, const SubmitTextToSignVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SubmitTextToSignVideoTaskOutcomeCallable submitTextToSignVideoTaskCallable(const Model::SubmitTextToSignVideoTaskRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_AVATAR_AVATARCLIENT_H_

32
avatar/include/alibabacloud/avatar/AvatarExport.h Normal file
View File

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

51
avatar/include/alibabacloud/avatar/model/CancelVideoTaskRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT CancelVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
CancelVideoTaskRequest();
~CancelVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getTaskUuid() const;
void setTaskUuid(const std::string &taskUuid);
private:
App app_;
long tenantId_;
std::string taskUuid_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_CANCELVIDEOTASKREQUEST_H_

63
avatar/include/alibabacloud/avatar/model/CancelVideoTaskResult.h Normal file
View File

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

45
avatar/include/alibabacloud/avatar/model/CloseTimedResetOperateRequest.h Normal file
View File

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

62
avatar/include/alibabacloud/avatar/model/CloseTimedResetOperateResult.h Normal file
View File

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

78
avatar/include/alibabacloud/avatar/model/DuplexDecisionRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT DuplexDecisionRequest : public RpcServiceRequest {
public:
struct DialogContext {
struct HistoriesItem {
std::string robot;
std::string user;
};
HistoriesItem historiesItem;
std::vector<HistoriesItem> histories;
int curUtteranceIdx;
};
DuplexDecisionRequest();
~DuplexDecisionRequest();
int getInterruptType() const;
void setInterruptType(int interruptType);
std::vector<std::string> getCustomKeywords() const;
void setCustomKeywords(const std::vector<std::string> &customKeywords);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
std::string getDialogStatus() const;
void setDialogStatus(const std::string &dialogStatus);
DialogContext getDialogContext() const;
void setDialogContext(const DialogContext &dialogContext);
int getCallTime() const;
void setCallTime(int callTime);
std::string getAppId() const;
void setAppId(const std::string &appId);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getBizRequestId() const;
void setBizRequestId(const std::string &bizRequestId);
private:
int interruptType_;
std::vector<std::string> customKeywords_;
std::string sessionId_;
std::string dialogStatus_;
DialogContext dialogContext_;
int callTime_;
std::string appId_;
long tenantId_;
std::string text_;
std::string bizRequestId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_DUPLEXDECISIONREQUEST_H_

63
avatar/include/alibabacloud/avatar/model/DuplexDecisionResult.h Normal file
View File

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

51
avatar/include/alibabacloud/avatar/model/GetVideoTaskInfoRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFOREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFOREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT GetVideoTaskInfoRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
GetVideoTaskInfoRequest();
~GetVideoTaskInfoRequest();
App getApp() const;
void setApp(const App &app);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getTaskUuid() const;
void setTaskUuid(const std::string &taskUuid);
private:
App app_;
long tenantId_;
std::string taskUuid_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_GETVIDEOTASKINFOREQUEST_H_

73
avatar/include/alibabacloud/avatar/model/GetVideoTaskInfoResult.h Normal file
View File

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

48
avatar/include/alibabacloud/avatar/model/LicenseAuthRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_LICENSEAUTHREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_LICENSEAUTHREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT LicenseAuthRequest : public RpcServiceRequest {
public:
LicenseAuthRequest();
~LicenseAuthRequest();
std::string getLicense() const;
void setLicense(const std::string &license);
std::string getAppId() const;
void setAppId(const std::string &appId);
long getTenantId() const;
void setTenantId(long tenantId);
private:
std::string license_;
std::string appId_;
long tenantId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_LICENSEAUTHREQUEST_H_

61
avatar/include/alibabacloud/avatar/model/LicenseAuthResult.h Normal file
View File

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

51
avatar/include/alibabacloud/avatar/model/QueryRunningInstanceRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT QueryRunningInstanceRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
QueryRunningInstanceRequest();
~QueryRunningInstanceRequest();
App getApp() const;
void setApp(const App &app);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
private:
App app_;
long tenantId_;
std::string sessionId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_QUERYRUNNINGINSTANCEREQUEST_H_

80
avatar/include/alibabacloud/avatar/model/QueryRunningInstanceResult.h Normal file
View File

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

45
avatar/include/alibabacloud/avatar/model/QueryTimedResetOperateStatusRequest.h Normal file
View File

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

64
avatar/include/alibabacloud/avatar/model/QueryTimedResetOperateStatusResult.h Normal file
View File

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

55
avatar/include/alibabacloud/avatar/model/SendMessageRequest.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SENDMESSAGEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SENDMESSAGEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SendMessageRequest : public RpcServiceRequest {
public:
struct VAMLRequest {
std::string code;
std::string vaml;
};
SendMessageRequest();
~SendMessageRequest();
std::string getTextRequest() const;
void setTextRequest(const std::string &textRequest);
long getTenantId() const;
void setTenantId(long tenantId);
VAMLRequest getVAMLRequest() const;
void setVAMLRequest(const VAMLRequest &vAMLRequest);
std::string getSessionId() const;
void setSessionId(const std::string &sessionId);
private:
std::string textRequest_;
long tenantId_;
VAMLRequest vAMLRequest_;
std::string sessionId_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SENDMESSAGEREQUEST_H_

62
avatar/include/alibabacloud/avatar/model/SendMessageResult.h Normal file
View File

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

61
avatar/include/alibabacloud/avatar/model/StartInstanceRequest.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCEREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCEREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT StartInstanceRequest : public RpcServiceRequest {
public:
struct Channel {
std::string type;
std::map<std::string, std::string> reqConfig;
};
struct CommandRequest {
bool alphaSwitch;
};
StartInstanceRequest();
~StartInstanceRequest();
std::string getApp() const;
void setApp(const std::string &app);
long getTenantId() const;
void setTenantId(long tenantId);
Channel getChannel() const;
void setChannel(const Channel &channel);
CommandRequest getCommandRequest() const;
void setCommandRequest(const CommandRequest &commandRequest);
std::string getUser() const;
void setUser(const std::string &user);
private:
std::string app_;
long tenantId_;
Channel channel_;
CommandRequest commandRequest_;
std::string user_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_STARTINSTANCEREQUEST_H_

76
avatar/include/alibabacloud/avatar/model/StartInstanceResult.h Normal file
View File

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

45
avatar/include/alibabacloud/avatar/model/StartTimedResetOperateRequest.h Normal file
View File

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

62
avatar/include/alibabacloud/avatar/model/StartTimedResetOperateResult.h Normal file
View File

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

45
avatar/include/alibabacloud/avatar/model/StopInstanceRequest.h Normal file
View File

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

62
avatar/include/alibabacloud/avatar/model/StopInstanceResult.h Normal file
View File

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

77
avatar/include/alibabacloud/avatar/model/SubmitTextTo2DAvatarVideoTaskRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO2DAVATARVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO2DAVATARVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SubmitTextTo2DAvatarVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
struct VideoInfo {
bool isAlpha;
std::string backgroundImageUrl;
bool isSubtitles;
};
struct AudioInfo {
std::string voice;
int volume;
int speechRate;
int pitchRate;
};
struct AvatarInfo {
std::string code;
};
SubmitTextTo2DAvatarVideoTaskRequest();
~SubmitTextTo2DAvatarVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
VideoInfo getVideoInfo() const;
void setVideoInfo(const VideoInfo &videoInfo);
AudioInfo getAudioInfo() const;
void setAudioInfo(const AudioInfo &audioInfo);
AvatarInfo getAvatarInfo() const;
void setAvatarInfo(const AvatarInfo &avatarInfo);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getTitle() const;
void setTitle(const std::string &title);
private:
App app_;
VideoInfo videoInfo_;
AudioInfo audioInfo_;
AvatarInfo avatarInfo_;
long tenantId_;
std::string text_;
std::string title_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO2DAVATARVIDEOTASKREQUEST_H_

61
avatar/include/alibabacloud/avatar/model/SubmitTextTo2DAvatarVideoTaskResult.h Normal file
View File

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

72
avatar/include/alibabacloud/avatar/model/SubmitTextTo3DAvatarVideoTaskRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO3DAVATARVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO3DAVATARVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SubmitTextTo3DAvatarVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
struct VideoInfo {
bool isAlpha;
std::string backgroundImageUrl;
bool isSubtitles;
int resolution;
int alphaFormat;
};
struct AvatarInfo {
std::string code;
int locate;
int angle;
};
SubmitTextTo3DAvatarVideoTaskRequest();
~SubmitTextTo3DAvatarVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
VideoInfo getVideoInfo() const;
void setVideoInfo(const VideoInfo &videoInfo);
AvatarInfo getAvatarInfo() const;
void setAvatarInfo(const AvatarInfo &avatarInfo);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getTitle() const;
void setTitle(const std::string &title);
private:
App app_;
VideoInfo videoInfo_;
AvatarInfo avatarInfo_;
long tenantId_;
std::string text_;
std::string title_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTO3DAVATARVIDEOTASKREQUEST_H_

61
avatar/include/alibabacloud/avatar/model/SubmitTextTo3DAvatarVideoTaskResult.h Normal file
View File

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

62
avatar/include/alibabacloud/avatar/model/SubmitTextToSignVideoTaskRequest.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTOSIGNVIDEOTASKREQUEST_H_
#define ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTOSIGNVIDEOTASKREQUEST_H_
#include <alibabacloud/avatar/AvatarExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Avatar {
namespace Model {
class ALIBABACLOUD_AVATAR_EXPORT SubmitTextToSignVideoTaskRequest : public RpcServiceRequest {
public:
struct App {
std::string appId;
};
struct VideoInfo {
bool isAlpha;
bool isSubtitles;
int resolution;
};
SubmitTextToSignVideoTaskRequest();
~SubmitTextToSignVideoTaskRequest();
App getApp() const;
void setApp(const App &app);
VideoInfo getVideoInfo() const;
void setVideoInfo(const VideoInfo &videoInfo);
long getTenantId() const;
void setTenantId(long tenantId);
std::string getText() const;
void setText(const std::string &text);
std::string getTitle() const;
void setTitle(const std::string &title);
private:
App app_;
VideoInfo videoInfo_;
long tenantId_;
std::string text_;
std::string title_;
};
} // namespace Model
} // namespace Avatar
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AVATAR_MODEL_SUBMITTEXTTOSIGNVIDEOTASKREQUEST_H_

61
avatar/include/alibabacloud/avatar/model/SubmitTextToSignVideoTaskResult.h Normal file
View File

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