public static DescribeDomainRecordsResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDomainRecordsResponse describeDomainRecordsResponse = new DescribeDomainRecordsResponse();

            describeDomainRecordsResponse.HttpResponse = context.HttpResponse;
            describeDomainRecordsResponse.RequestId = context.StringValue("DescribeDomainRecords.RequestId");
            describeDomainRecordsResponse.TotalCount = context.LongValue("DescribeDomainRecords.TotalCount");
            describeDomainRecordsResponse.PageNumber = context.LongValue("DescribeDomainRecords.PageNumber");
            describeDomainRecordsResponse.PageSize = context.LongValue("DescribeDomainRecords.PageSize");

            List<DescribeDomainRecordsResponse.Record> domainRecords = new List<DescribeDomainRecordsResponse.Record>();
            for (int i = 0; i < context.Length("DescribeDomainRecords.DomainRecords.Length"); i++) {
                DescribeDomainRecordsResponse.Record record = new DescribeDomainRecordsResponse.Record();
                record.DomainName = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].DomainName");
                record.RecordId = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].RecordId");
                record.RR = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].RR");
                record.Type = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].Type");
                record.Value = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].Value");
                record.TTL = context.LongValue("DescribeDomainRecords.DomainRecords["+ i +"].TTL");
                record.Priority = context.LongValue("DescribeDomainRecords.DomainRecords["+ i +"].Priority");
                record.Line = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].Line");
                record.Status = context.StringValue("DescribeDomainRecords.DomainRecords["+ i +"].Status");
                record.Locked = context.BooleanValue("DescribeDomainRecords.DomainRecords["+ i +"].Locked");
                record.Weight = context.IntegerValue("DescribeDomainRecords.DomainRecords["+ i +"].Weight");

                domainRecords.Add(record);
            }
            describeDomainRecordsResponse.DomainRecords = domainRecords;

            return describeDomainRecordsResponse;
        }
        public static DescribeDomainQpsDataResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDomainQpsDataResponse describeDomainQpsDataResponse = new DescribeDomainQpsDataResponse();

            describeDomainQpsDataResponse.HttpResponse = context.HttpResponse;
            describeDomainQpsDataResponse.RequestId = context.StringValue("DescribeDomainQpsData.RequestId");
            describeDomainQpsDataResponse.DomainName = context.StringValue("DescribeDomainQpsData.DomainName");
            describeDomainQpsDataResponse.DataInterval = context.StringValue("DescribeDomainQpsData.DataInterval");
            describeDomainQpsDataResponse.StartTime = context.StringValue("DescribeDomainQpsData.StartTime");
            describeDomainQpsDataResponse.EndTime = context.StringValue("DescribeDomainQpsData.EndTime");

            List<DescribeDomainQpsDataResponse.DataModule> qpsDataInterval = new List<DescribeDomainQpsDataResponse.DataModule>();
            for (int i = 0; i < context.Length("DescribeDomainQpsData.QpsDataInterval.Length"); i++) {
                DescribeDomainQpsDataResponse.DataModule dataModule = new DescribeDomainQpsDataResponse.DataModule();
                dataModule.TimeStamp = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].TimeStamp");
                dataModule.Value = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].Value");
                dataModule.DomesticValue = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].DomesticValue");
                dataModule.OverseasValue = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].OverseasValue");
                dataModule.AccValue = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].AccValue");
                dataModule.AccDomesticValue = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].AccDomesticValue");
                dataModule.AccOverseasValue = context.StringValue("DescribeDomainQpsData.QpsDataInterval["+ i +"].AccOverseasValue");

                qpsDataInterval.Add(dataModule);
            }
            describeDomainQpsDataResponse.QpsDataInterval = qpsDataInterval;

            return describeDomainQpsDataResponse;
        }
        public static DescribeCdnRegionAndIspResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeCdnRegionAndIspResponse describeCdnRegionAndIspResponse = new DescribeCdnRegionAndIspResponse();

            describeCdnRegionAndIspResponse.HttpResponse = context.HttpResponse;
            describeCdnRegionAndIspResponse.RequestId = context.StringValue("DescribeCdnRegionAndIsp.RequestId");

            List<DescribeCdnRegionAndIspResponse.Region> regions = new List<DescribeCdnRegionAndIspResponse.Region>();
            for (int i = 0; i < context.Length("DescribeCdnRegionAndIsp.Regions.Length"); i++) {
                DescribeCdnRegionAndIspResponse.Region region = new DescribeCdnRegionAndIspResponse.Region();
                region.NameZh = context.StringValue("DescribeCdnRegionAndIsp.Regions["+ i +"].NameZh");
                region.NameEn = context.StringValue("DescribeCdnRegionAndIsp.Regions["+ i +"].NameEn");

                regions.Add(region);
            }
            describeCdnRegionAndIspResponse.Regions = regions;

            List<DescribeCdnRegionAndIspResponse.Isp> isps = new List<DescribeCdnRegionAndIspResponse.Isp>();
            for (int i = 0; i < context.Length("DescribeCdnRegionAndIsp.Isps.Length"); i++) {
                DescribeCdnRegionAndIspResponse.Isp isp = new DescribeCdnRegionAndIspResponse.Isp();
                isp.NameZh = context.StringValue("DescribeCdnRegionAndIsp.Isps["+ i +"].NameZh");
                isp.NameEn = context.StringValue("DescribeCdnRegionAndIsp.Isps["+ i +"].NameEn");

                isps.Add(isp);
            }
            describeCdnRegionAndIspResponse.Isps = isps;

            return describeCdnRegionAndIspResponse;
        }
        public static DescribeHistoryApisResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeHistoryApisResponse describeHistoryApisResponse = new DescribeHistoryApisResponse();

            describeHistoryApisResponse.HttpResponse = context.HttpResponse;
            describeHistoryApisResponse.RequestId = context.StringValue("DescribeHistoryApis.RequestId");
            describeHistoryApisResponse.TotalCount = context.IntegerValue("DescribeHistoryApis.TotalCount");
            describeHistoryApisResponse.PageSize = context.IntegerValue("DescribeHistoryApis.PageSize");
            describeHistoryApisResponse.PageNumber = context.IntegerValue("DescribeHistoryApis.PageNumber");

            List<DescribeHistoryApisResponse.ApiHisItem> apiHisItems = new List<DescribeHistoryApisResponse.ApiHisItem>();
            for (int i = 0; i < context.Length("DescribeHistoryApis.ApiHisItems.Length"); i++) {
                DescribeHistoryApisResponse.ApiHisItem apiHisItem = new DescribeHistoryApisResponse.ApiHisItem();
                apiHisItem.RegionId = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].RegionId");
                apiHisItem.ApiId = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].ApiId");
                apiHisItem.ApiName = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].ApiName");
                apiHisItem.GroupId = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].GroupId");
                apiHisItem.GroupName = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].GroupName");
                apiHisItem.StageName = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].StageName");
                apiHisItem.HistoryVersion = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].HistoryVersion");
                apiHisItem.Status = context.EnumValue<DescribeHistoryApisResponse.ApiHisItem.StatusEnum>("DescribeHistoryApis.ApiHisItems["+ i +"].Status");
                apiHisItem.Description = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].Description");
                apiHisItem.DeployedTime = context.StringValue("DescribeHistoryApis.ApiHisItems["+ i +"].DeployedTime");

                apiHisItems.Add(apiHisItem);
            }
            describeHistoryApisResponse.ApiHisItems = apiHisItems;

            return describeHistoryApisResponse;
        }
        public static QueryMediaWorkflowListResponse Unmarshall(UnmarshallerContext context)
        {
            QueryMediaWorkflowListResponse queryMediaWorkflowListResponse = new QueryMediaWorkflowListResponse();

            queryMediaWorkflowListResponse.HttpResponse = context.HttpResponse;
            queryMediaWorkflowListResponse.RequestId = context.StringValue("QueryMediaWorkflowList.RequestId");

            List<string> nonExistMediaWorkflowIds = new List<string>();
            for (int i = 0; i < context.Length("QueryMediaWorkflowList.NonExistMediaWorkflowIds.Length"); i++) {
                nonExistMediaWorkflowIds.Add(context.StringValue("QueryMediaWorkflowList.NonExistMediaWorkflowIds["+ i +"]"));
            }
            queryMediaWorkflowListResponse.NonExistMediaWorkflowIds = nonExistMediaWorkflowIds;

            List<QueryMediaWorkflowListResponse.MediaWorkflow> mediaWorkflowList = new List<QueryMediaWorkflowListResponse.MediaWorkflow>();
            for (int i = 0; i < context.Length("QueryMediaWorkflowList.MediaWorkflowList.Length"); i++) {
                QueryMediaWorkflowListResponse.MediaWorkflow mediaWorkflow = new QueryMediaWorkflowListResponse.MediaWorkflow();
                mediaWorkflow.MediaWorkflowId = context.StringValue("QueryMediaWorkflowList.MediaWorkflowList["+ i +"].MediaWorkflowId");
                mediaWorkflow.Name = context.StringValue("QueryMediaWorkflowList.MediaWorkflowList["+ i +"].Name");
                mediaWorkflow.Topology = context.StringValue("QueryMediaWorkflowList.MediaWorkflowList["+ i +"].Topology");
                mediaWorkflow.State = context.StringValue("QueryMediaWorkflowList.MediaWorkflowList["+ i +"].State");
                mediaWorkflow.CreationTime = context.StringValue("QueryMediaWorkflowList.MediaWorkflowList["+ i +"].CreationTime");

                mediaWorkflowList.Add(mediaWorkflow);
            }
            queryMediaWorkflowListResponse.MediaWorkflowList = mediaWorkflowList;

            return queryMediaWorkflowListResponse;
        }
        public static QueryPipelineListResponse Unmarshall(UnmarshallerContext context)
        {
            QueryPipelineListResponse queryPipelineListResponse = new QueryPipelineListResponse();

            queryPipelineListResponse.HttpResponse = context.HttpResponse;
            queryPipelineListResponse.RequestId = context.StringValue("QueryPipelineList.RequestId");

            List<string> nonExistPids = new List<string>();
            for (int i = 0; i < context.Length("QueryPipelineList.NonExistPids.Length"); i++) {
                nonExistPids.Add(context.StringValue("QueryPipelineList.NonExistPids["+ i +"]"));
            }
            queryPipelineListResponse.NonExistPids = nonExistPids;

            List<QueryPipelineListResponse.Pipeline> pipelineList = new List<QueryPipelineListResponse.Pipeline>();
            for (int i = 0; i < context.Length("QueryPipelineList.PipelineList.Length"); i++) {
                QueryPipelineListResponse.Pipeline pipeline = new QueryPipelineListResponse.Pipeline();
                pipeline.Id = context.StringValue("QueryPipelineList.PipelineList["+ i +"].Id");
                pipeline.Name = context.StringValue("QueryPipelineList.PipelineList["+ i +"].Name");
                pipeline.State = context.StringValue("QueryPipelineList.PipelineList["+ i +"].State");
                pipeline.Speed = context.StringValue("QueryPipelineList.PipelineList["+ i +"].Speed");
                pipeline.Role = context.StringValue("QueryPipelineList.PipelineList["+ i +"].Role");

                QueryPipelineListResponse.Pipeline.NotifyConfig_ notifyConfig = new QueryPipelineListResponse.Pipeline.NotifyConfig_();
                notifyConfig.Topic = context.StringValue("QueryPipelineList.PipelineList["+ i +"].NotifyConfig.Topic");
                notifyConfig.QueueName = context.StringValue("QueryPipelineList.PipelineList["+ i +"].NotifyConfig.QueueName");
                pipeline.NotifyConfig = notifyConfig;

                pipelineList.Add(pipeline);
            }
            queryPipelineListResponse.PipelineList = pipelineList;

            return queryPipelineListResponse;
        }
        public static DescribeDatabasesResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDatabasesResponse describeDatabasesResponse = new DescribeDatabasesResponse();

            describeDatabasesResponse.HttpResponse = context.HttpResponse;
            describeDatabasesResponse.RequestId = context.StringValue("DescribeDatabases.RequestId");

            List<DescribeDatabasesResponse.Database> databases = new List<DescribeDatabasesResponse.Database>();
            for (int i = 0; i < context.Length("DescribeDatabases.Databases.Length"); i++) {
                DescribeDatabasesResponse.Database database = new DescribeDatabasesResponse.Database();
                database.DBName = context.StringValue("DescribeDatabases.Databases["+ i +"].DBName");
                database.DBInstanceId = context.StringValue("DescribeDatabases.Databases["+ i +"].DBInstanceId");
                database.Engine = context.StringValue("DescribeDatabases.Databases["+ i +"].Engine");
                database.DBStatus = context.EnumValue<DescribeDatabasesResponse.Database.DBStatusEnum>("DescribeDatabases.Databases["+ i +"].DBStatus");
                database.CharacterSetName = context.StringValue("DescribeDatabases.Databases["+ i +"].CharacterSetName");
                database.DBDescription = context.StringValue("DescribeDatabases.Databases["+ i +"].DBDescription");

                List<DescribeDatabasesResponse.Database.AccountPrivilegeInfo> accounts = new List<DescribeDatabasesResponse.Database.AccountPrivilegeInfo>();
                for (int j = 0; j < context.Length("DescribeDatabases.Databases["+ i +"].Accounts.Length"); j++) {
                    DescribeDatabasesResponse.Database.AccountPrivilegeInfo accountPrivilegeInfo = new DescribeDatabasesResponse.Database.AccountPrivilegeInfo();
                    accountPrivilegeInfo.Account = context.StringValue("DescribeDatabases.Databases["+ i +"].Accounts["+ j +"].Account");
                    accountPrivilegeInfo.AccountPrivilege = context.StringValue("DescribeDatabases.Databases["+ i +"].Accounts["+ j +"].AccountPrivilege");

                    accounts.Add(accountPrivilegeInfo);
                }
                database.Accounts = accounts;

                databases.Add(database);
            }
            describeDatabasesResponse.Databases = databases;

            return describeDatabasesResponse;
        }
        public static DescribeZonesResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeZonesResponse describeZonesResponse = new DescribeZonesResponse();

            describeZonesResponse.HttpResponse = context.HttpResponse;
            describeZonesResponse.RequestId = context.StringValue("DescribeZones.RequestId");

            List<DescribeZonesResponse.Zone> zones = new List<DescribeZonesResponse.Zone>();
            for (int i = 0; i < context.Length("DescribeZones.Zones.Length"); i++) {
                DescribeZonesResponse.Zone zone = new DescribeZonesResponse.Zone();
                zone.ZoneId = context.StringValue("DescribeZones.Zones["+ i +"].ZoneId");
                zone.LocalName = context.StringValue("DescribeZones.Zones["+ i +"].LocalName");

                List<DescribeZonesResponse.Zone.SlaveZone> slaveZones = new List<DescribeZonesResponse.Zone.SlaveZone>();
                for (int j = 0; j < context.Length("DescribeZones.Zones["+ i +"].SlaveZones.Length"); j++) {
                    DescribeZonesResponse.Zone.SlaveZone slaveZone = new DescribeZonesResponse.Zone.SlaveZone();
                    slaveZone.ZoneId = context.StringValue("DescribeZones.Zones["+ i +"].SlaveZones["+ j +"].ZoneId");
                    slaveZone.LocalName = context.StringValue("DescribeZones.Zones["+ i +"].SlaveZones["+ j +"].LocalName");

                    slaveZones.Add(slaveZone);
                }
                zone.SlaveZones = slaveZones;

                zones.Add(zone);
            }
            describeZonesResponse.Zones = zones;

            return describeZonesResponse;
        }
        public static DescribeVSwitchesResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeVSwitchesResponse describeVSwitchesResponse = new DescribeVSwitchesResponse();

            describeVSwitchesResponse.HttpResponse = context.HttpResponse;
            describeVSwitchesResponse.RequestId = context.StringValue("DescribeVSwitches.RequestId");
            describeVSwitchesResponse.TotalCount = context.IntegerValue("DescribeVSwitches.TotalCount");
            describeVSwitchesResponse.PageNumber = context.IntegerValue("DescribeVSwitches.PageNumber");
            describeVSwitchesResponse.PageSize = context.IntegerValue("DescribeVSwitches.PageSize");

            List<DescribeVSwitchesResponse.VSwitch> vSwitches = new List<DescribeVSwitchesResponse.VSwitch>();
            for (int i = 0; i < context.Length("DescribeVSwitches.VSwitches.Length"); i++) {
                DescribeVSwitchesResponse.VSwitch vSwitch = new DescribeVSwitchesResponse.VSwitch();
                vSwitch.VSwitchId = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].VSwitchId");
                vSwitch.VpcId = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].VpcId");
                vSwitch.Status = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].Status");
                vSwitch.CidrBlock = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].CidrBlock");
                vSwitch.ZoneId = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].ZoneId");
                vSwitch.AvailableIpAddressCount = context.LongValue("DescribeVSwitches.VSwitches["+ i +"].AvailableIpAddressCount");
                vSwitch.Description = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].Description");
                vSwitch.VSwitchName = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].VSwitchName");
                vSwitch.CreationTime = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].CreationTime");
                vSwitch.IsDefault = context.StringValue("DescribeVSwitches.VSwitches["+ i +"].IsDefault");

                vSwitches.Add(vSwitch);
            }
            describeVSwitchesResponse.VSwitches = vSwitches;

            return describeVSwitchesResponse;
        }
        public static DescribeUserDomainsResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeUserDomainsResponse describeUserDomainsResponse = new DescribeUserDomainsResponse();

            describeUserDomainsResponse.HttpResponse = context.HttpResponse;
            describeUserDomainsResponse.RequestId = context.StringValue("DescribeUserDomains.RequestId");
            describeUserDomainsResponse.PageNumber = context.LongValue("DescribeUserDomains.PageNumber");
            describeUserDomainsResponse.PageSize = context.LongValue("DescribeUserDomains.PageSize");
            describeUserDomainsResponse.TotalCount = context.LongValue("DescribeUserDomains.TotalCount");

            List<DescribeUserDomainsResponse.PageData> domains = new List<DescribeUserDomainsResponse.PageData>();
            for (int i = 0; i < context.Length("DescribeUserDomains.Domains.Length"); i++) {
                DescribeUserDomainsResponse.PageData pageData = new DescribeUserDomainsResponse.PageData();
                pageData.DomainName = context.StringValue("DescribeUserDomains.Domains["+ i +"].DomainName");
                pageData.Cname = context.StringValue("DescribeUserDomains.Domains["+ i +"].Cname");
                pageData.CdnType = context.StringValue("DescribeUserDomains.Domains["+ i +"].CdnType");
                pageData.DomainStatus = context.StringValue("DescribeUserDomains.Domains["+ i +"].DomainStatus");
                pageData.GmtCreated = context.StringValue("DescribeUserDomains.Domains["+ i +"].GmtCreated");
                pageData.GmtModified = context.StringValue("DescribeUserDomains.Domains["+ i +"].GmtModified");
                pageData.Description = context.StringValue("DescribeUserDomains.Domains["+ i +"].Description");
                pageData.SourceType = context.StringValue("DescribeUserDomains.Domains["+ i +"].SourceType");
                pageData.SslProtocol = context.StringValue("DescribeUserDomains.Domains["+ i +"].SslProtocol");

                List<string> sources = new List<string>();
                for (int j = 0; j < context.Length("DescribeUserDomains.Domains["+ i +"].Sources.Length"); j++) {
                    sources.Add(context.StringValue("DescribeUserDomains.Domains["+ i +"].Sources["+ j +"]"));
                }
                pageData.Sources = sources;

                domains.Add(pageData);
            }
            describeUserDomainsResponse.Domains = domains;

            return describeUserDomainsResponse;
        }
        public static DescribeCdnDomainDetailResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeCdnDomainDetailResponse describeCdnDomainDetailResponse = new DescribeCdnDomainDetailResponse();

            describeCdnDomainDetailResponse.HttpResponse = context.HttpResponse;
            describeCdnDomainDetailResponse.RequestId = context.StringValue("DescribeCdnDomainDetail.RequestId");

            DescribeCdnDomainDetailResponse.GetDomainDetailModel_ getDomainDetailModel = new DescribeCdnDomainDetailResponse.GetDomainDetailModel_();
            getDomainDetailModel.GmtCreated = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.GmtCreated");
            getDomainDetailModel.GmtModified = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.GmtModified");
            getDomainDetailModel.SourceType = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.SourceType");
            getDomainDetailModel.DomainStatus = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.DomainStatus");
            getDomainDetailModel.SourcePort = context.IntegerValue("DescribeCdnDomainDetail.GetDomainDetailModel.SourcePort");
            getDomainDetailModel.CdnType = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.CdnType");
            getDomainDetailModel.Cname = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.Cname");
            getDomainDetailModel.HttpsCname = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.HttpsCname");
            getDomainDetailModel.DomainName = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.DomainName");
            getDomainDetailModel.Description = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.Description");
            getDomainDetailModel.ServerCertificateStatus = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.ServerCertificateStatus");
            getDomainDetailModel.ServerCertificate = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.ServerCertificate");
            getDomainDetailModel.Scope = context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.Scope");

            List<string> sources = new List<string>();
            for (int i = 0; i < context.Length("DescribeCdnDomainDetail.GetDomainDetailModel.Sources.Length"); i++) {
                sources.Add(context.StringValue("DescribeCdnDomainDetail.GetDomainDetailModel.Sources["+ i +"]"));
            }
            getDomainDetailModel.Sources = sources;
            describeCdnDomainDetailResponse.GetDomainDetailModel = getDomainDetailModel;

            return describeCdnDomainDetailResponse;
        }
        public static DescribeSQLLogRecordsResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeSQLLogRecordsResponse describeSQLLogRecordsResponse = new DescribeSQLLogRecordsResponse();

            describeSQLLogRecordsResponse.HttpResponse = context.HttpResponse;
            describeSQLLogRecordsResponse.RequestId = context.StringValue("DescribeSQLLogRecords.RequestId");
            describeSQLLogRecordsResponse.TotalRecordCount = context.IntegerValue("DescribeSQLLogRecords.TotalRecordCount");
            describeSQLLogRecordsResponse.PageNumber = context.IntegerValue("DescribeSQLLogRecords.PageNumber");
            describeSQLLogRecordsResponse.PageRecordCount = context.IntegerValue("DescribeSQLLogRecords.PageRecordCount");

            List<DescribeSQLLogRecordsResponse.SQLRecord> items = new List<DescribeSQLLogRecordsResponse.SQLRecord>();
            for (int i = 0; i < context.Length("DescribeSQLLogRecords.Items.Length"); i++) {
                DescribeSQLLogRecordsResponse.SQLRecord sQLRecord = new DescribeSQLLogRecordsResponse.SQLRecord();
                sQLRecord.DBName = context.StringValue("DescribeSQLLogRecords.Items["+ i +"].DBName");
                sQLRecord.AccountName = context.StringValue("DescribeSQLLogRecords.Items["+ i +"].AccountName");
                sQLRecord.HostAddress = context.StringValue("DescribeSQLLogRecords.Items["+ i +"].HostAddress");
                sQLRecord.SQLText = context.StringValue("DescribeSQLLogRecords.Items["+ i +"].SQLText");
                sQLRecord.TotalExecutionTimes = context.LongValue("DescribeSQLLogRecords.Items["+ i +"].TotalExecutionTimes");
                sQLRecord.ReturnRowCounts = context.LongValue("DescribeSQLLogRecords.Items["+ i +"].ReturnRowCounts");
                sQLRecord.ExecuteTime = context.StringValue("DescribeSQLLogRecords.Items["+ i +"].ExecuteTime");

                items.Add(sQLRecord);
            }
            describeSQLLogRecordsResponse.Items = items;

            return describeSQLLogRecordsResponse;
        }
        public static DescribeParametersResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeParametersResponse describeParametersResponse = new DescribeParametersResponse();

            describeParametersResponse.HttpResponse = context.HttpResponse;
            describeParametersResponse.RequestId = context.StringValue("DescribeParameters.RequestId");
            describeParametersResponse.Engine = context.StringValue("DescribeParameters.Engine");
            describeParametersResponse.EngineVersion = context.StringValue("DescribeParameters.EngineVersion");

            List<DescribeParametersResponse.DBInstanceParameter> configParameters = new List<DescribeParametersResponse.DBInstanceParameter>();
            for (int i = 0; i < context.Length("DescribeParameters.ConfigParameters.Length"); i++) {
                DescribeParametersResponse.DBInstanceParameter dBInstanceParameter = new DescribeParametersResponse.DBInstanceParameter();
                dBInstanceParameter.ParameterName = context.StringValue("DescribeParameters.ConfigParameters["+ i +"].ParameterName");
                dBInstanceParameter.ParameterValue = context.StringValue("DescribeParameters.ConfigParameters["+ i +"].ParameterValue");
                dBInstanceParameter.ParameterDescription = context.StringValue("DescribeParameters.ConfigParameters["+ i +"].ParameterDescription");

                configParameters.Add(dBInstanceParameter);
            }
            describeParametersResponse.ConfigParameters = configParameters;

            List<DescribeParametersResponse.DBInstanceParameter> runningParameters = new List<DescribeParametersResponse.DBInstanceParameter>();
            for (int i = 0; i < context.Length("DescribeParameters.RunningParameters.Length"); i++) {
                DescribeParametersResponse.DBInstanceParameter dBInstanceParameter = new DescribeParametersResponse.DBInstanceParameter();
                dBInstanceParameter.ParameterName = context.StringValue("DescribeParameters.RunningParameters["+ i +"].ParameterName");
                dBInstanceParameter.ParameterValue = context.StringValue("DescribeParameters.RunningParameters["+ i +"].ParameterValue");
                dBInstanceParameter.ParameterDescription = context.StringValue("DescribeParameters.RunningParameters["+ i +"].ParameterDescription");

                runningParameters.Add(dBInstanceParameter);
            }
            describeParametersResponse.RunningParameters = runningParameters;

            return describeParametersResponse;
        }
        public static DescribeDiskMonitorDataResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDiskMonitorDataResponse describeDiskMonitorDataResponse = new DescribeDiskMonitorDataResponse();

            describeDiskMonitorDataResponse.HttpResponse = context.HttpResponse;
            describeDiskMonitorDataResponse.RequestId = context.StringValue("DescribeDiskMonitorData.RequestId");
            describeDiskMonitorDataResponse.TotalCount = context.IntegerValue("DescribeDiskMonitorData.TotalCount");

            List<DescribeDiskMonitorDataResponse.DiskMonitorData> monitorData = new List<DescribeDiskMonitorDataResponse.DiskMonitorData>();
            for (int i = 0; i < context.Length("DescribeDiskMonitorData.MonitorData.Length"); i++) {
                DescribeDiskMonitorDataResponse.DiskMonitorData diskMonitorData = new DescribeDiskMonitorDataResponse.DiskMonitorData();
                diskMonitorData.DiskId = context.StringValue("DescribeDiskMonitorData.MonitorData["+ i +"].DiskId");
                diskMonitorData.IOPSRead = context.IntegerValue("DescribeDiskMonitorData.MonitorData["+ i +"].IOPSRead");
                diskMonitorData.IOPSWrite = context.IntegerValue("DescribeDiskMonitorData.MonitorData["+ i +"].IOPSWrite");
                diskMonitorData.IOPSTotal = context.IntegerValue("DescribeDiskMonitorData.MonitorData["+ i +"].IOPSTotal");
                diskMonitorData.BPSRead = context.IntegerValue("DescribeDiskMonitorData.MonitorData["+ i +"].BPSRead");
                diskMonitorData.BPSWrite = context.IntegerValue("DescribeDiskMonitorData.MonitorData["+ i +"].BPSWrite");
                diskMonitorData.BPSTotal = context.IntegerValue("DescribeDiskMonitorData.MonitorData["+ i +"].BPSTotal");
                diskMonitorData.TimeStamp = context.StringValue("DescribeDiskMonitorData.MonitorData["+ i +"].TimeStamp");

                monitorData.Add(diskMonitorData);
            }
            describeDiskMonitorDataResponse.MonitorData = monitorData;

            return describeDiskMonitorDataResponse;
        }
        public static DescribeCdnDomainBaseDetailResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeCdnDomainBaseDetailResponse describeCdnDomainBaseDetailResponse = new DescribeCdnDomainBaseDetailResponse();

            describeCdnDomainBaseDetailResponse.HttpResponse = context.HttpResponse;
            describeCdnDomainBaseDetailResponse.RequestId = context.StringValue("DescribeCdnDomainBaseDetail.RequestId");

            DescribeCdnDomainBaseDetailResponse.DomainBaseDetailModel_ domainBaseDetailModel = new DescribeCdnDomainBaseDetailResponse.DomainBaseDetailModel_();
            domainBaseDetailModel.Cname = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.Cname");
            domainBaseDetailModel.CdnType = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.CdnType");
            domainBaseDetailModel.DomainStatus = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.DomainStatus");
            domainBaseDetailModel.SourceType = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.SourceType");
            domainBaseDetailModel.DomainName = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.DomainName");
            domainBaseDetailModel.Remark = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.Remark");
            domainBaseDetailModel.GmtModified = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.GmtModified");
            domainBaseDetailModel.GmtCreated = context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.GmtCreated");

            List<string> sources = new List<string>();
            for (int i = 0; i < context.Length("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.Sources.Length"); i++) {
                sources.Add(context.StringValue("DescribeCdnDomainBaseDetail.DomainBaseDetailModel.Sources["+ i +"]"));
            }
            domainBaseDetailModel.Sources = sources;
            describeCdnDomainBaseDetailResponse.DomainBaseDetailModel = domainBaseDetailModel;

            return describeCdnDomainBaseDetailResponse;
        }
        public static DescribeDBInstancePerformanceResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDBInstancePerformanceResponse describeDBInstancePerformanceResponse = new DescribeDBInstancePerformanceResponse();

            describeDBInstancePerformanceResponse.HttpResponse = context.HttpResponse;
            describeDBInstancePerformanceResponse.RequestId = context.StringValue("DescribeDBInstancePerformance.RequestId");
            describeDBInstancePerformanceResponse.DBInstanceId = context.StringValue("DescribeDBInstancePerformance.DBInstanceId");
            describeDBInstancePerformanceResponse.Engine = context.StringValue("DescribeDBInstancePerformance.Engine");
            describeDBInstancePerformanceResponse.StartTime = context.StringValue("DescribeDBInstancePerformance.StartTime");
            describeDBInstancePerformanceResponse.EndTime = context.StringValue("DescribeDBInstancePerformance.EndTime");

            List<DescribeDBInstancePerformanceResponse.PerformanceKey> performanceKeys = new List<DescribeDBInstancePerformanceResponse.PerformanceKey>();
            for (int i = 0; i < context.Length("DescribeDBInstancePerformance.PerformanceKeys.Length"); i++) {
                DescribeDBInstancePerformanceResponse.PerformanceKey performanceKey = new DescribeDBInstancePerformanceResponse.PerformanceKey();
                performanceKey.Key = context.StringValue("DescribeDBInstancePerformance.PerformanceKeys["+ i +"].Key");
                performanceKey.Unit = context.StringValue("DescribeDBInstancePerformance.PerformanceKeys["+ i +"].Unit");
                performanceKey.ValueFormat = context.StringValue("DescribeDBInstancePerformance.PerformanceKeys["+ i +"].ValueFormat");

                List<DescribeDBInstancePerformanceResponse.PerformanceKey.PerformanceValue> values = new List<DescribeDBInstancePerformanceResponse.PerformanceKey.PerformanceValue>();
                for (int j = 0; j < context.Length("DescribeDBInstancePerformance.PerformanceKeys["+ i +"].Values.Length"); j++) {
                    DescribeDBInstancePerformanceResponse.PerformanceKey.PerformanceValue performanceValue = new DescribeDBInstancePerformanceResponse.PerformanceKey.PerformanceValue();
                    performanceValue.Value = context.StringValue("DescribeDBInstancePerformance.PerformanceKeys["+ i +"].Values["+ j +"].Value");
                    performanceValue.Date = context.StringValue("DescribeDBInstancePerformance.PerformanceKeys["+ i +"].Values["+ j +"].Date");

                    values.Add(performanceValue);
                }
                performanceKey.Values = values;

                performanceKeys.Add(performanceKey);
            }
            describeDBInstancePerformanceResponse.PerformanceKeys = performanceKeys;

            return describeDBInstancePerformanceResponse;
        }
        public static DescribeDomainLogsResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDomainLogsResponse describeDomainLogsResponse = new DescribeDomainLogsResponse();

            describeDomainLogsResponse.HttpResponse = context.HttpResponse;
            describeDomainLogsResponse.RequestId = context.StringValue("DescribeDomainLogs.RequestId");
            describeDomainLogsResponse.TotalCount = context.LongValue("DescribeDomainLogs.TotalCount");
            describeDomainLogsResponse.PageNumber = context.LongValue("DescribeDomainLogs.PageNumber");
            describeDomainLogsResponse.PageSize = context.LongValue("DescribeDomainLogs.PageSize");

            List<DescribeDomainLogsResponse.DomainLog> domainLogs = new List<DescribeDomainLogsResponse.DomainLog>();
            for (int i = 0; i < context.Length("DescribeDomainLogs.DomainLogs.Length"); i++) {
                DescribeDomainLogsResponse.DomainLog domainLog = new DescribeDomainLogsResponse.DomainLog();
                domainLog.ActionTime = context.StringValue("DescribeDomainLogs.DomainLogs["+ i +"].ActionTime");
                domainLog.DomainName = context.StringValue("DescribeDomainLogs.DomainLogs["+ i +"].DomainName");
                domainLog.Action = context.StringValue("DescribeDomainLogs.DomainLogs["+ i +"].Action");
                domainLog.Message = context.StringValue("DescribeDomainLogs.DomainLogs["+ i +"].Message");
                domainLog.ClientIp = context.StringValue("DescribeDomainLogs.DomainLogs["+ i +"].ClientIp");

                domainLogs.Add(domainLog);
            }
            describeDomainLogsResponse.DomainLogs = domainLogs;

            return describeDomainLogsResponse;
        }
        public static SearchWaterMarkTemplateResponse Unmarshall(UnmarshallerContext context)
        {
            SearchWaterMarkTemplateResponse searchWaterMarkTemplateResponse = new SearchWaterMarkTemplateResponse();

            searchWaterMarkTemplateResponse.HttpResponse = context.HttpResponse;
            searchWaterMarkTemplateResponse.RequestId = context.StringValue("SearchWaterMarkTemplate.RequestId");
            searchWaterMarkTemplateResponse.TotalCount = context.LongValue("SearchWaterMarkTemplate.TotalCount");
            searchWaterMarkTemplateResponse.PageNumber = context.LongValue("SearchWaterMarkTemplate.PageNumber");
            searchWaterMarkTemplateResponse.PageSize = context.LongValue("SearchWaterMarkTemplate.PageSize");

            List<SearchWaterMarkTemplateResponse.WaterMarkTemplate> waterMarkTemplateList = new List<SearchWaterMarkTemplateResponse.WaterMarkTemplate>();
            for (int i = 0; i < context.Length("SearchWaterMarkTemplate.WaterMarkTemplateList.Length"); i++) {
                SearchWaterMarkTemplateResponse.WaterMarkTemplate waterMarkTemplate = new SearchWaterMarkTemplateResponse.WaterMarkTemplate();
                waterMarkTemplate.Id = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Id");
                waterMarkTemplate.Name = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Name");
                waterMarkTemplate.Width = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Width");
                waterMarkTemplate.Height = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Height");
                waterMarkTemplate.Dx = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Dx");
                waterMarkTemplate.Dy = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Dy");
                waterMarkTemplate.ReferPos = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].ReferPos");
                waterMarkTemplate.Type = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].Type");
                waterMarkTemplate.State = context.StringValue("SearchWaterMarkTemplate.WaterMarkTemplateList["+ i +"].State");

                waterMarkTemplateList.Add(waterMarkTemplate);
            }
            searchWaterMarkTemplateResponse.WaterMarkTemplateList = waterMarkTemplateList;

            return searchWaterMarkTemplateResponse;
        }
        public static DescribeDomainISPDataResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDomainISPDataResponse describeDomainISPDataResponse = new DescribeDomainISPDataResponse();

            describeDomainISPDataResponse.HttpResponse = context.HttpResponse;
            describeDomainISPDataResponse.RequestId = context.StringValue("DescribeDomainISPData.RequestId");
            describeDomainISPDataResponse.DomainName = context.StringValue("DescribeDomainISPData.DomainName");
            describeDomainISPDataResponse.DataInterval = context.StringValue("DescribeDomainISPData.DataInterval");
            describeDomainISPDataResponse.StartTime = context.StringValue("DescribeDomainISPData.StartTime");
            describeDomainISPDataResponse.EndTime = context.StringValue("DescribeDomainISPData.EndTime");

            List<DescribeDomainISPDataResponse.ISPProportionData> value = new List<DescribeDomainISPDataResponse.ISPProportionData>();
            for (int i = 0; i < context.Length("DescribeDomainISPData.Value.Length"); i++) {
                DescribeDomainISPDataResponse.ISPProportionData iSPProportionData = new DescribeDomainISPDataResponse.ISPProportionData();
                iSPProportionData.ISP = context.StringValue("DescribeDomainISPData.Value["+ i +"].ISP");
                iSPProportionData.Proportion = context.StringValue("DescribeDomainISPData.Value["+ i +"].Proportion");
                iSPProportionData.IspEname = context.StringValue("DescribeDomainISPData.Value["+ i +"].IspEname");
                iSPProportionData.AvgObjectSize = context.StringValue("DescribeDomainISPData.Value["+ i +"].AvgObjectSize");
                iSPProportionData.AvgResponseTime = context.StringValue("DescribeDomainISPData.Value["+ i +"].AvgResponseTime");
                iSPProportionData.Bps = context.StringValue("DescribeDomainISPData.Value["+ i +"].Bps");
                iSPProportionData.ByteHitRate = context.StringValue("DescribeDomainISPData.Value["+ i +"].ByteHitRate");
                iSPProportionData.Qps = context.StringValue("DescribeDomainISPData.Value["+ i +"].Qps");
                iSPProportionData.ReqErrRate = context.StringValue("DescribeDomainISPData.Value["+ i +"].ReqErrRate");
                iSPProportionData.ReqHitRate = context.StringValue("DescribeDomainISPData.Value["+ i +"].ReqHitRate");
                iSPProportionData.AvgResponseRate = context.StringValue("DescribeDomainISPData.Value["+ i +"].AvgResponseRate");
                iSPProportionData.TotalBytes = context.StringValue("DescribeDomainISPData.Value["+ i +"].TotalBytes");
                iSPProportionData.BytesProportion = context.StringValue("DescribeDomainISPData.Value["+ i +"].BytesProportion");
                iSPProportionData.TotalQuery = context.StringValue("DescribeDomainISPData.Value["+ i +"].TotalQuery");

                value.Add(iSPProportionData);
            }
            describeDomainISPDataResponse.Value = value;

            return describeDomainISPDataResponse;
        }
        public static ListDevicePermitsResponse Unmarshall(UnmarshallerContext context)
        {
            ListDevicePermitsResponse listDevicePermitsResponse = new ListDevicePermitsResponse();

            listDevicePermitsResponse.HttpResponse = context.HttpResponse;
            listDevicePermitsResponse.RequestId = context.StringValue("ListDevicePermits.RequestId");
            listDevicePermitsResponse.Success = context.BooleanValue("ListDevicePermits.Success");
            listDevicePermitsResponse.ErrorMessage = context.StringValue("ListDevicePermits.ErrorMessage");

            List<ListDevicePermitsResponse.DevicePermission> devicePermissions = new List<ListDevicePermitsResponse.DevicePermission>();
            for (int i = 0; i < context.Length("ListDevicePermits.DevicePermissions.Length"); i++) {
                ListDevicePermitsResponse.DevicePermission devicePermission = new ListDevicePermitsResponse.DevicePermission();
                devicePermission.Id = context.LongValue("ListDevicePermits.DevicePermissions["+ i +"].Id");
                devicePermission.AppKey = context.LongValue("ListDevicePermits.DevicePermissions["+ i +"].AppKey");
                devicePermission.DeviceId = context.StringValue("ListDevicePermits.DevicePermissions["+ i +"].DeviceId");
                devicePermission.GrantType = context.StringValue("ListDevicePermits.DevicePermissions["+ i +"].GrantType");
                devicePermission.TopicFullName = context.StringValue("ListDevicePermits.DevicePermissions["+ i +"].TopicFullName");
                devicePermission.TopicUserId = context.LongValue("ListDevicePermits.DevicePermissions["+ i +"].TopicUserId");

                devicePermissions.Add(devicePermission);
            }
            listDevicePermitsResponse.DevicePermissions = devicePermissions;

            return listDevicePermitsResponse;
        }
        public static DescribeAccessPointsResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeAccessPointsResponse describeAccessPointsResponse = new DescribeAccessPointsResponse();

            describeAccessPointsResponse.HttpResponse = context.HttpResponse;
            describeAccessPointsResponse.RequestId = context.StringValue("DescribeAccessPoints.RequestId");
            describeAccessPointsResponse.PageNumber = context.IntegerValue("DescribeAccessPoints.PageNumber");
            describeAccessPointsResponse.PageSize = context.IntegerValue("DescribeAccessPoints.PageSize");
            describeAccessPointsResponse.TotalCount = context.IntegerValue("DescribeAccessPoints.TotalCount");

            List<DescribeAccessPointsResponse.AccessPointType> accessPointSet = new List<DescribeAccessPointsResponse.AccessPointType>();
            for (int i = 0; i < context.Length("DescribeAccessPoints.AccessPointSet.Length"); i++) {
                DescribeAccessPointsResponse.AccessPointType accessPointType = new DescribeAccessPointsResponse.AccessPointType();
                accessPointType.AccessPointId = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].AccessPointId");
                accessPointType.Status = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].Status");
                accessPointType.Type = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].Type");
                accessPointType.AttachedRegionNo = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].AttachedRegionNo");
                accessPointType.Location = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].Location");
                accessPointType.HostOperator = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].HostOperator");
                accessPointType.Name = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].Name");
                accessPointType.Description = context.StringValue("DescribeAccessPoints.AccessPointSet["+ i +"].Description");

                accessPointSet.Add(accessPointType);
            }
            describeAccessPointsResponse.AccessPointSet = accessPointSet;

            return describeAccessPointsResponse;
        }
        public static DescribeSecurityGroupAttributeResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeSecurityGroupAttributeResponse describeSecurityGroupAttributeResponse = new DescribeSecurityGroupAttributeResponse();

            describeSecurityGroupAttributeResponse.HttpResponse = context.HttpResponse;
            describeSecurityGroupAttributeResponse.RequestId = context.StringValue("DescribeSecurityGroupAttribute.RequestId");
            describeSecurityGroupAttributeResponse.RegionId = context.StringValue("DescribeSecurityGroupAttribute.RegionId");
            describeSecurityGroupAttributeResponse.SecurityGroupId = context.StringValue("DescribeSecurityGroupAttribute.SecurityGroupId");
            describeSecurityGroupAttributeResponse.Description = context.StringValue("DescribeSecurityGroupAttribute.Description");
            describeSecurityGroupAttributeResponse.SecurityGroupName = context.StringValue("DescribeSecurityGroupAttribute.SecurityGroupName");
            describeSecurityGroupAttributeResponse.VpcId = context.StringValue("DescribeSecurityGroupAttribute.VpcId");

            List<DescribeSecurityGroupAttributeResponse.Permission> permissions = new List<DescribeSecurityGroupAttributeResponse.Permission>();
            for (int i = 0; i < context.Length("DescribeSecurityGroupAttribute.Permissions.Length"); i++) {
                DescribeSecurityGroupAttributeResponse.Permission permission = new DescribeSecurityGroupAttributeResponse.Permission();
                permission.IpProtocol = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].IpProtocol");
                permission.PortRange = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].PortRange");
                permission.SourceGroupId = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].SourceGroupId");
                permission.SourceCidrIp = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].SourceCidrIp");
                permission.Policy = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].Policy");
                permission.NicType = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].NicType");
                permission.SourceGroupOwnerAccount = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].SourceGroupOwnerAccount");
                permission.DestGroupId = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].DestGroupId");
                permission.DestCidrIp = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].DestCidrIp");
                permission.DestGroupOwnerAccount = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].DestGroupOwnerAccount");
                permission.Priority = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].Priority");
                permission.Direction = context.StringValue("DescribeSecurityGroupAttribute.Permissions["+ i +"].Direction");

                permissions.Add(permission);
            }
            describeSecurityGroupAttributeResponse.Permissions = permissions;

            return describeSecurityGroupAttributeResponse;
        }
        public static DescribeDBInstancesByPerformanceResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDBInstancesByPerformanceResponse describeDBInstancesByPerformanceResponse = new DescribeDBInstancesByPerformanceResponse();

            describeDBInstancesByPerformanceResponse.HttpResponse = context.HttpResponse;
            describeDBInstancesByPerformanceResponse.RequestId = context.StringValue("DescribeDBInstancesByPerformance.RequestId");
            describeDBInstancesByPerformanceResponse.PageNumber = context.IntegerValue("DescribeDBInstancesByPerformance.PageNumber");
            describeDBInstancesByPerformanceResponse.TotalRecordCount = context.IntegerValue("DescribeDBInstancesByPerformance.TotalRecordCount");
            describeDBInstancesByPerformanceResponse.PageRecordCount = context.IntegerValue("DescribeDBInstancesByPerformance.PageRecordCount");

            List<DescribeDBInstancesByPerformanceResponse.DBInstancePerformance> items = new List<DescribeDBInstancesByPerformanceResponse.DBInstancePerformance>();
            for (int i = 0; i < context.Length("DescribeDBInstancesByPerformance.Items.Length"); i++) {
                DescribeDBInstancesByPerformanceResponse.DBInstancePerformance dBInstancePerformance = new DescribeDBInstancesByPerformanceResponse.DBInstancePerformance();
                dBInstancePerformance.CPUUsage = context.StringValue("DescribeDBInstancesByPerformance.Items["+ i +"].CPUUsage");
                dBInstancePerformance.IOPSUsage = context.StringValue("DescribeDBInstancesByPerformance.Items["+ i +"].IOPSUsage");
                dBInstancePerformance.DiskUsage = context.StringValue("DescribeDBInstancesByPerformance.Items["+ i +"].DiskUsage");
                dBInstancePerformance.SessionUsage = context.StringValue("DescribeDBInstancesByPerformance.Items["+ i +"].SessionUsage");
                dBInstancePerformance.DBInstanceId = context.StringValue("DescribeDBInstancesByPerformance.Items["+ i +"].DBInstanceId");
                dBInstancePerformance.DBInstanceDescription = context.StringValue("DescribeDBInstancesByPerformance.Items["+ i +"].DBInstanceDescription");

                items.Add(dBInstancePerformance);
            }
            describeDBInstancesByPerformanceResponse.Items = items;

            return describeDBInstancesByPerformanceResponse;
        }
        public static DescribeCdnMonitorDataResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeCdnMonitorDataResponse describeCdnMonitorDataResponse = new DescribeCdnMonitorDataResponse();

            describeCdnMonitorDataResponse.HttpResponse = context.HttpResponse;
            describeCdnMonitorDataResponse.RequestId = context.StringValue("DescribeCdnMonitorData.RequestId");
            describeCdnMonitorDataResponse.DomainName = context.StringValue("DescribeCdnMonitorData.DomainName");
            describeCdnMonitorDataResponse.MonitorInterval = context.LongValue("DescribeCdnMonitorData.MonitorInterval");
            describeCdnMonitorDataResponse.StartTime = context.StringValue("DescribeCdnMonitorData.StartTime");
            describeCdnMonitorDataResponse.EndTime = context.StringValue("DescribeCdnMonitorData.EndTime");

            List<DescribeCdnMonitorDataResponse.CDNMonitorData> monitorDatas = new List<DescribeCdnMonitorDataResponse.CDNMonitorData>();
            for (int i = 0; i < context.Length("DescribeCdnMonitorData.MonitorDatas.Length"); i++) {
                DescribeCdnMonitorDataResponse.CDNMonitorData cDNMonitorData = new DescribeCdnMonitorDataResponse.CDNMonitorData();
                cDNMonitorData.TimeStamp = context.StringValue("DescribeCdnMonitorData.MonitorDatas["+ i +"].TimeStamp");
                cDNMonitorData.QueryPerSecond = context.StringValue("DescribeCdnMonitorData.MonitorDatas["+ i +"].QueryPerSecond");
                cDNMonitorData.BytesPerSecond = context.StringValue("DescribeCdnMonitorData.MonitorDatas["+ i +"].BytesPerSecond");
                cDNMonitorData.BytesHitRate = context.StringValue("DescribeCdnMonitorData.MonitorDatas["+ i +"].BytesHitRate");
                cDNMonitorData.RequestHitRate = context.StringValue("DescribeCdnMonitorData.MonitorDatas["+ i +"].RequestHitRate");
                cDNMonitorData.AverageObjectSize = context.StringValue("DescribeCdnMonitorData.MonitorDatas["+ i +"].AverageObjectSize");

                monitorDatas.Add(cDNMonitorData);
            }
            describeCdnMonitorDataResponse.MonitorDatas = monitorDatas;

            return describeCdnMonitorDataResponse;
        }
        public static DescribeAuthorizedApisResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeAuthorizedApisResponse describeAuthorizedApisResponse = new DescribeAuthorizedApisResponse();

            describeAuthorizedApisResponse.HttpResponse = context.HttpResponse;
            describeAuthorizedApisResponse.RequestId = context.StringValue("DescribeAuthorizedApis.RequestId");
            describeAuthorizedApisResponse.TotalCount = context.IntegerValue("DescribeAuthorizedApis.TotalCount");
            describeAuthorizedApisResponse.PageSize = context.IntegerValue("DescribeAuthorizedApis.PageSize");
            describeAuthorizedApisResponse.PageNumber = context.IntegerValue("DescribeAuthorizedApis.PageNumber");

            List<DescribeAuthorizedApisResponse.AuthorizedApi> authorizedApis = new List<DescribeAuthorizedApisResponse.AuthorizedApi>();
            for (int i = 0; i < context.Length("DescribeAuthorizedApis.AuthorizedApis.Length"); i++) {
                DescribeAuthorizedApisResponse.AuthorizedApi authorizedApi = new DescribeAuthorizedApisResponse.AuthorizedApi();
                authorizedApi.RegionId = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].RegionId");
                authorizedApi.GroupId = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].GroupId");
                authorizedApi.GroupName = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].GroupName");
                authorizedApi.StageName = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].StageName");
                authorizedApi.Operator = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].Operator");
                authorizedApi.ApiId = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].ApiId");
                authorizedApi.ApiName = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].ApiName");
                authorizedApi.AuthorizationSource = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].AuthorizationSource");
                authorizedApi.Description = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].Description");
                authorizedApi.AuthorizedTime = context.StringValue("DescribeAuthorizedApis.AuthorizedApis["+ i +"].AuthorizedTime");

                authorizedApis.Add(authorizedApi);
            }
            describeAuthorizedApisResponse.AuthorizedApis = authorizedApis;

            return describeAuthorizedApisResponse;
        }
        public static DescribeVirtualBorderRoutersForPhysicalConnectionResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeVirtualBorderRoutersForPhysicalConnectionResponse describeVirtualBorderRoutersForPhysicalConnectionResponse = new DescribeVirtualBorderRoutersForPhysicalConnectionResponse();

            describeVirtualBorderRoutersForPhysicalConnectionResponse.HttpResponse = context.HttpResponse;
            describeVirtualBorderRoutersForPhysicalConnectionResponse.RequestId = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.RequestId");
            describeVirtualBorderRoutersForPhysicalConnectionResponse.PageNumber = context.IntegerValue("DescribeVirtualBorderRoutersForPhysicalConnection.PageNumber");
            describeVirtualBorderRoutersForPhysicalConnectionResponse.PageSize = context.IntegerValue("DescribeVirtualBorderRoutersForPhysicalConnection.PageSize");
            describeVirtualBorderRoutersForPhysicalConnectionResponse.TotalCount = context.IntegerValue("DescribeVirtualBorderRoutersForPhysicalConnection.TotalCount");

            List<DescribeVirtualBorderRoutersForPhysicalConnectionResponse.VirtualBorderRouterForPhysicalConnectionType> virtualBorderRouterForPhysicalConnectionSet = new List<DescribeVirtualBorderRoutersForPhysicalConnectionResponse.VirtualBorderRouterForPhysicalConnectionType>();
            for (int i = 0; i < context.Length("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet.Length"); i++) {
                DescribeVirtualBorderRoutersForPhysicalConnectionResponse.VirtualBorderRouterForPhysicalConnectionType virtualBorderRouterForPhysicalConnectionType = new DescribeVirtualBorderRoutersForPhysicalConnectionResponse.VirtualBorderRouterForPhysicalConnectionType();
                virtualBorderRouterForPhysicalConnectionType.VbrId = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].VbrId");
                virtualBorderRouterForPhysicalConnectionType.VbrOwnerUid = context.LongValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].VbrOwnerUid");
                virtualBorderRouterForPhysicalConnectionType.CreationTime = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].CreationTime");
                virtualBorderRouterForPhysicalConnectionType.ActivationTime = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].ActivationTime");
                virtualBorderRouterForPhysicalConnectionType.TerminationTime = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].TerminationTime");
                virtualBorderRouterForPhysicalConnectionType.RecoveryTime = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].RecoveryTime");
                virtualBorderRouterForPhysicalConnectionType.VlanId = context.IntegerValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].VlanId");
                virtualBorderRouterForPhysicalConnectionType.CircuitCode = context.StringValue("DescribeVirtualBorderRoutersForPhysicalConnection.VirtualBorderRouterForPhysicalConnectionSet["+ i +"].CircuitCode");

                virtualBorderRouterForPhysicalConnectionSet.Add(virtualBorderRouterForPhysicalConnectionType);
            }
            describeVirtualBorderRoutersForPhysicalConnectionResponse.VirtualBorderRouterForPhysicalConnectionSet = virtualBorderRouterForPhysicalConnectionSet;

            return describeVirtualBorderRoutersForPhysicalConnectionResponse;
        }
        public static DescribeImageSharePermissionResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeImageSharePermissionResponse describeImageSharePermissionResponse = new DescribeImageSharePermissionResponse();

            describeImageSharePermissionResponse.HttpResponse = context.HttpResponse;
            describeImageSharePermissionResponse.RequestId = context.StringValue("DescribeImageSharePermission.RequestId");
            describeImageSharePermissionResponse.RegionId = context.StringValue("DescribeImageSharePermission.RegionId");
            describeImageSharePermissionResponse.TotalCount = context.IntegerValue("DescribeImageSharePermission.TotalCount");
            describeImageSharePermissionResponse.PageNumber = context.IntegerValue("DescribeImageSharePermission.PageNumber");
            describeImageSharePermissionResponse.PageSize = context.IntegerValue("DescribeImageSharePermission.PageSize");
            describeImageSharePermissionResponse.ImageId = context.StringValue("DescribeImageSharePermission.ImageId");

            List<DescribeImageSharePermissionResponse.ShareGroup> shareGroups = new List<DescribeImageSharePermissionResponse.ShareGroup>();
            for (int i = 0; i < context.Length("DescribeImageSharePermission.ShareGroups.Length"); i++) {
                DescribeImageSharePermissionResponse.ShareGroup shareGroup = new DescribeImageSharePermissionResponse.ShareGroup();
                shareGroup.Group = context.StringValue("DescribeImageSharePermission.ShareGroups["+ i +"].Group");

                shareGroups.Add(shareGroup);
            }
            describeImageSharePermissionResponse.ShareGroups = shareGroups;

            List<DescribeImageSharePermissionResponse.Account> accounts = new List<DescribeImageSharePermissionResponse.Account>();
            for (int i = 0; i < context.Length("DescribeImageSharePermission.Accounts.Length"); i++) {
                DescribeImageSharePermissionResponse.Account account = new DescribeImageSharePermissionResponse.Account();
                account.AliyunId = context.StringValue("DescribeImageSharePermission.Accounts["+ i +"].AliyunId");

                accounts.Add(account);
            }
            describeImageSharePermissionResponse.Accounts = accounts;

            return describeImageSharePermissionResponse;
        }
        public static DescribeDomainWafDataResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeDomainWafDataResponse describeDomainWafDataResponse = new DescribeDomainWafDataResponse();

            describeDomainWafDataResponse.HttpResponse = context.HttpResponse;
            describeDomainWafDataResponse.RequestId = context.StringValue("DescribeDomainWafData.RequestId");
            describeDomainWafDataResponse.DomainName = context.StringValue("DescribeDomainWafData.DomainName");
            describeDomainWafDataResponse.DataInterval = context.StringValue("DescribeDomainWafData.DataInterval");
            describeDomainWafDataResponse.StartTime = context.StringValue("DescribeDomainWafData.StartTime");
            describeDomainWafDataResponse.EndTime = context.StringValue("DescribeDomainWafData.EndTime");

            List<DescribeDomainWafDataResponse.WafDatas> wafDataList = new List<DescribeDomainWafDataResponse.WafDatas>();
            for (int i = 0; i < context.Length("DescribeDomainWafData.WafDataList.Length"); i++) {
                DescribeDomainWafDataResponse.WafDatas wafDatas = new DescribeDomainWafDataResponse.WafDatas();
                wafDatas.TimeStamp = context.StringValue("DescribeDomainWafData.WafDataList["+ i +"].TimeStamp");

                List<string> value = new List<string>();
                for (int j = 0; j < context.Length("DescribeDomainWafData.WafDataList["+ i +"].Value.Length"); j++) {
                    value.Add(context.StringValue("DescribeDomainWafData.WafDataList["+ i +"].Value["+ j +"]"));
                }
                wafDatas.Value = value;

                wafDataList.Add(wafDatas);
            }
            describeDomainWafDataResponse.WafDataList = wafDataList;

            return describeDomainWafDataResponse;
        }
        public static DescribeOptimizeAdviceOnBigTableResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeOptimizeAdviceOnBigTableResponse describeOptimizeAdviceOnBigTableResponse = new DescribeOptimizeAdviceOnBigTableResponse();

            describeOptimizeAdviceOnBigTableResponse.HttpResponse = context.HttpResponse;
            describeOptimizeAdviceOnBigTableResponse.RequestId = context.StringValue("DescribeOptimizeAdviceOnBigTable.RequestId");
            describeOptimizeAdviceOnBigTableResponse.TotalRecordsCount = context.IntegerValue("DescribeOptimizeAdviceOnBigTable.TotalRecordsCount");
            describeOptimizeAdviceOnBigTableResponse.PageNumber = context.IntegerValue("DescribeOptimizeAdviceOnBigTable.PageNumber");
            describeOptimizeAdviceOnBigTableResponse.PageRecordCount = context.IntegerValue("DescribeOptimizeAdviceOnBigTable.PageRecordCount");

            List<DescribeOptimizeAdviceOnBigTableResponse.AdviceOnBigTable> items = new List<DescribeOptimizeAdviceOnBigTableResponse.AdviceOnBigTable>();
            for (int i = 0; i < context.Length("DescribeOptimizeAdviceOnBigTable.Items.Length"); i++) {
                DescribeOptimizeAdviceOnBigTableResponse.AdviceOnBigTable adviceOnBigTable = new DescribeOptimizeAdviceOnBigTableResponse.AdviceOnBigTable();
                adviceOnBigTable.DBName = context.StringValue("DescribeOptimizeAdviceOnBigTable.Items["+ i +"].DBName");
                adviceOnBigTable.TableName = context.StringValue("DescribeOptimizeAdviceOnBigTable.Items["+ i +"].TableName");
                adviceOnBigTable.TableSize = context.LongValue("DescribeOptimizeAdviceOnBigTable.Items["+ i +"].TableSize");
                adviceOnBigTable.DataSize = context.LongValue("DescribeOptimizeAdviceOnBigTable.Items["+ i +"].DataSize");
                adviceOnBigTable.IndexSize = context.LongValue("DescribeOptimizeAdviceOnBigTable.Items["+ i +"].IndexSize");

                items.Add(adviceOnBigTable);
            }
            describeOptimizeAdviceOnBigTableResponse.Items = items;

            return describeOptimizeAdviceOnBigTableResponse;
        }
        public static DescribeLoadBalancerHTTPListenerAttributeResponse Unmarshall(UnmarshallerContext context)
        {
            DescribeLoadBalancerHTTPListenerAttributeResponse describeLoadBalancerHTTPListenerAttributeResponse = new DescribeLoadBalancerHTTPListenerAttributeResponse();

            describeLoadBalancerHTTPListenerAttributeResponse.HttpResponse = context.HttpResponse;
            describeLoadBalancerHTTPListenerAttributeResponse.RequestId = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.RequestId");
            describeLoadBalancerHTTPListenerAttributeResponse.ListenerPort = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.ListenerPort");
            describeLoadBalancerHTTPListenerAttributeResponse.BackendServerPort = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.BackendServerPort");
            describeLoadBalancerHTTPListenerAttributeResponse.Bandwidth = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.Bandwidth");
            describeLoadBalancerHTTPListenerAttributeResponse.Status = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.Status");
            describeLoadBalancerHTTPListenerAttributeResponse.SecurityStatus = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.SecurityStatus");
            describeLoadBalancerHTTPListenerAttributeResponse.XForwardedFor = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.XForwardedFor");
            describeLoadBalancerHTTPListenerAttributeResponse.Scheduler = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.Scheduler");
            describeLoadBalancerHTTPListenerAttributeResponse.StickySession = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.StickySession");
            describeLoadBalancerHTTPListenerAttributeResponse.StickySessionType = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.StickySessionType");
            describeLoadBalancerHTTPListenerAttributeResponse.CookieTimeout = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.CookieTimeout");
            describeLoadBalancerHTTPListenerAttributeResponse.Cookie = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.Cookie");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheck = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheck");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheckDomain = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheckDomain");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheckURI = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheckURI");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthyThreshold = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.HealthyThreshold");
            describeLoadBalancerHTTPListenerAttributeResponse.UnhealthyThreshold = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.UnhealthyThreshold");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheckTimeout = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheckTimeout");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheckInterval = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheckInterval");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheckConnectPort = context.IntegerValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheckConnectPort");
            describeLoadBalancerHTTPListenerAttributeResponse.HealthCheckHttpCode = context.StringValue("DescribeLoadBalancerHTTPListenerAttribute.HealthCheckHttpCode");

            return describeLoadBalancerHTTPListenerAttributeResponse;
        }
