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

SCDN SDK Auto Released By xiaoyao,Version：1.17.2

Browse Source 
Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>
This commit is contained in:
haowei.yao
2018-06-08 10:47:08 +08:00
parent 8bc596cc81
commit 87f2db5065
123 changed files with 12767 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
scdn/include/alibabacloud/scdn/ScdnClient.h Normal file
View File

@@ -0,0 +1,278 @@
/*
* 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_SCDN_SCDNCLIENT_H_
#define ALIBABACLOUD_SCDN_SCDNCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ScdnExport.h"
#include "model/DescribeScdnRefreshQuotaRequest.h"
#include "model/DescribeScdnRefreshQuotaResult.h"
#include "model/DescribeScdnDomainTrafficDataRequest.h"
#include "model/DescribeScdnDomainTrafficDataResult.h"
#include "model/DescribeScdnDomainDetailRequest.h"
#include "model/DescribeScdnDomainDetailResult.h"
#include "model/DescribeScdnDomainOriginBpsDataRequest.h"
#include "model/DescribeScdnDomainOriginBpsDataResult.h"
#include "model/DescribeScdnCertificateListRequest.h"
#include "model/DescribeScdnCertificateListResult.h"
#include "model/DescribeScdnDomainQpsDataRequest.h"
#include "model/DescribeScdnDomainQpsDataResult.h"
#include "model/DescribeScdnDomainConfigsRequest.h"
#include "model/DescribeScdnDomainConfigsResult.h"
#include "model/SetScdnDomainCertificateRequest.h"
#include "model/SetScdnDomainCertificateResult.h"
#include "model/BatchDeleteScdnDomainConfigsRequest.h"
#include "model/BatchDeleteScdnDomainConfigsResult.h"
#include "model/DescribeScdnDomainBpsDataRequest.h"
#include "model/DescribeScdnDomainBpsDataResult.h"
#include "model/PreloadScdnObjectCachesRequest.h"
#include "model/PreloadScdnObjectCachesResult.h"
#include "model/DescribeScdnDomainHitRateDataRequest.h"
#include "model/DescribeScdnDomainHitRateDataResult.h"
#include "model/DescribeScdnUserDomainsRequest.h"
#include "model/DescribeScdnUserDomainsResult.h"
#include "model/StopScdnDomainRequest.h"
#include "model/StopScdnDomainResult.h"
#include "model/AddScdnDomainRequest.h"
#include "model/AddScdnDomainResult.h"
#include "model/DescribeScdnDomainCnameRequest.h"
#include "model/DescribeScdnDomainCnameResult.h"
#include "model/DescribeScdnCertificateDetailRequest.h"
#include "model/DescribeScdnCertificateDetailResult.h"
#include "model/StartScdnDomainRequest.h"
#include "model/StartScdnDomainResult.h"
#include "model/DeleteScdnDomainRequest.h"
#include "model/DeleteScdnDomainResult.h"
#include "model/DescribeScdnServiceRequest.h"
#include "model/DescribeScdnServiceResult.h"
#include "model/DescribeScdnDomainLogRequest.h"
#include "model/DescribeScdnDomainLogResult.h"
#include "model/DescribeScdnUserQuotaRequest.h"
#include "model/DescribeScdnUserQuotaResult.h"
#include "model/DescribeScdnDomainHttpCodeDataRequest.h"
#include "model/DescribeScdnDomainHttpCodeDataResult.h"
#include "model/RefreshScdnObjectCachesRequest.h"
#include "model/RefreshScdnObjectCachesResult.h"
#include "model/DescribeScdnDomainCertificateInfoRequest.h"
#include "model/DescribeScdnDomainCertificateInfoResult.h"
#include "model/CheckScdnServiceRequest.h"
#include "model/CheckScdnServiceResult.h"
#include "model/UpdateScdnDomainRequest.h"
#include "model/UpdateScdnDomainResult.h"
#include "model/DescribeScdnDomainOriginTrafficDataRequest.h"
#include "model/DescribeScdnDomainOriginTrafficDataResult.h"
#include "model/DescribeScdnRefreshTasksRequest.h"
#include "model/DescribeScdnRefreshTasksResult.h"
namespace AlibabaCloud
{
namespace Scdn
{
class ALIBABACLOUD_SCDN_EXPORT ScdnClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::DescribeScdnRefreshQuotaResult> DescribeScdnRefreshQuotaOutcome;
typedef std::future<DescribeScdnRefreshQuotaOutcome> DescribeScdnRefreshQuotaOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnRefreshQuotaRequest&, const DescribeScdnRefreshQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnRefreshQuotaAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainTrafficDataResult> DescribeScdnDomainTrafficDataOutcome;
typedef std::future<DescribeScdnDomainTrafficDataOutcome> DescribeScdnDomainTrafficDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainTrafficDataRequest&, const DescribeScdnDomainTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainTrafficDataAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainDetailResult> DescribeScdnDomainDetailOutcome;
typedef std::future<DescribeScdnDomainDetailOutcome> DescribeScdnDomainDetailOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainDetailRequest&, const DescribeScdnDomainDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainDetailAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainOriginBpsDataResult> DescribeScdnDomainOriginBpsDataOutcome;
typedef std::future<DescribeScdnDomainOriginBpsDataOutcome> DescribeScdnDomainOriginBpsDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainOriginBpsDataRequest&, const DescribeScdnDomainOriginBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainOriginBpsDataAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnCertificateListResult> DescribeScdnCertificateListOutcome;
typedef std::future<DescribeScdnCertificateListOutcome> DescribeScdnCertificateListOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnCertificateListRequest&, const DescribeScdnCertificateListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnCertificateListAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainQpsDataResult> DescribeScdnDomainQpsDataOutcome;
typedef std::future<DescribeScdnDomainQpsDataOutcome> DescribeScdnDomainQpsDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainQpsDataRequest&, const DescribeScdnDomainQpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainQpsDataAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainConfigsResult> DescribeScdnDomainConfigsOutcome;
typedef std::future<DescribeScdnDomainConfigsOutcome> DescribeScdnDomainConfigsOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainConfigsRequest&, const DescribeScdnDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainConfigsAsyncHandler;
typedef Outcome<Error, Model::SetScdnDomainCertificateResult> SetScdnDomainCertificateOutcome;
typedef std::future<SetScdnDomainCertificateOutcome> SetScdnDomainCertificateOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::SetScdnDomainCertificateRequest&, const SetScdnDomainCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetScdnDomainCertificateAsyncHandler;
typedef Outcome<Error, Model::BatchDeleteScdnDomainConfigsResult> BatchDeleteScdnDomainConfigsOutcome;
typedef std::future<BatchDeleteScdnDomainConfigsOutcome> BatchDeleteScdnDomainConfigsOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::BatchDeleteScdnDomainConfigsRequest&, const BatchDeleteScdnDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteScdnDomainConfigsAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainBpsDataResult> DescribeScdnDomainBpsDataOutcome;
typedef std::future<DescribeScdnDomainBpsDataOutcome> DescribeScdnDomainBpsDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainBpsDataRequest&, const DescribeScdnDomainBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainBpsDataAsyncHandler;
typedef Outcome<Error, Model::PreloadScdnObjectCachesResult> PreloadScdnObjectCachesOutcome;
typedef std::future<PreloadScdnObjectCachesOutcome> PreloadScdnObjectCachesOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::PreloadScdnObjectCachesRequest&, const PreloadScdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreloadScdnObjectCachesAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainHitRateDataResult> DescribeScdnDomainHitRateDataOutcome;
typedef std::future<DescribeScdnDomainHitRateDataOutcome> DescribeScdnDomainHitRateDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainHitRateDataRequest&, const DescribeScdnDomainHitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainHitRateDataAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnUserDomainsResult> DescribeScdnUserDomainsOutcome;
typedef std::future<DescribeScdnUserDomainsOutcome> DescribeScdnUserDomainsOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnUserDomainsRequest&, const DescribeScdnUserDomainsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnUserDomainsAsyncHandler;
typedef Outcome<Error, Model::StopScdnDomainResult> StopScdnDomainOutcome;
typedef std::future<StopScdnDomainOutcome> StopScdnDomainOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::StopScdnDomainRequest&, const StopScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopScdnDomainAsyncHandler;
typedef Outcome<Error, Model::AddScdnDomainResult> AddScdnDomainOutcome;
typedef std::future<AddScdnDomainOutcome> AddScdnDomainOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::AddScdnDomainRequest&, const AddScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddScdnDomainAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainCnameResult> DescribeScdnDomainCnameOutcome;
typedef std::future<DescribeScdnDomainCnameOutcome> DescribeScdnDomainCnameOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainCnameRequest&, const DescribeScdnDomainCnameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainCnameAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnCertificateDetailResult> DescribeScdnCertificateDetailOutcome;
typedef std::future<DescribeScdnCertificateDetailOutcome> DescribeScdnCertificateDetailOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnCertificateDetailRequest&, const DescribeScdnCertificateDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnCertificateDetailAsyncHandler;
typedef Outcome<Error, Model::StartScdnDomainResult> StartScdnDomainOutcome;
typedef std::future<StartScdnDomainOutcome> StartScdnDomainOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::StartScdnDomainRequest&, const StartScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartScdnDomainAsyncHandler;
typedef Outcome<Error, Model::DeleteScdnDomainResult> DeleteScdnDomainOutcome;
typedef std::future<DeleteScdnDomainOutcome> DeleteScdnDomainOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DeleteScdnDomainRequest&, const DeleteScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScdnDomainAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnServiceResult> DescribeScdnServiceOutcome;
typedef std::future<DescribeScdnServiceOutcome> DescribeScdnServiceOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnServiceRequest&, const DescribeScdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnServiceAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainLogResult> DescribeScdnDomainLogOutcome;
typedef std::future<DescribeScdnDomainLogOutcome> DescribeScdnDomainLogOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainLogRequest&, const DescribeScdnDomainLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainLogAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnUserQuotaResult> DescribeScdnUserQuotaOutcome;
typedef std::future<DescribeScdnUserQuotaOutcome> DescribeScdnUserQuotaOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnUserQuotaRequest&, const DescribeScdnUserQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnUserQuotaAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainHttpCodeDataResult> DescribeScdnDomainHttpCodeDataOutcome;
typedef std::future<DescribeScdnDomainHttpCodeDataOutcome> DescribeScdnDomainHttpCodeDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainHttpCodeDataRequest&, const DescribeScdnDomainHttpCodeDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainHttpCodeDataAsyncHandler;
typedef Outcome<Error, Model::RefreshScdnObjectCachesResult> RefreshScdnObjectCachesOutcome;
typedef std::future<RefreshScdnObjectCachesOutcome> RefreshScdnObjectCachesOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::RefreshScdnObjectCachesRequest&, const RefreshScdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefreshScdnObjectCachesAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainCertificateInfoResult> DescribeScdnDomainCertificateInfoOutcome;
typedef std::future<DescribeScdnDomainCertificateInfoOutcome> DescribeScdnDomainCertificateInfoOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainCertificateInfoRequest&, const DescribeScdnDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainCertificateInfoAsyncHandler;
typedef Outcome<Error, Model::CheckScdnServiceResult> CheckScdnServiceOutcome;
typedef std::future<CheckScdnServiceOutcome> CheckScdnServiceOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::CheckScdnServiceRequest&, const CheckScdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckScdnServiceAsyncHandler;
typedef Outcome<Error, Model::UpdateScdnDomainResult> UpdateScdnDomainOutcome;
typedef std::future<UpdateScdnDomainOutcome> UpdateScdnDomainOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::UpdateScdnDomainRequest&, const UpdateScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateScdnDomainAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnDomainOriginTrafficDataResult> DescribeScdnDomainOriginTrafficDataOutcome;
typedef std::future<DescribeScdnDomainOriginTrafficDataOutcome> DescribeScdnDomainOriginTrafficDataOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainOriginTrafficDataRequest&, const DescribeScdnDomainOriginTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainOriginTrafficDataAsyncHandler;
typedef Outcome<Error, Model::DescribeScdnRefreshTasksResult> DescribeScdnRefreshTasksOutcome;
typedef std::future<DescribeScdnRefreshTasksOutcome> DescribeScdnRefreshTasksOutcomeCallable;
typedef std::function<void(const ScdnClient*, const Model::DescribeScdnRefreshTasksRequest&, const DescribeScdnRefreshTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnRefreshTasksAsyncHandler;
ScdnClient(const Credentials &credentials, const ClientConfiguration &configuration);
ScdnClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ScdnClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ScdnClient();
DescribeScdnRefreshQuotaOutcome describeScdnRefreshQuota(const Model::DescribeScdnRefreshQuotaRequest &request)const;
void describeScdnRefreshQuotaAsync(const Model::DescribeScdnRefreshQuotaRequest& request, const DescribeScdnRefreshQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnRefreshQuotaOutcomeCallable describeScdnRefreshQuotaCallable(const Model::DescribeScdnRefreshQuotaRequest& request) const;
DescribeScdnDomainTrafficDataOutcome describeScdnDomainTrafficData(const Model::DescribeScdnDomainTrafficDataRequest &request)const;
void describeScdnDomainTrafficDataAsync(const Model::DescribeScdnDomainTrafficDataRequest& request, const DescribeScdnDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainTrafficDataOutcomeCallable describeScdnDomainTrafficDataCallable(const Model::DescribeScdnDomainTrafficDataRequest& request) const;
DescribeScdnDomainDetailOutcome describeScdnDomainDetail(const Model::DescribeScdnDomainDetailRequest &request)const;
void describeScdnDomainDetailAsync(const Model::DescribeScdnDomainDetailRequest& request, const DescribeScdnDomainDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainDetailOutcomeCallable describeScdnDomainDetailCallable(const Model::DescribeScdnDomainDetailRequest& request) const;
DescribeScdnDomainOriginBpsDataOutcome describeScdnDomainOriginBpsData(const Model::DescribeScdnDomainOriginBpsDataRequest &request)const;
void describeScdnDomainOriginBpsDataAsync(const Model::DescribeScdnDomainOriginBpsDataRequest& request, const DescribeScdnDomainOriginBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainOriginBpsDataOutcomeCallable describeScdnDomainOriginBpsDataCallable(const Model::DescribeScdnDomainOriginBpsDataRequest& request) const;
DescribeScdnCertificateListOutcome describeScdnCertificateList(const Model::DescribeScdnCertificateListRequest &request)const;
void describeScdnCertificateListAsync(const Model::DescribeScdnCertificateListRequest& request, const DescribeScdnCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnCertificateListOutcomeCallable describeScdnCertificateListCallable(const Model::DescribeScdnCertificateListRequest& request) const;
DescribeScdnDomainQpsDataOutcome describeScdnDomainQpsData(const Model::DescribeScdnDomainQpsDataRequest &request)const;
void describeScdnDomainQpsDataAsync(const Model::DescribeScdnDomainQpsDataRequest& request, const DescribeScdnDomainQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainQpsDataOutcomeCallable describeScdnDomainQpsDataCallable(const Model::DescribeScdnDomainQpsDataRequest& request) const;
DescribeScdnDomainConfigsOutcome describeScdnDomainConfigs(const Model::DescribeScdnDomainConfigsRequest &request)const;
void describeScdnDomainConfigsAsync(const Model::DescribeScdnDomainConfigsRequest& request, const DescribeScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainConfigsOutcomeCallable describeScdnDomainConfigsCallable(const Model::DescribeScdnDomainConfigsRequest& request) const;
SetScdnDomainCertificateOutcome setScdnDomainCertificate(const Model::SetScdnDomainCertificateRequest &request)const;
void setScdnDomainCertificateAsync(const Model::SetScdnDomainCertificateRequest& request, const SetScdnDomainCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetScdnDomainCertificateOutcomeCallable setScdnDomainCertificateCallable(const Model::SetScdnDomainCertificateRequest& request) const;
BatchDeleteScdnDomainConfigsOutcome batchDeleteScdnDomainConfigs(const Model::BatchDeleteScdnDomainConfigsRequest &request)const;
void batchDeleteScdnDomainConfigsAsync(const Model::BatchDeleteScdnDomainConfigsRequest& request, const BatchDeleteScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchDeleteScdnDomainConfigsOutcomeCallable batchDeleteScdnDomainConfigsCallable(const Model::BatchDeleteScdnDomainConfigsRequest& request) const;
DescribeScdnDomainBpsDataOutcome describeScdnDomainBpsData(const Model::DescribeScdnDomainBpsDataRequest &request)const;
void describeScdnDomainBpsDataAsync(const Model::DescribeScdnDomainBpsDataRequest& request, const DescribeScdnDomainBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainBpsDataOutcomeCallable describeScdnDomainBpsDataCallable(const Model::DescribeScdnDomainBpsDataRequest& request) const;
PreloadScdnObjectCachesOutcome preloadScdnObjectCaches(const Model::PreloadScdnObjectCachesRequest &request)const;
void preloadScdnObjectCachesAsync(const Model::PreloadScdnObjectCachesRequest& request, const PreloadScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PreloadScdnObjectCachesOutcomeCallable preloadScdnObjectCachesCallable(const Model::PreloadScdnObjectCachesRequest& request) const;
DescribeScdnDomainHitRateDataOutcome describeScdnDomainHitRateData(const Model::DescribeScdnDomainHitRateDataRequest &request)const;
void describeScdnDomainHitRateDataAsync(const Model::DescribeScdnDomainHitRateDataRequest& request, const DescribeScdnDomainHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainHitRateDataOutcomeCallable describeScdnDomainHitRateDataCallable(const Model::DescribeScdnDomainHitRateDataRequest& request) const;
DescribeScdnUserDomainsOutcome describeScdnUserDomains(const Model::DescribeScdnUserDomainsRequest &request)const;
void describeScdnUserDomainsAsync(const Model::DescribeScdnUserDomainsRequest& request, const DescribeScdnUserDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnUserDomainsOutcomeCallable describeScdnUserDomainsCallable(const Model::DescribeScdnUserDomainsRequest& request) const;
StopScdnDomainOutcome stopScdnDomain(const Model::StopScdnDomainRequest &request)const;
void stopScdnDomainAsync(const Model::StopScdnDomainRequest& request, const StopScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopScdnDomainOutcomeCallable stopScdnDomainCallable(const Model::StopScdnDomainRequest& request) const;
AddScdnDomainOutcome addScdnDomain(const Model::AddScdnDomainRequest &request)const;
void addScdnDomainAsync(const Model::AddScdnDomainRequest& request, const AddScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddScdnDomainOutcomeCallable addScdnDomainCallable(const Model::AddScdnDomainRequest& request) const;
DescribeScdnDomainCnameOutcome describeScdnDomainCname(const Model::DescribeScdnDomainCnameRequest &request)const;
void describeScdnDomainCnameAsync(const Model::DescribeScdnDomainCnameRequest& request, const DescribeScdnDomainCnameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainCnameOutcomeCallable describeScdnDomainCnameCallable(const Model::DescribeScdnDomainCnameRequest& request) const;
DescribeScdnCertificateDetailOutcome describeScdnCertificateDetail(const Model::DescribeScdnCertificateDetailRequest &request)const;
void describeScdnCertificateDetailAsync(const Model::DescribeScdnCertificateDetailRequest& request, const DescribeScdnCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnCertificateDetailOutcomeCallable describeScdnCertificateDetailCallable(const Model::DescribeScdnCertificateDetailRequest& request) const;
StartScdnDomainOutcome startScdnDomain(const Model::StartScdnDomainRequest &request)const;
void startScdnDomainAsync(const Model::StartScdnDomainRequest& request, const StartScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartScdnDomainOutcomeCallable startScdnDomainCallable(const Model::StartScdnDomainRequest& request) const;
DeleteScdnDomainOutcome deleteScdnDomain(const Model::DeleteScdnDomainRequest &request)const;
void deleteScdnDomainAsync(const Model::DeleteScdnDomainRequest& request, const DeleteScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteScdnDomainOutcomeCallable deleteScdnDomainCallable(const Model::DeleteScdnDomainRequest& request) const;
DescribeScdnServiceOutcome describeScdnService(const Model::DescribeScdnServiceRequest &request)const;
void describeScdnServiceAsync(const Model::DescribeScdnServiceRequest& request, const DescribeScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnServiceOutcomeCallable describeScdnServiceCallable(const Model::DescribeScdnServiceRequest& request) const;
DescribeScdnDomainLogOutcome describeScdnDomainLog(const Model::DescribeScdnDomainLogRequest &request)const;
void describeScdnDomainLogAsync(const Model::DescribeScdnDomainLogRequest& request, const DescribeScdnDomainLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainLogOutcomeCallable describeScdnDomainLogCallable(const Model::DescribeScdnDomainLogRequest& request) const;
DescribeScdnUserQuotaOutcome describeScdnUserQuota(const Model::DescribeScdnUserQuotaRequest &request)const;
void describeScdnUserQuotaAsync(const Model::DescribeScdnUserQuotaRequest& request, const DescribeScdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnUserQuotaOutcomeCallable describeScdnUserQuotaCallable(const Model::DescribeScdnUserQuotaRequest& request) const;
DescribeScdnDomainHttpCodeDataOutcome describeScdnDomainHttpCodeData(const Model::DescribeScdnDomainHttpCodeDataRequest &request)const;
void describeScdnDomainHttpCodeDataAsync(const Model::DescribeScdnDomainHttpCodeDataRequest& request, const DescribeScdnDomainHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainHttpCodeDataOutcomeCallable describeScdnDomainHttpCodeDataCallable(const Model::DescribeScdnDomainHttpCodeDataRequest& request) const;
RefreshScdnObjectCachesOutcome refreshScdnObjectCaches(const Model::RefreshScdnObjectCachesRequest &request)const;
void refreshScdnObjectCachesAsync(const Model::RefreshScdnObjectCachesRequest& request, const RefreshScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RefreshScdnObjectCachesOutcomeCallable refreshScdnObjectCachesCallable(const Model::RefreshScdnObjectCachesRequest& request) const;
DescribeScdnDomainCertificateInfoOutcome describeScdnDomainCertificateInfo(const Model::DescribeScdnDomainCertificateInfoRequest &request)const;
void describeScdnDomainCertificateInfoAsync(const Model::DescribeScdnDomainCertificateInfoRequest& request, const DescribeScdnDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainCertificateInfoOutcomeCallable describeScdnDomainCertificateInfoCallable(const Model::DescribeScdnDomainCertificateInfoRequest& request) const;
CheckScdnServiceOutcome checkScdnService(const Model::CheckScdnServiceRequest &request)const;
void checkScdnServiceAsync(const Model::CheckScdnServiceRequest& request, const CheckScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckScdnServiceOutcomeCallable checkScdnServiceCallable(const Model::CheckScdnServiceRequest& request) const;
UpdateScdnDomainOutcome updateScdnDomain(const Model::UpdateScdnDomainRequest &request)const;
void updateScdnDomainAsync(const Model::UpdateScdnDomainRequest& request, const UpdateScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateScdnDomainOutcomeCallable updateScdnDomainCallable(const Model::UpdateScdnDomainRequest& request) const;
DescribeScdnDomainOriginTrafficDataOutcome describeScdnDomainOriginTrafficData(const Model::DescribeScdnDomainOriginTrafficDataRequest &request)const;
void describeScdnDomainOriginTrafficDataAsync(const Model::DescribeScdnDomainOriginTrafficDataRequest& request, const DescribeScdnDomainOriginTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnDomainOriginTrafficDataOutcomeCallable describeScdnDomainOriginTrafficDataCallable(const Model::DescribeScdnDomainOriginTrafficDataRequest& request) const;
DescribeScdnRefreshTasksOutcome describeScdnRefreshTasks(const Model::DescribeScdnRefreshTasksRequest &request)const;
void describeScdnRefreshTasksAsync(const Model::DescribeScdnRefreshTasksRequest& request, const DescribeScdnRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScdnRefreshTasksOutcomeCallable describeScdnRefreshTasksCallable(const Model::DescribeScdnRefreshTasksRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_SCDN_SCDNCLIENT_H_

32
scdn/include/alibabacloud/scdn/ScdnExport.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_SCDN_SCDNEXPORT_H_
#define ALIBABACLOUD_SCDN_SCDNEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_SCDN_LIBRARY)
# define ALIBABACLOUD_SCDN_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_SCDN_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_SCDN_EXPORT
#endif
#endif // !ALIBABACLOUD_SCDN_SCDNEXPORT_H_

72
scdn/include/alibabacloud/scdn/model/AddScdnDomainRequest.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_SCDN_MODEL_ADDSCDNDOMAINREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT AddScdnDomainRequest : public RpcServiceRequest
{
public:
AddScdnDomainRequest();
~AddScdnDomainRequest();
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSources()const;
void setSources(const std::string& sources);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getScope()const;
void setScope(const std::string& scope);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getCheckUrl()const;
void setCheckUrl(const std::string& checkUrl);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string resourceGroupId_;
std::string sources_;
std::string securityToken_;
std::string ownerAccount_;
std::string scope_;
std::string domainName_;
long ownerId_;
std::string checkUrl_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/AddScdnDomainResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_ADDSCDNDOMAINRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT AddScdnDomainResult : public ServiceResult
{
public:
AddScdnDomainResult();
explicit AddScdnDomainResult(const std::string &payload);
~AddScdnDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINRESULT_H_

63
scdn/include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsRequest.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_SCDN_MODEL_BATCHDELETESCDNDOMAINCONFIGSREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_BATCHDELETESCDNDOMAINCONFIGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT BatchDeleteScdnDomainConfigsRequest : public RpcServiceRequest
{
public:
BatchDeleteScdnDomainConfigsRequest();
~BatchDeleteScdnDomainConfigsRequest();
std::string getFunctionNames()const;
void setFunctionNames(const std::string& functionNames);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainNames()const;
void setDomainNames(const std::string& domainNames);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string functionNames_;
std::string securityToken_;
std::string domainNames_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_BATCHDELETESCDNDOMAINCONFIGSREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_BATCHDELETESCDNDOMAINCONFIGSRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_BATCHDELETESCDNDOMAINCONFIGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT BatchDeleteScdnDomainConfigsResult : public ServiceResult
{
public:
BatchDeleteScdnDomainConfigsResult();
explicit BatchDeleteScdnDomainConfigsResult(const std::string &payload);
~BatchDeleteScdnDomainConfigsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_BATCHDELETESCDNDOMAINCONFIGSRESULT_H_

54
scdn/include/alibabacloud/scdn/model/CheckScdnServiceRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_CHECKSCDNSERVICEREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_CHECKSCDNSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT CheckScdnServiceRequest : public RpcServiceRequest
{
public:
CheckScdnServiceRequest();
~CheckScdnServiceRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_CHECKSCDNSERVICEREQUEST_H_

57
scdn/include/alibabacloud/scdn/model/CheckScdnServiceResult.h Normal file
View File

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

63
scdn/include/alibabacloud/scdn/model/DeleteScdnDomainRequest.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_SCDN_MODEL_DELETESCDNDOMAINREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DELETESCDNDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DeleteScdnDomainRequest : public RpcServiceRequest
{
public:
DeleteScdnDomainRequest();
~DeleteScdnDomainRequest();
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string resourceGroupId_;
std::string securityToken_;
std::string ownerAccount_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DELETESCDNDOMAINREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/DeleteScdnDomainResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_DELETESCDNDOMAINRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DELETESCDNDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DeleteScdnDomainResult : public ServiceResult
{
public:
DeleteScdnDomainResult();
explicit DeleteScdnDomainResult(const std::string &payload);
~DeleteScdnDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DELETESCDNDOMAINRESULT_H_

57
scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateDetailRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATEDETAILREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATEDETAILREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnCertificateDetailRequest : public RpcServiceRequest
{
public:
DescribeScdnCertificateDetailRequest();
~DescribeScdnCertificateDetailRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getCertName()const;
void setCertName(const std::string& certName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string certName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATEDETAILREQUEST_H_

57
scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateDetailResult.h Normal file
View File

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

57
scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateListRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATELISTREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnCertificateListRequest : public RpcServiceRequest
{
public:
DescribeScdnCertificateListRequest();
~DescribeScdnCertificateListRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATELISTREQUEST_H_

65
scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateListResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNCERTIFICATELISTRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnCertificateListResult : public ServiceResult
{
public:
struct CertificateListModel
{
struct Cert
{
std::string fingerprint;
std::string issuer;
long certId;
std::string certName;
long lastTime;
std::string common;
};
std::vector<Cert> certList;
int count;
};
DescribeScdnCertificateListResult();
explicit DescribeScdnCertificateListResult(const std::string &payload);
~DescribeScdnCertificateListResult();
CertificateListModel getCertificateListModel()const;
protected:
void parse(const std::string &payload);
private:
CertificateListModel certificateListModel_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNCERTIFICATELISTRESULT_H_

126
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataRequest.h Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINBPSDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINBPSDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainBpsDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainBpsDataRequest();
~DescribeScdnDomainBpsDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getLocationNameEn()const;
void setLocationNameEn(const std::string& locationNameEn);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getIspNameEn()const;
void setIspNameEn(const std::string& ispNameEn);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string locationNameEn_;
std::string startTime_;
std::string ispNameEn_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINBPSDATAREQUEST_H_

66
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINBPSDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINBPSDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainBpsDataResult : public ServiceResult
{
public:
struct DataModule
{
std::string httpsBpsValue;
std::string bpsValue;
std::string httpBpsValue;
std::string timeStamp;
};
DescribeScdnDomainBpsDataResult();
explicit DescribeScdnDomainBpsDataResult(const std::string &payload);
~DescribeScdnDomainBpsDataResult();
std::string getEndTime()const;
std::string getDomainName()const;
std::string getStartTime()const;
std::string getDataInterval()const;
std::vector<DataModule> getBpsDataPerInterval()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string domainName_;
std::string startTime_;
std::string dataInterval_;
std::vector<DataModule> bpsDataPerInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINBPSDATARESULT_H_

108
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoRequest.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINCERTIFICATEINFOREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCERTIFICATEINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainCertificateInfoRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainCertificateInfoRequest();
~DescribeScdnDomainCertificateInfoRequest();
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getVersion()const;
void setVersion(const std::string& version);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
private:
std::string app_ip_;
std::string product_;
long callerParentId_;
std::string domainName_;
bool proxy_original_security_transport_;
std::string callerBid_;
long ownerId_;
std::string proxy_original_source_ip_;
std::string version_;
std::string ownerIdLoginEmail_;
std::string callerType_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
std::string accessKeyId_;
bool security_transport_;
std::string securityToken_;
std::string requestId_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCERTIFICATEINFOREQUEST_H_

64
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoResult.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_SCDN_MODEL_DESCRIBESCDNDOMAINCERTIFICATEINFORESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCERTIFICATEINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainCertificateInfoResult : public ServiceResult
{
public:
struct CertInfo
{
std::string status;
std::string certLife;
std::string domainName;
std::string sSLPub;
std::string certDomainName;
std::string certOrg;
std::string certType;
std::string certExpireTime;
std::string certName;
std::string sSLProtocol;
};
DescribeScdnDomainCertificateInfoResult();
explicit DescribeScdnDomainCertificateInfoResult(const std::string &payload);
~DescribeScdnDomainCertificateInfoResult();
std::vector<CertInfo> getCertInfos()const;
protected:
void parse(const std::string &payload);
private:
std::vector<CertInfo> certInfos_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCERTIFICATEINFORESULT_H_

108
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCnameRequest.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINCNAMEREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCNAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainCnameRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainCnameRequest();
~DescribeScdnDomainCnameRequest();
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getVersion()const;
void setVersion(const std::string& version);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
private:
std::string app_ip_;
std::string product_;
long callerParentId_;
std::string domainName_;
bool proxy_original_security_transport_;
std::string callerBid_;
long ownerId_;
std::string proxy_original_source_ip_;
std::string version_;
std::string ownerIdLoginEmail_;
std::string callerType_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
std::string accessKeyId_;
bool security_transport_;
std::string securityToken_;
std::string requestId_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCNAMEREQUEST_H_

57
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCnameResult.h Normal file
View File

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

60
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainConfigsRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINCONFIGSREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCONFIGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainConfigsRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainConfigsRequest();
~DescribeScdnDomainConfigsRequest();
std::string getFunctionNames()const;
void setFunctionNames(const std::string& functionNames);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string functionNames_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCONFIGSREQUEST_H_

63
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainConfigsResult.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_SCDN_MODEL_DESCRIBESCDNDOMAINCONFIGSRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCONFIGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainConfigsResult : public ServiceResult
{
public:
struct DomainConfig
{
struct FunctionArg
{
std::string argValue;
std::string argName;
};
std::string status;
std::string functionName;
std::vector<DomainConfig::FunctionArg> functionArgs;
std::string configId;
};
DescribeScdnDomainConfigsResult();
explicit DescribeScdnDomainConfigsResult(const std::string &payload);
~DescribeScdnDomainConfigsResult();
std::vector<DomainConfig> getDomainConfigs()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DomainConfig> domainConfigs_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINCONFIGSRESULT_H_

57
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainDetailRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINDETAILREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINDETAILREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainDetailRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainDetailRequest();
~DescribeScdnDomainDetailRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINDETAILREQUEST_H_

74
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainDetailResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINDETAILRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINDETAILRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainDetailResult : public ServiceResult
{
public:
struct DomainDetail
{
struct Source
{
std::string type;
std::string content;
std::string priority;
int port;
std::string enabled;
};
std::string description;
std::string scope;
std::string resourceGroupId;
std::string domainName;
std::string sSLPub;
std::string gmtModified;
std::string gmtCreated;
std::string certName;
std::vector<Source> sources;
std::string cname;
std::string domainStatus;
std::string sSLProtocol;
};
DescribeScdnDomainDetailResult();
explicit DescribeScdnDomainDetailResult(const std::string &payload);
~DescribeScdnDomainDetailResult();
DomainDetail getDomainDetail()const;
protected:
void parse(const std::string &payload);
private:
DomainDetail domainDetail_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINDETAILRESULT_H_

120
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHitRateDataRequest.h Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINHITRATEDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHITRATEDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainHitRateDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainHitRateDataRequest();
~DescribeScdnDomainHitRateDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string startTime_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHITRATEDATAREQUEST_H_

65
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHitRateDataResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINHITRATEDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHITRATEDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainHitRateDataResult : public ServiceResult
{
public:
struct DataModule
{
std::string reqHitRate;
std::string byteHitRate;
std::string timeStamp;
};
DescribeScdnDomainHitRateDataResult();
explicit DescribeScdnDomainHitRateDataResult(const std::string &payload);
~DescribeScdnDomainHitRateDataResult();
std::string getEndTime()const;
std::string getDomainName()const;
std::vector<DataModule> getHitRatePerInterval()const;
std::string getStartTime()const;
std::string getDataInterval()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string domainName_;
std::vector<DataModule> hitRatePerInterval_;
std::string startTime_;
std::string dataInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHITRATEDATARESULT_H_

126
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataRequest.h Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINHTTPCODEDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHTTPCODEDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainHttpCodeDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainHttpCodeDataRequest();
~DescribeScdnDomainHttpCodeDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getLocationNameEn()const;
void setLocationNameEn(const std::string& locationNameEn);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getIspNameEn()const;
void setIspNameEn(const std::string& ispNameEn);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string locationNameEn_;
std::string startTime_;
std::string ispNameEn_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHTTPCODEDATAREQUEST_H_

70
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHTTPCODEDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHTTPCODEDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainHttpCodeDataResult : public ServiceResult
{
public:
struct DataModule
{
struct HttpCodeDataModule
{
std::string proportion;
std::string count;
std::string code;
};
std::vector<DataModule::HttpCodeDataModule> httpCodeDataPerInterval;
std::string timeStamp;
};
DescribeScdnDomainHttpCodeDataResult();
explicit DescribeScdnDomainHttpCodeDataResult(const std::string &payload);
~DescribeScdnDomainHttpCodeDataResult();
std::string getEndTime()const;
std::string getDomainName()const;
std::string getStartTime()const;
std::string getDataInterval()const;
std::vector<DataModule> getDataPerInterval()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string domainName_;
std::string startTime_;
std::string dataInterval_;
std::vector<DataModule> dataPerInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINHTTPCODEDATARESULT_H_

120
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainLogRequest.h Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINLOGREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINLOGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainLogRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainLogRequest();
~DescribeScdnDomainLogRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
long getPageNumber()const;
void setPageNumber(long pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
long getPageSize()const;
void setPageSize(long pageSize);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string startTime_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
long pageNumber_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
long pageSize_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINLOGREQUEST_H_

73
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainLogResult.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_SCDN_MODEL_DESCRIBESCDNDOMAINLOGRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINLOGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainLogResult : public ServiceResult
{
public:
struct DomainLogDetail
{
struct PageInfoDetail
{
long pageSize;
long total;
long pageIndex;
};
struct LogInfoDetail
{
long logSize;
std::string endTime;
std::string startTime;
std::string logName;
std::string logPath;
};
std::vector<DomainLogDetail::LogInfoDetail> logInfos;
std::vector<DomainLogDetail::PageInfoDetail> pageInfos;
long logCount;
};
DescribeScdnDomainLogResult();
explicit DescribeScdnDomainLogResult(const std::string &payload);
~DescribeScdnDomainLogResult();
std::string getDomainName()const;
std::vector<DomainLogDetail> getDomainLogDetails()const;
protected:
void parse(const std::string &payload);
private:
std::string domainName_;
std::vector<DomainLogDetail> domainLogDetails_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINLOGRESULT_H_

120
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataRequest.h Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINBPSDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINBPSDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainOriginBpsDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainOriginBpsDataRequest();
~DescribeScdnDomainOriginBpsDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string startTime_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINBPSDATAREQUEST_H_

66
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINBPSDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINBPSDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainOriginBpsDataResult : public ServiceResult
{
public:
struct DataModule
{
std::string originBpsValue;
std::string httpOriginBpsValue;
std::string httpsOriginBpsValue;
std::string timeStamp;
};
DescribeScdnDomainOriginBpsDataResult();
explicit DescribeScdnDomainOriginBpsDataResult(const std::string &payload);
~DescribeScdnDomainOriginBpsDataResult();
std::string getEndTime()const;
std::string getDomainName()const;
std::string getStartTime()const;
std::string getDataInterval()const;
std::vector<DataModule> getOriginBpsDataPerInterval()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string domainName_;
std::string startTime_;
std::string dataInterval_;
std::vector<DataModule> originBpsDataPerInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINBPSDATARESULT_H_

120
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataRequest.h Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINTRAFFICDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINTRAFFICDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainOriginTrafficDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainOriginTrafficDataRequest();
~DescribeScdnDomainOriginTrafficDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string startTime_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINTRAFFICDATAREQUEST_H_

66
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINTRAFFICDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINTRAFFICDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainOriginTrafficDataResult : public ServiceResult
{
public:
struct DataModule
{
std::string httpTrafficValue;
std::string httpsTrafficValue;
std::string trafficValue;
std::string timeStamp;
};
DescribeScdnDomainOriginTrafficDataResult();
explicit DescribeScdnDomainOriginTrafficDataResult(const std::string &payload);
~DescribeScdnDomainOriginTrafficDataResult();
std::string getEndTime()const;
std::string getDomainName()const;
std::string getStartTime()const;
std::string getDataInterval()const;
std::vector<DataModule> getOriginTrafficDataPerInterval()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string domainName_;
std::string startTime_;
std::string dataInterval_;
std::vector<DataModule> originTrafficDataPerInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINORIGINTRAFFICDATARESULT_H_

126
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataRequest.h Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINQPSDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINQPSDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainQpsDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainQpsDataRequest();
~DescribeScdnDomainQpsDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getLocationNameEn()const;
void setLocationNameEn(const std::string& locationNameEn);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getIspNameEn()const;
void setIspNameEn(const std::string& ispNameEn);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string locationNameEn_;
std::string startTime_;
std::string ispNameEn_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINQPSDATAREQUEST_H_

69
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINQPSDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINQPSDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainQpsDataResult : public ServiceResult
{
public:
struct DataModule
{
std::string httpsQpsValue;
std::string httpAccValue;
std::string httpQpsValue;
std::string httpsAccValue;
std::string qpsValue;
std::string timeStamp;
std::string accValue;
};
DescribeScdnDomainQpsDataResult();
explicit DescribeScdnDomainQpsDataResult(const std::string &payload);
~DescribeScdnDomainQpsDataResult();
std::vector<DataModule> getQpsDataPerInterval()const;
std::string getEndTime()const;
std::string getDomainName()const;
std::string getStartTime()const;
std::string getDataInterval()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DataModule> qpsDataPerInterval_;
std::string endTime_;
std::string domainName_;
std::string startTime_;
std::string dataInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINQPSDATARESULT_H_

126
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataRequest.h Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNDOMAINTRAFFICDATAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTRAFFICDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainTrafficDataRequest : public RpcServiceRequest
{
public:
DescribeScdnDomainTrafficDataRequest();
~DescribeScdnDomainTrafficDataRequest();
long getCallerParentId()const;
void setCallerParentId(long callerParentId);
bool getProxy_original_security_transport()const;
void setProxy_original_security_transport(bool proxy_original_security_transport);
std::string getLocationNameEn()const;
void setLocationNameEn(const std::string& locationNameEn);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getIspNameEn()const;
void setIspNameEn(const std::string& ispNameEn);
std::string getProxy_original_source_ip()const;
void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
std::string getOwnerIdLoginEmail()const;
void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
std::string getCallerType()const;
void setCallerType(const std::string& callerType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRequestContent()const;
void setRequestContent(const std::string& requestContent);
std::string getCallerBidEmail()const;
void setCallerBidEmail(const std::string& callerBidEmail);
std::string getCallerUidEmail()const;
void setCallerUidEmail(const std::string& callerUidEmail);
long getCallerUid()const;
void setCallerUid(long callerUid);
std::string getApp_ip()const;
void setApp_ip(const std::string& app_ip);
std::string getProduct()const;
void setProduct(const std::string& product);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getCallerBid()const;
void setCallerBid(const std::string& callerBid);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
bool getProxy_trust_transport_info()const;
void setProxy_trust_transport_info(bool proxy_trust_transport_info);
bool getAk_mfa_present()const;
void setAk_mfa_present(bool ak_mfa_present);
bool getSecurity_transport()const;
void setSecurity_transport(bool security_transport);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getInterval()const;
void setInterval(const std::string& interval);
std::string getFields()const;
void setFields(const std::string& fields);
private:
long callerParentId_;
bool proxy_original_security_transport_;
std::string locationNameEn_;
std::string startTime_;
std::string ispNameEn_;
std::string proxy_original_source_ip_;
std::string ownerIdLoginEmail_;
std::string callerType_;
std::string accessKeyId_;
std::string securityToken_;
std::string requestContent_;
std::string callerBidEmail_;
std::string callerUidEmail_;
long callerUid_;
std::string app_ip_;
std::string product_;
std::string domainName_;
std::string endTime_;
std::string callerBid_;
long ownerId_;
std::string version_;
bool proxy_trust_transport_info_;
bool ak_mfa_present_;
bool security_transport_;
std::string requestId_;
std::string interval_;
std::string fields_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTRAFFICDATAREQUEST_H_

66
scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTRAFFICDATARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTRAFFICDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainTrafficDataResult : public ServiceResult
{
public:
struct DataModule
{
std::string httpTrafficValue;
std::string httpsTrafficValue;
std::string trafficValue;
std::string timeStamp;
};
DescribeScdnDomainTrafficDataResult();
explicit DescribeScdnDomainTrafficDataResult(const std::string &payload);
~DescribeScdnDomainTrafficDataResult();
std::string getEndTime()const;
std::vector<DataModule> getTrafficDataPerInterval()const;
std::string getDomainName()const;
std::string getStartTime()const;
std::string getDataInterval()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::vector<DataModule> trafficDataPerInterval_;
std::string domainName_;
std::string startTime_;
std::string dataInterval_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTRAFFICDATARESULT_H_

54
scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHQUOTAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHQUOTAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnRefreshQuotaRequest : public RpcServiceRequest
{
public:
DescribeScdnRefreshQuotaRequest();
~DescribeScdnRefreshQuotaRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHQUOTAREQUEST_H_

65
scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNREFRESHQUOTARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHQUOTARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnRefreshQuotaResult : public ServiceResult
{
public:
DescribeScdnRefreshQuotaResult();
explicit DescribeScdnRefreshQuotaResult(const std::string &payload);
~DescribeScdnRefreshQuotaResult();
std::string getUrlRemain()const;
std::string getPreloadRemain()const;
std::string getBlockRemain()const;
std::string getDirRemain()const;
std::string getBlockQuota()const;
std::string getUrlQuota()const;
std::string getDirQuota()const;
std::string getPreloadQuota()const;
protected:
void parse(const std::string &payload);
private:
std::string urlRemain_;
std::string preloadRemain_;
std::string blockRemain_;
std::string dirRemain_;
std::string blockQuota_;
std::string urlQuota_;
std::string dirQuota_;
std::string preloadQuota_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHQUOTARESULT_H_

84
scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshTasksRequest.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnRefreshTasksRequest : public RpcServiceRequest
{
public:
DescribeScdnRefreshTasksRequest();
~DescribeScdnRefreshTasksRequest();
std::string getObjectPath()const;
void setObjectPath(const std::string& objectPath);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getObjectType()const;
void setObjectType(const std::string& objectType);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string objectPath_;
std::string domainName_;
std::string endTime_;
std::string startTime_;
long ownerId_;
int pageNumber_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string securityToken_;
int pageSize_;
std::string objectType_;
std::string taskId_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSREQUEST_H_

67
scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshTasksResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnRefreshTasksResult : public ServiceResult
{
public:
struct Task
{
std::string status;
std::string objectType;
std::string objectPath;
std::string taskId;
std::string description;
std::string creationTime;
std::string process;
};
DescribeScdnRefreshTasksResult();
explicit DescribeScdnRefreshTasksResult(const std::string &payload);
~DescribeScdnRefreshTasksResult();
long getTotalCount()const;
std::vector<Task> getTasks()const;
long getPageSize()const;
long getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
long totalCount_;
std::vector<Task> tasks_;
long pageSize_;
long pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSRESULT_H_

54
scdn/include/alibabacloud/scdn/model/DescribeScdnServiceRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICEREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnServiceRequest : public RpcServiceRequest
{
public:
DescribeScdnServiceRequest();
~DescribeScdnServiceRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICEREQUEST_H_

89
scdn/include/alibabacloud/scdn/model/DescribeScdnServiceResult.h Normal file
View File

@@ -0,0 +1,89 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNSERVICERESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnServiceResult : public ServiceResult
{
public:
struct LockReason
{
std::string lockReason;
};
DescribeScdnServiceResult();
explicit DescribeScdnServiceResult(const std::string &payload);
~DescribeScdnServiceResult();
std::string getEndTime()const;
std::string getInstanceId()const;
std::string getPricingCycle()const;
std::string getElasticProtection()const;
std::string getDDoSBasic()const;
std::string getDomainCountValue()const;
std::string getProtectTypeValue()const;
std::string getCcProtectionValue()const;
std::string getCcProtection()const;
std::vector<LockReason> getOperationLocks()const;
std::string getElasticProtectionValue()const;
std::string getOpenTime()const;
std::string getBandwidth()const;
std::string getDDoSBasicValue()const;
std::string getProtectType()const;
std::string getBandwidthValue()const;
std::string getPriceType()const;
std::string getDomainCount()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string instanceId_;
std::string pricingCycle_;
std::string elasticProtection_;
std::string dDoSBasic_;
std::string domainCountValue_;
std::string protectTypeValue_;
std::string ccProtectionValue_;
std::string ccProtection_;
std::vector<LockReason> operationLocks_;
std::string elasticProtectionValue_;
std::string openTime_;
std::string bandwidth_;
std::string dDoSBasicValue_;
std::string protectType_;
std::string bandwidthValue_;
std::string priceType_;
std::string domainCount_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICERESULT_H_

81
scdn/include/alibabacloud/scdn/model/DescribeScdnUserDomainsRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnUserDomainsRequest : public RpcServiceRequest
{
public:
DescribeScdnUserDomainsRequest();
~DescribeScdnUserDomainsRequest();
std::string getFuncFilter()const;
void setFuncFilter(const std::string& funcFilter);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getFuncId()const;
void setFuncId(const std::string& funcId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getDomainStatus()const;
void setDomainStatus(const std::string& domainStatus);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDomainSearchType()const;
void setDomainSearchType(const std::string& domainSearchType);
bool getCheckDomainShow()const;
void setCheckDomainShow(bool checkDomainShow);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string funcFilter_;
std::string domainName_;
long ownerId_;
std::string funcId_;
int pageNumber_;
std::string domainStatus_;
std::string accessKeyId_;
std::string domainSearchType_;
bool checkDomainShow_;
std::string resourceGroupId_;
std::string securityToken_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSREQUEST_H_

77
scdn/include/alibabacloud/scdn/model/DescribeScdnUserDomainsResult.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_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnUserDomainsResult : public ServiceResult
{
public:
struct PageData
{
struct Source
{
std::string type;
std::string content;
std::string priority;
int port;
};
std::string description;
std::string resourceGroupId;
std::string domainName;
std::string gmtModified;
std::string gmtCreated;
std::vector<PageData::Source> sources;
std::string cname;
std::string domainStatus;
std::string sSLProtocol;
std::string sandbox;
};
DescribeScdnUserDomainsResult();
explicit DescribeScdnUserDomainsResult(const std::string &payload);
~DescribeScdnUserDomainsResult();
std::vector<PageData> getDomains()const;
long getTotalCount()const;
long getPageSize()const;
long getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PageData> domains_;
long totalCount_;
long pageSize_;
long pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSRESULT_H_

54
scdn/include/alibabacloud/scdn/model/DescribeScdnUserQuotaRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERQUOTAREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERQUOTAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnUserQuotaRequest : public RpcServiceRequest
{
public:
DescribeScdnUserQuotaRequest();
~DescribeScdnUserQuotaRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERQUOTAREQUEST_H_

67
scdn/include/alibabacloud/scdn/model/DescribeScdnUserQuotaResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERQUOTARESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERQUOTARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT DescribeScdnUserQuotaResult : public ServiceResult
{
public:
DescribeScdnUserQuotaResult();
explicit DescribeScdnUserQuotaResult(const std::string &payload);
~DescribeScdnUserQuotaResult();
int getRefreshUrlQuota()const;
int getPreloadRemain()const;
int getBlockRemain()const;
int getRefreshDirRemain()const;
int getRefreshDirQuota()const;
int getBlockQuota()const;
int getDomainQuota()const;
int getRefreshUrlRemain()const;
int getPreloadQuota()const;
protected:
void parse(const std::string &payload);
private:
int refreshUrlQuota_;
int preloadRemain_;
int blockRemain_;
int refreshDirRemain_;
int refreshDirQuota_;
int blockQuota_;
int domainQuota_;
int refreshUrlRemain_;
int preloadQuota_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERQUOTARESULT_H_

57
scdn/include/alibabacloud/scdn/model/PreloadScdnObjectCachesRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_PRELOADSCDNOBJECTCACHESREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_PRELOADSCDNOBJECTCACHESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT PreloadScdnObjectCachesRequest : public RpcServiceRequest
{
public:
PreloadScdnObjectCachesRequest();
~PreloadScdnObjectCachesRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getObjectPath()const;
void setObjectPath(const std::string& objectPath);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string objectPath_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_PRELOADSCDNOBJECTCACHESREQUEST_H_

51
scdn/include/alibabacloud/scdn/model/PreloadScdnObjectCachesResult.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_SCDN_MODEL_PRELOADSCDNOBJECTCACHESRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_PRELOADSCDNOBJECTCACHESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT PreloadScdnObjectCachesResult : public ServiceResult
{
public:
PreloadScdnObjectCachesResult();
explicit PreloadScdnObjectCachesResult(const std::string &payload);
~PreloadScdnObjectCachesResult();
std::string getPreloadTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string preloadTaskId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_PRELOADSCDNOBJECTCACHESRESULT_H_

60
scdn/include/alibabacloud/scdn/model/RefreshScdnObjectCachesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_SCDN_MODEL_REFRESHSCDNOBJECTCACHESREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_REFRESHSCDNOBJECTCACHESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT RefreshScdnObjectCachesRequest : public RpcServiceRequest
{
public:
RefreshScdnObjectCachesRequest();
~RefreshScdnObjectCachesRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getObjectPath()const;
void setObjectPath(const std::string& objectPath);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getObjectType()const;
void setObjectType(const std::string& objectType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string objectPath_;
long ownerId_;
std::string objectType_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_REFRESHSCDNOBJECTCACHESREQUEST_H_

51
scdn/include/alibabacloud/scdn/model/RefreshScdnObjectCachesResult.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_SCDN_MODEL_REFRESHSCDNOBJECTCACHESRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_REFRESHSCDNOBJECTCACHESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT RefreshScdnObjectCachesResult : public ServiceResult
{
public:
RefreshScdnObjectCachesResult();
explicit RefreshScdnObjectCachesResult(const std::string &payload);
~RefreshScdnObjectCachesResult();
std::string getRefreshTaskId()const;
protected:
void parse(const std::string &payload);
private:
std::string refreshTaskId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_REFRESHSCDNOBJECTCACHESRESULT_H_

75
scdn/include/alibabacloud/scdn/model/SetScdnDomainCertificateRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* 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_SCDN_MODEL_SETSCDNDOMAINCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT SetScdnDomainCertificateRequest : public RpcServiceRequest
{
public:
SetScdnDomainCertificateRequest();
~SetScdnDomainCertificateRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getCertType()const;
void setCertType(const std::string& certType);
std::string getSSLPub()const;
void setSSLPub(const std::string& sSLPub);
std::string getCertName()const;
void setCertName(const std::string& certName);
std::string getSSLProtocol()const;
void setSSLProtocol(const std::string& sSLProtocol);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getRegion()const;
void setRegion(const std::string& region);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSSLPri()const;
void setSSLPri(const std::string& sSLPri);
private:
std::string securityToken_;
std::string certType_;
std::string sSLPub_;
std::string certName_;
std::string sSLProtocol_;
std::string domainName_;
long ownerId_;
std::string region_;
std::string accessKeyId_;
std::string sSLPri_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATEREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/SetScdnDomainCertificateResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_SETSCDNDOMAINCERTIFICATERESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT SetScdnDomainCertificateResult : public ServiceResult
{
public:
SetScdnDomainCertificateResult();
explicit SetScdnDomainCertificateResult(const std::string &payload);
~SetScdnDomainCertificateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATERESULT_H_

57
scdn/include/alibabacloud/scdn/model/StartScdnDomainRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_STARTSCDNDOMAINREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_STARTSCDNDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT StartScdnDomainRequest : public RpcServiceRequest
{
public:
StartScdnDomainRequest();
~StartScdnDomainRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_STARTSCDNDOMAINREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/StartScdnDomainResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_STARTSCDNDOMAINRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_STARTSCDNDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT StartScdnDomainResult : public ServiceResult
{
public:
StartScdnDomainResult();
explicit StartScdnDomainResult(const std::string &payload);
~StartScdnDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_STARTSCDNDOMAINRESULT_H_

57
scdn/include/alibabacloud/scdn/model/StopScdnDomainRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SCDN_MODEL_STOPSCDNDOMAINREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_STOPSCDNDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT StopScdnDomainRequest : public RpcServiceRequest
{
public:
StopScdnDomainRequest();
~StopScdnDomainRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_STOPSCDNDOMAINREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/StopScdnDomainResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_STOPSCDNDOMAINRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_STOPSCDNDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT StopScdnDomainResult : public ServiceResult
{
public:
StopScdnDomainResult();
explicit StopScdnDomainResult(const std::string &payload);
~StopScdnDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_STOPSCDNDOMAINRESULT_H_

63
scdn/include/alibabacloud/scdn/model/UpdateScdnDomainRequest.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_SCDN_MODEL_UPDATESCDNDOMAINREQUEST_H_
#define ALIBABACLOUD_SCDN_MODEL_UPDATESCDNDOMAINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT UpdateScdnDomainRequest : public RpcServiceRequest
{
public:
UpdateScdnDomainRequest();
~UpdateScdnDomainRequest();
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSources()const;
void setSources(const std::string& sources);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string resourceGroupId_;
std::string sources_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_UPDATESCDNDOMAINREQUEST_H_

49
scdn/include/alibabacloud/scdn/model/UpdateScdnDomainResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_SCDN_MODEL_UPDATESCDNDOMAINRESULT_H_
#define ALIBABACLOUD_SCDN_MODEL_UPDATESCDNDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/scdn/ScdnExport.h>
namespace AlibabaCloud
{
namespace Scdn
{
namespace Model
{
class ALIBABACLOUD_SCDN_EXPORT UpdateScdnDomainResult : public ServiceResult
{
public:
UpdateScdnDomainResult();
explicit UpdateScdnDomainResult(const std::string &payload);
~UpdateScdnDomainResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SCDN_MODEL_UPDATESCDNDOMAINRESULT_H_