Beispiel #31
0
 public override CreateClusterResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(CreateClusterResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #32
0
 public override DescribeReplicaPerformanceResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeReplicaPerformanceResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #33
0
 public override PublishSurveyResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(PublishSurveyResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #34
0
 public override DescribeTraceInfoDetailResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeTraceInfoDetailResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #35
0
 public override RebuildDBInstanceResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(RebuildDBInstanceResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override JoinLiveResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(JoinLiveResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override ImportImageResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ImportImageResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override ReleaseDedicatedHostResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ReleaseDedicatedHostResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #39
0
 public override ListRuleResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ListRuleResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override DeleteFlowlogResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DeleteFlowlogResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #41
0
 public override GetProjectSprintInfoResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(GetProjectSprintInfoResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #42
0
 public override DescribeVulnerabilitySummaryResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeVulnerabilitySummaryResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #43
0
 public override DescribeDBClusterAttributeResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeDBClusterAttributeResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #44
0
 public override DeleteForwardEntryResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DeleteForwardEntryResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #45
0
 public override GetStructSyncOrderDetailResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(GetStructSyncOrderDetailResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #46
0
 public override DescribeTasksResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeTasksResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override SaveSingleTaskForDisassociatingEnsResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(SaveSingleTaskForDisassociatingEnsResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #48
0
 public override RemoveProjectMemberFromRoleResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(RemoveProjectMemberFromRoleResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #49
0
 public override UpdateAccessKeyResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(UpdateAccessKeyResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #50
0
 public override DescribeInitializationStatusResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeInitializationStatusResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #51
0
 public override ModifyDBClusterSSLResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ModifyDBClusterSSLResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override PubBroadcastResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(PubBroadcastResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override CreateDBResourcePoolResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(CreateDBResourcePoolResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #54
0
 public override ValidateJobResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ValidateJobResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #55
0
 public override CreateVirtualHostResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(CreateVirtualHostResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override ListUserTenantsResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ListUserTenantsResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #57
0
 public override ApproveOrderResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(ApproveOrderResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #58
0
 public override GetUserResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(GetUserResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
 public override BindAliasResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(BindAliasResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }
Beispiel #60
0
 public override DescribeCrossBackupMetaListResponse GetResponse(UnmarshallerContext unmarshallerContext)
 {
     return(DescribeCrossBackupMetaListResponseUnmarshaller.Unmarshall(unmarshallerContext));
 }