avds-20171129/alibabacloud_avds20171129/models.py (8,433 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
from typing import List, Dict
class AddAssetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
start_after_verified: bool = None,
asset_group_id: str = None,
assets: List[str] = None,
tags: List[str] = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.start_after_verified = start_after_verified
self.asset_group_id = asset_group_id
self.assets = assets
self.tags = tags
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.start_after_verified is not None:
result['StartAfterVerified'] = self.start_after_verified
if self.asset_group_id is not None:
result['AssetGroupId'] = self.asset_group_id
if self.assets is not None:
result['Assets'] = self.assets
if self.tags is not None:
result['Tags'] = self.tags
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('StartAfterVerified') is not None:
self.start_after_verified = m.get('StartAfterVerified')
if m.get('AssetGroupId') is not None:
self.asset_group_id = m.get('AssetGroupId')
if m.get('Assets') is not None:
self.assets = m.get('Assets')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
return self
class AddAssetsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
success: bool = None,
):
self.request_id = request_id
self.success = success
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.success is not None:
result['Success'] = self.success
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Success') is not None:
self.success = m.get('Success')
return self
class AddAssetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddAssetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddAssetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddAssetTagsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
lang: str = None,
assets: List[str] = None,
tags: List[str] = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.lang = lang
self.assets = assets
self.tags = tags
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.lang is not None:
result['Lang'] = self.lang
if self.assets is not None:
result['Assets'] = self.assets
if self.tags is not None:
result['Tags'] = self.tags
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('Lang') is not None:
self.lang = m.get('Lang')
if m.get('Assets') is not None:
self.assets = m.get('Assets')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
return self
class AddAssetTagsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddAssetTagsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddAssetTagsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddAssetTagsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddOrgDomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
domains: List[str] = None,
):
self.source_ip = source_ip
self.org_id = org_id
self.domains = domains
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.domains is not None:
result['Domains'] = self.domains
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Domains') is not None:
self.domains = m.get('Domains')
return self
class AddOrgDomainsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddOrgDomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddOrgDomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddOrgDomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddOrgHostsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
hosts: List[str] = None,
):
self.source_ip = source_ip
self.org_id = org_id
self.hosts = hosts
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.hosts is not None:
result['Hosts'] = self.hosts
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Hosts') is not None:
self.hosts = m.get('Hosts')
return self
class AddOrgHostsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddOrgHostsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddOrgHostsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddOrgHostsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddOrgSubdomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
subdomains: List[str] = None,
):
self.source_ip = source_ip
self.org_id = org_id
self.subdomains = subdomains
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.subdomains is not None:
result['Subdomains'] = self.subdomains
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Subdomains') is not None:
self.subdomains = m.get('Subdomains')
return self
class AddOrgSubdomainsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddOrgSubdomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddOrgSubdomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddOrgSubdomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddOrgWebPathsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
urls: List[str] = None,
):
self.source_ip = source_ip
self.org_id = org_id
self.urls = urls
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.urls is not None:
result['URLs'] = self.urls
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('URLs') is not None:
self.urls = m.get('URLs')
return self
class AddOrgWebPathsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddOrgWebPathsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddOrgWebPathsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddOrgWebPathsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateAvdsBagOrderRequest(TeaModel):
def __init__(
self,
period: int = None,
period_unit: str = None,
auto_pay: bool = None,
auto_use_coupon: bool = None,
flowout_spec: str = None,
pack: str = None,
):
self.period = period
self.period_unit = period_unit
self.auto_pay = auto_pay
self.auto_use_coupon = auto_use_coupon
self.flowout_spec = flowout_spec
self.pack = pack
def validate(self):
pass
def to_map(self):
result = dict()
if self.period is not None:
result['Period'] = self.period
if self.period_unit is not None:
result['PeriodUnit'] = self.period_unit
if self.auto_pay is not None:
result['AutoPay'] = self.auto_pay
if self.auto_use_coupon is not None:
result['AutoUseCoupon'] = self.auto_use_coupon
if self.flowout_spec is not None:
result['FlowoutSpec'] = self.flowout_spec
if self.pack is not None:
result['Pack'] = self.pack
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Period') is not None:
self.period = m.get('Period')
if m.get('PeriodUnit') is not None:
self.period_unit = m.get('PeriodUnit')
if m.get('AutoPay') is not None:
self.auto_pay = m.get('AutoPay')
if m.get('AutoUseCoupon') is not None:
self.auto_use_coupon = m.get('AutoUseCoupon')
if m.get('FlowoutSpec') is not None:
self.flowout_spec = m.get('FlowoutSpec')
if m.get('Pack') is not None:
self.pack = m.get('Pack')
return self
class CreateAvdsBagOrderResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
order_id: str = None,
):
self.request_id = request_id
self.order_id = order_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.order_id is not None:
result['OrderId'] = self.order_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('OrderId') is not None:
self.order_id = m.get('OrderId')
return self
class CreateAvdsBagOrderResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: CreateAvdsBagOrderResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = CreateAvdsBagOrderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateAvdsOrderRequest(TeaModel):
def __init__(
self,
period: int = None,
period_unit: str = None,
auto_pay: bool = None,
auto_use_coupon: bool = None,
site_num: str = None,
service_version: str = None,
url_num: str = None,
add_vul_num: str = None,
):
self.period = period
self.period_unit = period_unit
self.auto_pay = auto_pay
self.auto_use_coupon = auto_use_coupon
self.site_num = site_num
self.service_version = service_version
self.url_num = url_num
self.add_vul_num = add_vul_num
def validate(self):
pass
def to_map(self):
result = dict()
if self.period is not None:
result['Period'] = self.period
if self.period_unit is not None:
result['PeriodUnit'] = self.period_unit
if self.auto_pay is not None:
result['AutoPay'] = self.auto_pay
if self.auto_use_coupon is not None:
result['AutoUseCoupon'] = self.auto_use_coupon
if self.site_num is not None:
result['SiteNum'] = self.site_num
if self.service_version is not None:
result['ServiceVersion'] = self.service_version
if self.url_num is not None:
result['UrlNum'] = self.url_num
if self.add_vul_num is not None:
result['AddVulNum'] = self.add_vul_num
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Period') is not None:
self.period = m.get('Period')
if m.get('PeriodUnit') is not None:
self.period_unit = m.get('PeriodUnit')
if m.get('AutoPay') is not None:
self.auto_pay = m.get('AutoPay')
if m.get('AutoUseCoupon') is not None:
self.auto_use_coupon = m.get('AutoUseCoupon')
if m.get('SiteNum') is not None:
self.site_num = m.get('SiteNum')
if m.get('ServiceVersion') is not None:
self.service_version = m.get('ServiceVersion')
if m.get('UrlNum') is not None:
self.url_num = m.get('UrlNum')
if m.get('AddVulNum') is not None:
self.add_vul_num = m.get('AddVulNum')
return self
class CreateAvdsOrderResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
order_id: str = None,
):
self.request_id = request_id
self.order_id = order_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.order_id is not None:
result['OrderId'] = self.order_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('OrderId') is not None:
self.order_id = m.get('OrderId')
return self
class CreateAvdsOrderResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: CreateAvdsOrderResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = CreateAvdsOrderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateAvdsPublicOrderRequest(TeaModel):
def __init__(
self,
auto_pay: bool = None,
auto_use_coupon: bool = None,
name_time: str = None,
):
self.auto_pay = auto_pay
self.auto_use_coupon = auto_use_coupon
self.name_time = name_time
def validate(self):
pass
def to_map(self):
result = dict()
if self.auto_pay is not None:
result['AutoPay'] = self.auto_pay
if self.auto_use_coupon is not None:
result['AutoUseCoupon'] = self.auto_use_coupon
if self.name_time is not None:
result['NameTime'] = self.name_time
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AutoPay') is not None:
self.auto_pay = m.get('AutoPay')
if m.get('AutoUseCoupon') is not None:
self.auto_use_coupon = m.get('AutoUseCoupon')
if m.get('NameTime') is not None:
self.name_time = m.get('NameTime')
return self
class CreateAvdsPublicOrderResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
order_id: str = None,
):
self.request_id = request_id
self.order_id = order_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.order_id is not None:
result['OrderId'] = self.order_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('OrderId') is not None:
self.order_id = m.get('OrderId')
return self
class CreateAvdsPublicOrderResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: CreateAvdsPublicOrderResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = CreateAvdsPublicOrderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateOrganizationRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
name: str = None,
description: str = None,
domains: List[str] = None,
):
self.source_ip = source_ip
self.name = name
self.description = description
self.domains = domains
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.name is not None:
result['Name'] = self.name
if self.description is not None:
result['Description'] = self.description
if self.domains is not None:
result['Domains'] = self.domains
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Domains') is not None:
self.domains = m.get('Domains')
return self
class CreateOrganizationResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateOrganizationResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: CreateOrganizationResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = CreateOrganizationResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateSessionRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
asset: str = None,
ttl: int = None,
login_session: str = None,
):
self.source_ip = source_ip
self.asset = asset
self.ttl = ttl
self.login_session = login_session
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.asset is not None:
result['Asset'] = self.asset
if self.ttl is not None:
result['TTL'] = self.ttl
if self.login_session is not None:
result['LoginSession'] = self.login_session
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('LoginSession') is not None:
self.login_session = m.get('LoginSession')
return self
class CreateSessionResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateSessionResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: CreateSessionResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = CreateSessionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteAssetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
asset_ids: List[str] = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.asset_ids = asset_ids
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.asset_ids is not None:
result['AssetIds'] = self.asset_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('AssetIds') is not None:
self.asset_ids = m.get('AssetIds')
return self
class DeleteAssetsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteAssetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeleteAssetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeleteAssetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteOrganizationsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_ids: List[str] = None,
):
self.source_ip = source_ip
self.org_ids = org_ids
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_ids is not None:
result['OrgIds'] = self.org_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgIds') is not None:
self.org_ids = m.get('OrgIds')
return self
class DeleteOrganizationsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteOrganizationsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeleteOrganizationsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeleteOrganizationsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteOrgAttackSurfaceRecordsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
source: str = None,
org_id: int = None,
records: List[int] = None,
):
self.source_ip = source_ip
self.source = source
self.org_id = org_id
self.records = records
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.source is not None:
result['Source'] = self.source
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.records is not None:
result['Records'] = self.records
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Records') is not None:
self.records = m.get('Records')
return self
class DeleteOrgAttackSurfaceRecordsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteOrgAttackSurfaceRecordsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeleteOrgAttackSurfaceRecordsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeleteOrgAttackSurfaceRecordsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteSessionRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
session_id: int = None,
):
self.source_ip = source_ip
self.session_id = session_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.session_id is not None:
result['SessionId'] = self.session_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('SessionId') is not None:
self.session_id = m.get('SessionId')
return self
class DeleteSessionResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteSessionResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeleteSessionResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeleteSessionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteUserAttackSurfaceRecordsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
source: str = None,
records: List[int] = None,
):
self.source_ip = source_ip
self.source = source
self.records = records
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.source is not None:
result['Source'] = self.source
if self.records is not None:
result['Records'] = self.records
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('Records') is not None:
self.records = m.get('Records')
return self
class DeleteUserAttackSurfaceRecordsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteUserAttackSurfaceRecordsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeleteUserAttackSurfaceRecordsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeleteUserAttackSurfaceRecordsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeAllVulnerabilitiesRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
scan_id: str = None,
name: str = None,
search: str = None,
lang: str = None,
severity: int = None,
status: str = None,
begin_time: int = None,
end_time: int = None,
task_id: int = None,
category: str = None,
module: str = None,
vul_type: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.scan_id = scan_id
self.name = name
self.search = search
self.lang = lang
self.severity = severity
self.status = status
self.begin_time = begin_time
self.end_time = end_time
self.task_id = task_id
self.category = category
self.module = module
self.vul_type = vul_type
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.scan_id is not None:
result['ScanId'] = self.scan_id
if self.name is not None:
result['Name'] = self.name
if self.search is not None:
result['Search'] = self.search
if self.lang is not None:
result['Lang'] = self.lang
if self.severity is not None:
result['Severity'] = self.severity
if self.status is not None:
result['Status'] = self.status
if self.begin_time is not None:
result['BeginTime'] = self.begin_time
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.category is not None:
result['Category'] = self.category
if self.module is not None:
result['Module'] = self.module
if self.vul_type is not None:
result['VulType'] = self.vul_type
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('ScanId') is not None:
self.scan_id = m.get('ScanId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Lang') is not None:
self.lang = m.get('Lang')
if m.get('Severity') is not None:
self.severity = m.get('Severity')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('BeginTime') is not None:
self.begin_time = m.get('BeginTime')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Category') is not None:
self.category = m.get('Category')
if m.get('Module') is not None:
self.module = m.get('Module')
if m.get('VulType') is not None:
self.vul_type = m.get('VulType')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeAllVulnerabilitiesResponseBodyList(TeaModel):
def __init__(
self,
status: int = None,
severity: int = None,
last_discovered_at: int = None,
hostname: str = None,
name: str = None,
task_id: int = None,
vulnerability_type_des: str = None,
target: str = None,
id: int = None,
):
self.status = status
self.severity = severity
self.last_discovered_at = last_discovered_at
self.hostname = hostname
self.name = name
self.task_id = task_id
self.vulnerability_type_des = vulnerability_type_des
self.target = target
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.status is not None:
result['Status'] = self.status
if self.severity is not None:
result['Severity'] = self.severity
if self.last_discovered_at is not None:
result['LastDiscoveredAt'] = self.last_discovered_at
if self.hostname is not None:
result['Hostname'] = self.hostname
if self.name is not None:
result['Name'] = self.name
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.vulnerability_type_des is not None:
result['VulnerabilityTypeDes'] = self.vulnerability_type_des
if self.target is not None:
result['Target'] = self.target
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Severity') is not None:
self.severity = m.get('Severity')
if m.get('LastDiscoveredAt') is not None:
self.last_discovered_at = m.get('LastDiscoveredAt')
if m.get('Hostname') is not None:
self.hostname = m.get('Hostname')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('VulnerabilityTypeDes') is not None:
self.vulnerability_type_des = m.get('VulnerabilityTypeDes')
if m.get('Target') is not None:
self.target = m.get('Target')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeAllVulnerabilitiesResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
request_id: str = None,
page_size: int = None,
page_count: int = None,
current_page: int = None,
list: List[DescribeAllVulnerabilitiesResponseBodyList] = None,
count: int = None,
):
self.total_count = total_count
self.request_id = request_id
self.page_size = page_size
self.page_count = page_count
self.current_page = current_page
self.list = list
self.count = count
def validate(self):
if self.list:
for k in self.list:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_count is not None:
result['PageCount'] = self.page_count
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['List'] = []
if self.list is not None:
for k in self.list:
result['List'].append(k.to_map() if k else None)
if self.count is not None:
result['Count'] = self.count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageCount') is not None:
self.page_count = m.get('PageCount')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.list = []
if m.get('List') is not None:
for k in m.get('List'):
temp_model = DescribeAllVulnerabilitiesResponseBodyList()
self.list.append(temp_model.from_map(k))
if m.get('Count') is not None:
self.count = m.get('Count')
return self
class DescribeAllVulnerabilitiesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeAllVulnerabilitiesResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeAllVulnerabilitiesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeAssetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
status: str = None,
search: str = None,
asset_group_id: str = None,
source: str = None,
gmt_create_from: int = None,
gmt_create_to: int = None,
current_page: int = None,
page_size: int = None,
types: List[str] = None,
assets: List[str] = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.status = status
self.search = search
self.asset_group_id = asset_group_id
self.source = source
self.gmt_create_from = gmt_create_from
self.gmt_create_to = gmt_create_to
self.current_page = current_page
self.page_size = page_size
self.types = types
self.assets = assets
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.status is not None:
result['Status'] = self.status
if self.search is not None:
result['Search'] = self.search
if self.asset_group_id is not None:
result['AssetGroupId'] = self.asset_group_id
if self.source is not None:
result['Source'] = self.source
if self.gmt_create_from is not None:
result['GmtCreateFrom'] = self.gmt_create_from
if self.gmt_create_to is not None:
result['GmtCreateTo'] = self.gmt_create_to
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.types is not None:
result['Types'] = self.types
if self.assets is not None:
result['Assets'] = self.assets
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('AssetGroupId') is not None:
self.asset_group_id = m.get('AssetGroupId')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('GmtCreateFrom') is not None:
self.gmt_create_from = m.get('GmtCreateFrom')
if m.get('GmtCreateTo') is not None:
self.gmt_create_to = m.get('GmtCreateTo')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Types') is not None:
self.types = m.get('Types')
if m.get('Assets') is not None:
self.assets = m.get('Assets')
return self
class DescribeAssetsResponseBodyList(TeaModel):
def __init__(
self,
type: str = None,
last_scan_date: int = None,
expire_time: int = None,
asset_id: str = None,
gmt_create: int = None,
source: str = None,
asset: str = None,
):
self.type = type
self.last_scan_date = last_scan_date
self.expire_time = expire_time
self.asset_id = asset_id
self.gmt_create = gmt_create
self.source = source
self.asset = asset
def validate(self):
pass
def to_map(self):
result = dict()
if self.type is not None:
result['Type'] = self.type
if self.last_scan_date is not None:
result['LastScanDate'] = self.last_scan_date
if self.expire_time is not None:
result['ExpireTime'] = self.expire_time
if self.asset_id is not None:
result['AssetId'] = self.asset_id
if self.gmt_create is not None:
result['GmtCreate'] = self.gmt_create
if self.source is not None:
result['Source'] = self.source
if self.asset is not None:
result['Asset'] = self.asset
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('LastScanDate') is not None:
self.last_scan_date = m.get('LastScanDate')
if m.get('ExpireTime') is not None:
self.expire_time = m.get('ExpireTime')
if m.get('AssetId') is not None:
self.asset_id = m.get('AssetId')
if m.get('GmtCreate') is not None:
self.gmt_create = m.get('GmtCreate')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
return self
class DescribeAssetsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
request_id: str = None,
page_size: int = None,
page_count: int = None,
current_page: int = None,
list: List[DescribeAssetsResponseBodyList] = None,
count: int = None,
):
self.total_count = total_count
self.request_id = request_id
self.page_size = page_size
self.page_count = page_count
self.current_page = current_page
self.list = list
self.count = count
def validate(self):
if self.list:
for k in self.list:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_count is not None:
result['PageCount'] = self.page_count
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['List'] = []
if self.list is not None:
for k in self.list:
result['List'].append(k.to_map() if k else None)
if self.count is not None:
result['Count'] = self.count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageCount') is not None:
self.page_count = m.get('PageCount')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.list = []
if m.get('List') is not None:
for k in m.get('List'):
temp_model = DescribeAssetsResponseBodyList()
self.list.append(temp_model.from_map(k))
if m.get('Count') is not None:
self.count = m.get('Count')
return self
class DescribeAssetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeAssetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeAssetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeAttackSurfacesFacetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class DescribeAttackSurfacesFacetsResponseBody(TeaModel):
def __init__(
self,
domains: int = None,
hosts: int = None,
web_paths: int = None,
request_id: str = None,
dnsmap: int = None,
web_servers: int = None,
ports: int = None,
crawler_requests: int = None,
web_techs: int = None,
subdomains: int = None,
):
self.domains = domains
self.hosts = hosts
self.web_paths = web_paths
self.request_id = request_id
self.dnsmap = dnsmap
self.web_servers = web_servers
self.ports = ports
self.crawler_requests = crawler_requests
self.web_techs = web_techs
self.subdomains = subdomains
def validate(self):
pass
def to_map(self):
result = dict()
if self.domains is not None:
result['Domains'] = self.domains
if self.hosts is not None:
result['Hosts'] = self.hosts
if self.web_paths is not None:
result['WebPaths'] = self.web_paths
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.dnsmap is not None:
result['DNSMap'] = self.dnsmap
if self.web_servers is not None:
result['WebServers'] = self.web_servers
if self.ports is not None:
result['Ports'] = self.ports
if self.crawler_requests is not None:
result['CrawlerRequests'] = self.crawler_requests
if self.web_techs is not None:
result['WebTechs'] = self.web_techs
if self.subdomains is not None:
result['Subdomains'] = self.subdomains
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Domains') is not None:
self.domains = m.get('Domains')
if m.get('Hosts') is not None:
self.hosts = m.get('Hosts')
if m.get('WebPaths') is not None:
self.web_paths = m.get('WebPaths')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('DNSMap') is not None:
self.dnsmap = m.get('DNSMap')
if m.get('WebServers') is not None:
self.web_servers = m.get('WebServers')
if m.get('Ports') is not None:
self.ports = m.get('Ports')
if m.get('CrawlerRequests') is not None:
self.crawler_requests = m.get('CrawlerRequests')
if m.get('WebTechs') is not None:
self.web_techs = m.get('WebTechs')
if m.get('Subdomains') is not None:
self.subdomains = m.get('Subdomains')
return self
class DescribeAttackSurfacesFacetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeAttackSurfacesFacetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeAttackSurfacesFacetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeCrawlerRequestsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeCrawlerRequestsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
data: str = None,
url: str = None,
method: str = None,
updated_at: int = None,
cookies: str = None,
):
self.index = index
self.data = data
self.url = url
self.method = method
self.updated_at = updated_at
self.cookies = cookies
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.data is not None:
result['Data'] = self.data
if self.url is not None:
result['URL'] = self.url
if self.method is not None:
result['Method'] = self.method
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.cookies is not None:
result['Cookies'] = self.cookies
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Data') is not None:
self.data = m.get('Data')
if m.get('URL') is not None:
self.url = m.get('URL')
if m.get('Method') is not None:
self.method = m.get('Method')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Cookies') is not None:
self.cookies = m.get('Cookies')
return self
class DescribeCrawlerRequestsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeCrawlerRequestsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeCrawlerRequestsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeCrawlerRequestsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeCrawlerRequestsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeCrawlerRequestsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeDNSMapRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeDNSMapResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
type: str = None,
domain: str = None,
updated_at: int = None,
record: str = None,
):
self.index = index
self.type = type
self.domain = domain
self.updated_at = updated_at
self.record = record
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.type is not None:
result['Type'] = self.type
if self.domain is not None:
result['Domain'] = self.domain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.record is not None:
result['Record'] = self.record
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Record') is not None:
self.record = m.get('Record')
return self
class DescribeDNSMapResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeDNSMapResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeDNSMapResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeDNSMapResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeDNSMapResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeDNSMapResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeDomainAttackSurfacesFacetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
domain: str = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.domain = domain
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.domain is not None:
result['Domain'] = self.domain
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
return self
class DescribeDomainAttackSurfacesFacetsResponseBody(TeaModel):
def __init__(
self,
web_paths: int = None,
request_id: str = None,
web_servers: int = None,
crawler_requests: int = None,
web_techs: int = None,
):
self.web_paths = web_paths
self.request_id = request_id
self.web_servers = web_servers
self.crawler_requests = crawler_requests
self.web_techs = web_techs
def validate(self):
pass
def to_map(self):
result = dict()
if self.web_paths is not None:
result['WebPaths'] = self.web_paths
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.web_servers is not None:
result['WebServers'] = self.web_servers
if self.crawler_requests is not None:
result['CrawlerRequests'] = self.crawler_requests
if self.web_techs is not None:
result['WebTechs'] = self.web_techs
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('WebPaths') is not None:
self.web_paths = m.get('WebPaths')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('WebServers') is not None:
self.web_servers = m.get('WebServers')
if m.get('CrawlerRequests') is not None:
self.crawler_requests = m.get('CrawlerRequests')
if m.get('WebTechs') is not None:
self.web_techs = m.get('WebTechs')
return self
class DescribeDomainAttackSurfacesFacetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeDomainAttackSurfacesFacetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeDomainAttackSurfacesFacetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeDomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeDomainsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
domain: str = None,
updated_at: int = None,
):
self.index = index
self.domain = domain
self.updated_at = updated_at
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
return self
class DescribeDomainsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeDomainsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeDomainsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeDomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeDomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeDomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeHostAttackSurfacesFacetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
host: str = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.host = host
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.host is not None:
result['Host'] = self.host
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Host') is not None:
self.host = m.get('Host')
return self
class DescribeHostAttackSurfacesFacetsResponseBody(TeaModel):
def __init__(
self,
hosts: int = None,
web_paths: int = None,
request_id: str = None,
ports: int = None,
crawler_requests: int = None,
web_techs: int = None,
):
self.hosts = hosts
self.web_paths = web_paths
self.request_id = request_id
self.ports = ports
self.crawler_requests = crawler_requests
self.web_techs = web_techs
def validate(self):
pass
def to_map(self):
result = dict()
if self.hosts is not None:
result['Hosts'] = self.hosts
if self.web_paths is not None:
result['WebPaths'] = self.web_paths
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.ports is not None:
result['Ports'] = self.ports
if self.crawler_requests is not None:
result['CrawlerRequests'] = self.crawler_requests
if self.web_techs is not None:
result['WebTechs'] = self.web_techs
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Hosts') is not None:
self.hosts = m.get('Hosts')
if m.get('WebPaths') is not None:
self.web_paths = m.get('WebPaths')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Ports') is not None:
self.ports = m.get('Ports')
if m.get('CrawlerRequests') is not None:
self.crawler_requests = m.get('CrawlerRequests')
if m.get('WebTechs') is not None:
self.web_techs = m.get('WebTechs')
return self
class DescribeHostAttackSurfacesFacetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeHostAttackSurfacesFacetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeHostAttackSurfacesFacetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeHostsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeHostsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
os: str = None,
hostname: str = None,
updated_at: int = None,
ip: str = None,
is_up: str = None,
):
self.index = index
self.os = os
self.hostname = hostname
self.updated_at = updated_at
self.ip = ip
self.is_up = is_up
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.os is not None:
result['OS'] = self.os
if self.hostname is not None:
result['Hostname'] = self.hostname
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.ip is not None:
result['IP'] = self.ip
if self.is_up is not None:
result['IsUp'] = self.is_up
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('OS') is not None:
self.os = m.get('OS')
if m.get('Hostname') is not None:
self.hostname = m.get('Hostname')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('IP') is not None:
self.ip = m.get('IP')
if m.get('IsUp') is not None:
self.is_up = m.get('IsUp')
return self
class DescribeHostsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeHostsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeHostsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeHostsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeHostsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeHostsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeListSessionsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeListSessionsResponseBodySessions(TeaModel):
def __init__(
self,
ttl: int = None,
expired: int = None,
created_at: int = None,
ali_uid: int = None,
modified_at: int = None,
login_session: str = None,
session_id: int = None,
asset: str = None,
):
self.ttl = ttl
self.expired = expired
self.created_at = created_at
self.ali_uid = ali_uid
self.modified_at = modified_at
self.login_session = login_session
self.session_id = session_id
self.asset = asset
def validate(self):
pass
def to_map(self):
result = dict()
if self.ttl is not None:
result['TTL'] = self.ttl
if self.expired is not None:
result['Expired'] = self.expired
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.ali_uid is not None:
result['AliUid'] = self.ali_uid
if self.modified_at is not None:
result['ModifiedAt'] = self.modified_at
if self.login_session is not None:
result['LoginSession'] = self.login_session
if self.session_id is not None:
result['SessionId'] = self.session_id
if self.asset is not None:
result['Asset'] = self.asset
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('Expired') is not None:
self.expired = m.get('Expired')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('AliUid') is not None:
self.ali_uid = m.get('AliUid')
if m.get('ModifiedAt') is not None:
self.modified_at = m.get('ModifiedAt')
if m.get('LoginSession') is not None:
self.login_session = m.get('LoginSession')
if m.get('SessionId') is not None:
self.session_id = m.get('SessionId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
return self
class DescribeListSessionsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
sessions: List[DescribeListSessionsResponseBodySessions] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.sessions = sessions
def validate(self):
if self.sessions:
for k in self.sessions:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Sessions'] = []
if self.sessions is not None:
for k in self.sessions:
result['Sessions'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.sessions = []
if m.get('Sessions') is not None:
for k in m.get('Sessions'):
temp_model = DescribeListSessionsResponseBodySessions()
self.sessions.append(temp_model.from_map(k))
return self
class DescribeListSessionsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeListSessionsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeListSessionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeOrgAttackSurfaceDetailsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
record_id: int = None,
org_id: int = None,
source: str = None,
):
self.source_ip = source_ip
self.record_id = record_id
self.org_id = org_id
self.source = source
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.record_id is not None:
result['RecordId'] = self.record_id
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.source is not None:
result['Source'] = self.source
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('RecordId') is not None:
self.record_id = m.get('RecordId')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Source') is not None:
self.source = m.get('Source')
return self
class DescribeOrgAttackSurfaceDetailsResponseBody(TeaModel):
def __init__(
self,
last_scanned_at: int = None,
request_id: str = None,
first_scanned_at: int = None,
occurrences: int = None,
):
self.last_scanned_at = last_scanned_at
self.request_id = request_id
self.first_scanned_at = first_scanned_at
self.occurrences = occurrences
def validate(self):
pass
def to_map(self):
result = dict()
if self.last_scanned_at is not None:
result['LastScannedAt'] = self.last_scanned_at
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.first_scanned_at is not None:
result['FirstScannedAt'] = self.first_scanned_at
if self.occurrences is not None:
result['Occurrences'] = self.occurrences
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('LastScannedAt') is not None:
self.last_scanned_at = m.get('LastScannedAt')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('FirstScannedAt') is not None:
self.first_scanned_at = m.get('FirstScannedAt')
if m.get('Occurrences') is not None:
self.occurrences = m.get('Occurrences')
return self
class DescribeOrgAttackSurfaceDetailsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeOrgAttackSurfaceDetailsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeOrgAttackSurfaceDetailsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeOrgInfoRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
):
self.source_ip = source_ip
self.org_id = org_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
return self
class DescribeOrgInfoResponseBody(TeaModel):
def __init__(
self,
org_id: int = None,
description: str = None,
request_id: str = None,
created_at: int = None,
ali_uid: int = None,
name: str = None,
):
self.org_id = org_id
self.description = description
self.request_id = request_id
self.created_at = created_at
self.ali_uid = ali_uid
self.name = name
def validate(self):
pass
def to_map(self):
result = dict()
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.description is not None:
result['Description'] = self.description
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.ali_uid is not None:
result['AliUid'] = self.ali_uid
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('AliUid') is not None:
self.ali_uid = m.get('AliUid')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class DescribeOrgInfoResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeOrgInfoResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeOrgInfoResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribePortsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribePortsResponseBodyRecords(TeaModel):
def __init__(
self,
service: str = None,
index: int = None,
fingerprint: str = None,
version: str = None,
product: str = None,
protocol: str = None,
updated_at: int = None,
port: str = None,
ip: str = None,
):
self.service = service
self.index = index
self.fingerprint = fingerprint
self.version = version
self.product = product
self.protocol = protocol
self.updated_at = updated_at
self.port = port
self.ip = ip
def validate(self):
pass
def to_map(self):
result = dict()
if self.service is not None:
result['Service'] = self.service
if self.index is not None:
result['Index'] = self.index
if self.fingerprint is not None:
result['Fingerprint'] = self.fingerprint
if self.version is not None:
result['Version'] = self.version
if self.product is not None:
result['Product'] = self.product
if self.protocol is not None:
result['Protocol'] = self.protocol
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.port is not None:
result['Port'] = self.port
if self.ip is not None:
result['IP'] = self.ip
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Service') is not None:
self.service = m.get('Service')
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Fingerprint') is not None:
self.fingerprint = m.get('Fingerprint')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Product') is not None:
self.product = m.get('Product')
if m.get('Protocol') is not None:
self.protocol = m.get('Protocol')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Port') is not None:
self.port = m.get('Port')
if m.get('IP') is not None:
self.ip = m.get('IP')
return self
class DescribePortsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribePortsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribePortsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribePortsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribePortsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribePortsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeScanSessionsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
scan_id: str = None,
current_page: int = None,
page_size: int = None,
search: str = None,
status_list: List[str] = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.scan_id = scan_id
self.current_page = current_page
self.page_size = page_size
self.search = search
self.status_list = status_list
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.scan_id is not None:
result['ScanId'] = self.scan_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.search is not None:
result['Search'] = self.search
if self.status_list is not None:
result['StatusList'] = self.status_list
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('ScanId') is not None:
self.scan_id = m.get('ScanId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('StatusList') is not None:
self.status_list = m.get('StatusList')
return self
class DescribeScanSessionsResponseBodyList(TeaModel):
def __init__(
self,
report_status: str = None,
finished_at: int = None,
targets: List[str] = None,
created_at: int = None,
scan_id: str = None,
period: str = None,
trigger_type: str = None,
report_url: str = None,
job_status: str = None,
run_percent: float = None,
interval: int = None,
name: str = None,
task_id: int = None,
):
self.report_status = report_status
self.finished_at = finished_at
self.targets = targets
self.created_at = created_at
self.scan_id = scan_id
self.period = period
self.trigger_type = trigger_type
self.report_url = report_url
self.job_status = job_status
self.run_percent = run_percent
self.interval = interval
self.name = name
self.task_id = task_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.report_status is not None:
result['ReportStatus'] = self.report_status
if self.finished_at is not None:
result['FinishedAt'] = self.finished_at
if self.targets is not None:
result['Targets'] = self.targets
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.scan_id is not None:
result['ScanId'] = self.scan_id
if self.period is not None:
result['Period'] = self.period
if self.trigger_type is not None:
result['TriggerType'] = self.trigger_type
if self.report_url is not None:
result['ReportUrl'] = self.report_url
if self.job_status is not None:
result['JobStatus'] = self.job_status
if self.run_percent is not None:
result['RunPercent'] = self.run_percent
if self.interval is not None:
result['Interval'] = self.interval
if self.name is not None:
result['Name'] = self.name
if self.task_id is not None:
result['TaskId'] = self.task_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ReportStatus') is not None:
self.report_status = m.get('ReportStatus')
if m.get('FinishedAt') is not None:
self.finished_at = m.get('FinishedAt')
if m.get('Targets') is not None:
self.targets = m.get('Targets')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('ScanId') is not None:
self.scan_id = m.get('ScanId')
if m.get('Period') is not None:
self.period = m.get('Period')
if m.get('TriggerType') is not None:
self.trigger_type = m.get('TriggerType')
if m.get('ReportUrl') is not None:
self.report_url = m.get('ReportUrl')
if m.get('JobStatus') is not None:
self.job_status = m.get('JobStatus')
if m.get('RunPercent') is not None:
self.run_percent = m.get('RunPercent')
if m.get('Interval') is not None:
self.interval = m.get('Interval')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class DescribeScanSessionsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
request_id: str = None,
page_size: int = None,
page_count: int = None,
current_page: int = None,
list: List[DescribeScanSessionsResponseBodyList] = None,
count: int = None,
):
self.total_count = total_count
self.request_id = request_id
self.page_size = page_size
self.page_count = page_count
self.current_page = current_page
self.list = list
self.count = count
def validate(self):
if self.list:
for k in self.list:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_count is not None:
result['PageCount'] = self.page_count
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['List'] = []
if self.list is not None:
for k in self.list:
result['List'].append(k.to_map() if k else None)
if self.count is not None:
result['Count'] = self.count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageCount') is not None:
self.page_count = m.get('PageCount')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.list = []
if m.get('List') is not None:
for k in m.get('List'):
temp_model = DescribeScanSessionsResponseBodyList()
self.list.append(temp_model.from_map(k))
if m.get('Count') is not None:
self.count = m.get('Count')
return self
class DescribeScanSessionsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeScanSessionsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeScanSessionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeSessionRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
session_id: int = None,
):
self.source_ip = source_ip
self.session_id = session_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.session_id is not None:
result['SessionId'] = self.session_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('SessionId') is not None:
self.session_id = m.get('SessionId')
return self
class DescribeSessionResponseBodySession(TeaModel):
def __init__(
self,
ttl: int = None,
expired: int = None,
created_at: int = None,
ali_uid: int = None,
modified_at: int = None,
login_session: str = None,
session_id: int = None,
asset: str = None,
):
self.ttl = ttl
self.expired = expired
self.created_at = created_at
self.ali_uid = ali_uid
self.modified_at = modified_at
self.login_session = login_session
self.session_id = session_id
self.asset = asset
def validate(self):
pass
def to_map(self):
result = dict()
if self.ttl is not None:
result['TTL'] = self.ttl
if self.expired is not None:
result['Expired'] = self.expired
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.ali_uid is not None:
result['AliUid'] = self.ali_uid
if self.modified_at is not None:
result['ModifiedAt'] = self.modified_at
if self.login_session is not None:
result['LoginSession'] = self.login_session
if self.session_id is not None:
result['SessionId'] = self.session_id
if self.asset is not None:
result['Asset'] = self.asset
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('Expired') is not None:
self.expired = m.get('Expired')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('AliUid') is not None:
self.ali_uid = m.get('AliUid')
if m.get('ModifiedAt') is not None:
self.modified_at = m.get('ModifiedAt')
if m.get('LoginSession') is not None:
self.login_session = m.get('LoginSession')
if m.get('SessionId') is not None:
self.session_id = m.get('SessionId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
return self
class DescribeSessionResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
session: DescribeSessionResponseBodySession = None,
):
self.request_id = request_id
self.session = session
def validate(self):
if self.session:
self.session.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.session is not None:
result['Session'] = self.session.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Session') is not None:
temp_model = DescribeSessionResponseBodySession()
self.session = temp_model.from_map(m['Session'])
return self
class DescribeSessionResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeSessionResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeSessionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeSubdomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeSubdomainsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
domain: str = None,
updated_at: int = None,
root_domain: str = None,
):
self.index = index
self.domain = domain
self.updated_at = updated_at
self.root_domain = root_domain
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.root_domain is not None:
result['RootDomain'] = self.root_domain
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('RootDomain') is not None:
self.root_domain = m.get('RootDomain')
return self
class DescribeSubdomainsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeSubdomainsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeSubdomainsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeSubdomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeSubdomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeSubdomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeTaskBriefInfoRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
lang: str = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.lang = lang
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.lang is not None:
result['Lang'] = self.lang
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Lang') is not None:
self.lang = m.get('Lang')
return self
class DescribeTaskBriefInfoResponseBodyRisksFacets(TeaModel):
def __init__(
self,
medium: int = None,
low: int = None,
total: int = None,
high: int = None,
info: int = None,
):
self.medium = medium
self.low = low
self.total = total
self.high = high
self.info = info
def validate(self):
pass
def to_map(self):
result = dict()
if self.medium is not None:
result['Medium'] = self.medium
if self.low is not None:
result['Low'] = self.low
if self.total is not None:
result['Total'] = self.total
if self.high is not None:
result['High'] = self.high
if self.info is not None:
result['Info'] = self.info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Medium') is not None:
self.medium = m.get('Medium')
if m.get('Low') is not None:
self.low = m.get('Low')
if m.get('Total') is not None:
self.total = m.get('Total')
if m.get('High') is not None:
self.high = m.get('High')
if m.get('Info') is not None:
self.info = m.get('Info')
return self
class DescribeTaskBriefInfoResponseBodyBriefActionRunsFacet(TeaModel):
def __init__(
self,
completed: int = None,
total: int = None,
):
self.completed = completed
self.total = total
def validate(self):
pass
def to_map(self):
result = dict()
if self.completed is not None:
result['Completed'] = self.completed
if self.total is not None:
result['Total'] = self.total
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Completed') is not None:
self.completed = m.get('Completed')
if m.get('Total') is not None:
self.total = m.get('Total')
return self
class DescribeTaskBriefInfoResponseBodyBrief(TeaModel):
def __init__(
self,
finished_at: int = None,
progress: float = None,
description: str = None,
created_at: str = None,
action_runs_facet: DescribeTaskBriefInfoResponseBodyBriefActionRunsFacet = None,
):
self.finished_at = finished_at
self.progress = progress
self.description = description
self.created_at = created_at
self.action_runs_facet = action_runs_facet
def validate(self):
if self.action_runs_facet:
self.action_runs_facet.validate()
def to_map(self):
result = dict()
if self.finished_at is not None:
result['FinishedAt'] = self.finished_at
if self.progress is not None:
result['Progress'] = self.progress
if self.description is not None:
result['Description'] = self.description
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.action_runs_facet is not None:
result['ActionRunsFacet'] = self.action_runs_facet.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FinishedAt') is not None:
self.finished_at = m.get('FinishedAt')
if m.get('Progress') is not None:
self.progress = m.get('Progress')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('ActionRunsFacet') is not None:
temp_model = DescribeTaskBriefInfoResponseBodyBriefActionRunsFacet()
self.action_runs_facet = temp_model.from_map(m['ActionRunsFacet'])
return self
class DescribeTaskBriefInfoResponseBody(TeaModel):
def __init__(
self,
risks_facets: DescribeTaskBriefInfoResponseBodyRisksFacets = None,
request_id: str = None,
brief: DescribeTaskBriefInfoResponseBodyBrief = None,
):
self.risks_facets = risks_facets
self.request_id = request_id
self.brief = brief
def validate(self):
if self.risks_facets:
self.risks_facets.validate()
if self.brief:
self.brief.validate()
def to_map(self):
result = dict()
if self.risks_facets is not None:
result['RisksFacets'] = self.risks_facets.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.brief is not None:
result['Brief'] = self.brief.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RisksFacets') is not None:
temp_model = DescribeTaskBriefInfoResponseBodyRisksFacets()
self.risks_facets = temp_model.from_map(m['RisksFacets'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Brief') is not None:
temp_model = DescribeTaskBriefInfoResponseBodyBrief()
self.brief = temp_model.from_map(m['Brief'])
return self
class DescribeTaskBriefInfoResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeTaskBriefInfoResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeTaskBriefInfoResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeUserTagsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
lang: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.lang = lang
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.lang is not None:
result['Lang'] = self.lang
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('Lang') is not None:
self.lang = m.get('Lang')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeUserTagsResponseBodyList(TeaModel):
def __init__(
self,
asset_count: int = None,
tag_key: str = None,
):
self.asset_count = asset_count
self.tag_key = tag_key
def validate(self):
pass
def to_map(self):
result = dict()
if self.asset_count is not None:
result['AssetCount'] = self.asset_count
if self.tag_key is not None:
result['TagKey'] = self.tag_key
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AssetCount') is not None:
self.asset_count = m.get('AssetCount')
if m.get('TagKey') is not None:
self.tag_key = m.get('TagKey')
return self
class DescribeUserTagsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
request_id: str = None,
page_size: int = None,
page_count: int = None,
current_page: int = None,
list: List[DescribeUserTagsResponseBodyList] = None,
count: int = None,
):
self.total_count = total_count
self.request_id = request_id
self.page_size = page_size
self.page_count = page_count
self.current_page = current_page
self.list = list
self.count = count
def validate(self):
if self.list:
for k in self.list:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_count is not None:
result['PageCount'] = self.page_count
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['List'] = []
if self.list is not None:
for k in self.list:
result['List'].append(k.to_map() if k else None)
if self.count is not None:
result['Count'] = self.count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageCount') is not None:
self.page_count = m.get('PageCount')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.list = []
if m.get('List') is not None:
for k in m.get('List'):
temp_model = DescribeUserTagsResponseBodyList()
self.list.append(temp_model.from_map(k))
if m.get('Count') is not None:
self.count = m.get('Count')
return self
class DescribeUserTagsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeUserTagsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeUserTagsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeVulnerabilityRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
id: int = None,
lang: str = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.id = id
self.lang = lang
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.id is not None:
result['Id'] = self.id
if self.lang is not None:
result['Lang'] = self.lang
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Lang') is not None:
self.lang = m.get('Lang')
return self
class DescribeVulnerabilityResponseBodyVulnerability(TeaModel):
def __init__(
self,
severity: int = None,
status: int = None,
data: str = None,
args: str = None,
owasp: str = None,
impact: str = None,
cwe: str = None,
hostname: str = None,
reference: str = None,
wasc: str = None,
last_discovered_at: int = None,
description: str = None,
common_type: str = None,
solution: str = None,
name: str = None,
target: str = None,
poc: str = None,
id: int = None,
):
self.severity = severity
self.status = status
self.data = data
self.args = args
self.owasp = owasp
self.impact = impact
self.cwe = cwe
self.hostname = hostname
self.reference = reference
self.wasc = wasc
self.last_discovered_at = last_discovered_at
self.description = description
self.common_type = common_type
self.solution = solution
self.name = name
self.target = target
self.poc = poc
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.severity is not None:
result['Severity'] = self.severity
if self.status is not None:
result['Status'] = self.status
if self.data is not None:
result['Data'] = self.data
if self.args is not None:
result['Args'] = self.args
if self.owasp is not None:
result['Owasp'] = self.owasp
if self.impact is not None:
result['Impact'] = self.impact
if self.cwe is not None:
result['Cwe'] = self.cwe
if self.hostname is not None:
result['Hostname'] = self.hostname
if self.reference is not None:
result['Reference'] = self.reference
if self.wasc is not None:
result['Wasc'] = self.wasc
if self.last_discovered_at is not None:
result['LastDiscoveredAt'] = self.last_discovered_at
if self.description is not None:
result['Description'] = self.description
if self.common_type is not None:
result['CommonType'] = self.common_type
if self.solution is not None:
result['Solution'] = self.solution
if self.name is not None:
result['Name'] = self.name
if self.target is not None:
result['Target'] = self.target
if self.poc is not None:
result['Poc'] = self.poc
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Severity') is not None:
self.severity = m.get('Severity')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Data') is not None:
self.data = m.get('Data')
if m.get('Args') is not None:
self.args = m.get('Args')
if m.get('Owasp') is not None:
self.owasp = m.get('Owasp')
if m.get('Impact') is not None:
self.impact = m.get('Impact')
if m.get('Cwe') is not None:
self.cwe = m.get('Cwe')
if m.get('Hostname') is not None:
self.hostname = m.get('Hostname')
if m.get('Reference') is not None:
self.reference = m.get('Reference')
if m.get('Wasc') is not None:
self.wasc = m.get('Wasc')
if m.get('LastDiscoveredAt') is not None:
self.last_discovered_at = m.get('LastDiscoveredAt')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('CommonType') is not None:
self.common_type = m.get('CommonType')
if m.get('Solution') is not None:
self.solution = m.get('Solution')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Target') is not None:
self.target = m.get('Target')
if m.get('Poc') is not None:
self.poc = m.get('Poc')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeVulnerabilityResponseBody(TeaModel):
def __init__(
self,
impact: str = None,
args: str = None,
description: str = None,
request_id: str = None,
last_discovered_at: int = None,
poc: str = None,
reference: str = None,
hostname: str = None,
severity: int = None,
data: str = None,
vulnerability: DescribeVulnerabilityResponseBodyVulnerability = None,
success: bool = None,
name: str = None,
target: str = None,
id: int = None,
solution: str = None,
):
self.impact = impact
self.args = args
self.description = description
self.request_id = request_id
self.last_discovered_at = last_discovered_at
self.poc = poc
self.reference = reference
self.hostname = hostname
self.severity = severity
self.data = data
self.vulnerability = vulnerability
self.success = success
self.name = name
self.target = target
self.id = id
self.solution = solution
def validate(self):
if self.vulnerability:
self.vulnerability.validate()
def to_map(self):
result = dict()
if self.impact is not None:
result['Impact'] = self.impact
if self.args is not None:
result['Args'] = self.args
if self.description is not None:
result['Description'] = self.description
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.last_discovered_at is not None:
result['LastDiscoveredAt'] = self.last_discovered_at
if self.poc is not None:
result['Poc'] = self.poc
if self.reference is not None:
result['Reference'] = self.reference
if self.hostname is not None:
result['Hostname'] = self.hostname
if self.severity is not None:
result['Severity'] = self.severity
if self.data is not None:
result['Data'] = self.data
if self.vulnerability is not None:
result['Vulnerability'] = self.vulnerability.to_map()
if self.success is not None:
result['Success'] = self.success
if self.name is not None:
result['Name'] = self.name
if self.target is not None:
result['Target'] = self.target
if self.id is not None:
result['Id'] = self.id
if self.solution is not None:
result['Solution'] = self.solution
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Impact') is not None:
self.impact = m.get('Impact')
if m.get('Args') is not None:
self.args = m.get('Args')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('LastDiscoveredAt') is not None:
self.last_discovered_at = m.get('LastDiscoveredAt')
if m.get('Poc') is not None:
self.poc = m.get('Poc')
if m.get('Reference') is not None:
self.reference = m.get('Reference')
if m.get('Hostname') is not None:
self.hostname = m.get('Hostname')
if m.get('Severity') is not None:
self.severity = m.get('Severity')
if m.get('Data') is not None:
self.data = m.get('Data')
if m.get('Vulnerability') is not None:
temp_model = DescribeVulnerabilityResponseBodyVulnerability()
self.vulnerability = temp_model.from_map(m['Vulnerability'])
if m.get('Success') is not None:
self.success = m.get('Success')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Target') is not None:
self.target = m.get('Target')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Solution') is not None:
self.solution = m.get('Solution')
return self
class DescribeVulnerabilityResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeVulnerabilityResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeVulnerabilityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeWebPathsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeWebPathsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
extension: str = None,
site: str = None,
path: str = None,
updated_at: int = None,
):
self.index = index
self.extension = extension
self.site = site
self.path = path
self.updated_at = updated_at
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.extension is not None:
result['Extension'] = self.extension
if self.site is not None:
result['Site'] = self.site
if self.path is not None:
result['Path'] = self.path
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Extension') is not None:
self.extension = m.get('Extension')
if m.get('Site') is not None:
self.site = m.get('Site')
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
return self
class DescribeWebPathsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeWebPathsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeWebPathsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeWebPathsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeWebPathsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeWebPathsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeWebServersRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeWebServersResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
host: str = None,
scheme: str = None,
updated_at: int = None,
port: str = None,
):
self.index = index
self.host = host
self.scheme = scheme
self.updated_at = updated_at
self.port = port
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.host is not None:
result['Host'] = self.host
if self.scheme is not None:
result['Scheme'] = self.scheme
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.port is not None:
result['Port'] = self.port
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Host') is not None:
self.host = m.get('Host')
if m.get('Scheme') is not None:
self.scheme = m.get('Scheme')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Port') is not None:
self.port = m.get('Port')
return self
class DescribeWebServersResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeWebServersResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeWebServersResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeWebServersResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeWebServersResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeWebServersResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeWebTechsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
task_id: int = None,
asset: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.task_id = task_id
self.asset = asset
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class DescribeWebTechsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
powered_by: str = None,
version: str = None,
url: str = None,
server: str = None,
updated_at: int = None,
title: str = None,
name: str = None,
):
self.index = index
self.powered_by = powered_by
self.version = version
self.url = url
self.server = server
self.updated_at = updated_at
self.title = title
self.name = name
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.powered_by is not None:
result['PoweredBy'] = self.powered_by
if self.version is not None:
result['Version'] = self.version
if self.url is not None:
result['URL'] = self.url
if self.server is not None:
result['Server'] = self.server
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.title is not None:
result['Title'] = self.title
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('PoweredBy') is not None:
self.powered_by = m.get('PoweredBy')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('URL') is not None:
self.url = m.get('URL')
if m.get('Server') is not None:
self.server = m.get('Server')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Title') is not None:
self.title = m.get('Title')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class DescribeWebTechsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
total: int = None,
records: List[DescribeWebTechsResponseBodyRecords] = None,
):
self.request_id = request_id
self.total = total
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total is not None:
result['Total'] = self.total
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Total') is not None:
self.total = m.get('Total')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = DescribeWebTechsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class DescribeWebTechsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DescribeWebTechsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DescribeWebTechsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class EditSessionRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
session_id: int = None,
asset: str = None,
ttl: int = None,
login_session: str = None,
):
self.source_ip = source_ip
self.session_id = session_id
self.asset = asset
self.ttl = ttl
self.login_session = login_session
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.session_id is not None:
result['SessionId'] = self.session_id
if self.asset is not None:
result['Asset'] = self.asset
if self.ttl is not None:
result['TTL'] = self.ttl
if self.login_session is not None:
result['LoginSession'] = self.login_session
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('SessionId') is not None:
self.session_id = m.get('SessionId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('LoginSession') is not None:
self.login_session = m.get('LoginSession')
return self
class EditSessionResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class EditSessionResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: EditSessionResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = EditSessionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GenerateVulReportRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
resource_owner_id: int = None,
format: str = None,
lang: str = None,
task_ids: List[str] = None,
):
self.source_ip = source_ip
self.resource_owner_id = resource_owner_id
self.format = format
self.lang = lang
self.task_ids = task_ids
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.resource_owner_id is not None:
result['ResourceOwnerId'] = self.resource_owner_id
if self.format is not None:
result['format'] = self.format
if self.lang is not None:
result['lang'] = self.lang
if self.task_ids is not None:
result['TaskIds'] = self.task_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('ResourceOwnerId') is not None:
self.resource_owner_id = m.get('ResourceOwnerId')
if m.get('format') is not None:
self.format = m.get('format')
if m.get('lang') is not None:
self.lang = m.get('lang')
if m.get('TaskIds') is not None:
self.task_ids = m.get('TaskIds')
return self
class GenerateVulReportResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GenerateVulReportResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GenerateVulReportResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GenerateVulReportResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgDNSMapRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.org_id = org_id
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgDNSMapResponseBodyRecords(TeaModel):
def __init__(
self,
type: str = None,
index: int = None,
domain: str = None,
org_id: int = None,
subdomain: str = None,
updated_at: int = None,
record: str = None,
id: int = None,
):
self.type = type
self.index = index
self.domain = domain
self.org_id = org_id
self.subdomain = subdomain
self.updated_at = updated_at
self.record = record
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.type is not None:
result['Type'] = self.type
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.subdomain is not None:
result['Subdomain'] = self.subdomain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.record is not None:
result['Record'] = self.record
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Subdomain') is not None:
self.subdomain = m.get('Subdomain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Record') is not None:
self.record = m.get('Record')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgDNSMapResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgDNSMapResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgDNSMapResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgDNSMapResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgDNSMapResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgDNSMapResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgDomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
org_id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.org_id = org_id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgDomainsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
domain: str = None,
org_id: int = None,
updated_at: int = None,
id: int = None,
):
self.index = index
self.domain = domain
self.org_id = org_id
self.updated_at = updated_at
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgDomainsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgDomainsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgDomainsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgDomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgDomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgDomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgHostsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
org_id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.org_id = org_id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgHostsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
state: str = None,
org_id: int = None,
os: str = None,
hostname: str = None,
updated_at: int = None,
ip: str = None,
id: int = None,
):
self.index = index
self.state = state
self.org_id = org_id
self.os = os
self.hostname = hostname
self.updated_at = updated_at
self.ip = ip
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.state is not None:
result['State'] = self.state
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.os is not None:
result['OS'] = self.os
if self.hostname is not None:
result['Hostname'] = self.hostname
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.ip is not None:
result['IP'] = self.ip
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('State') is not None:
self.state = m.get('State')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('OS') is not None:
self.os = m.get('OS')
if m.get('Hostname') is not None:
self.hostname = m.get('Hostname')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('IP') is not None:
self.ip = m.get('IP')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgHostsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgHostsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgHostsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgHostsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgHostsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgHostsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgPortsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
org_id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.org_id = org_id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgPortsResponseBodyRecords(TeaModel):
def __init__(
self,
service: str = None,
index: int = None,
fingerprint: str = None,
version: str = None,
product: str = None,
protocol: str = None,
org_id: int = None,
updated_at: int = None,
port: int = None,
ip: str = None,
id: int = None,
):
self.service = service
self.index = index
self.fingerprint = fingerprint
self.version = version
self.product = product
self.protocol = protocol
self.org_id = org_id
self.updated_at = updated_at
self.port = port
self.ip = ip
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.service is not None:
result['Service'] = self.service
if self.index is not None:
result['Index'] = self.index
if self.fingerprint is not None:
result['Fingerprint'] = self.fingerprint
if self.version is not None:
result['Version'] = self.version
if self.product is not None:
result['Product'] = self.product
if self.protocol is not None:
result['Protocol'] = self.protocol
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.port is not None:
result['Port'] = self.port
if self.ip is not None:
result['IP'] = self.ip
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Service') is not None:
self.service = m.get('Service')
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Fingerprint') is not None:
self.fingerprint = m.get('Fingerprint')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Product') is not None:
self.product = m.get('Product')
if m.get('Protocol') is not None:
self.protocol = m.get('Protocol')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Port') is not None:
self.port = m.get('Port')
if m.get('IP') is not None:
self.ip = m.get('IP')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgPortsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgPortsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgPortsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgPortsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgPortsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgPortsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgRiskyAssetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
):
self.source_ip = source_ip
self.org_id = org_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
return self
class ListOrgRiskyAssetsResponseBodyAssets(TeaModel):
def __init__(
self,
type: str = None,
asset: str = None,
count: int = None,
):
self.type = type
self.asset = asset
self.count = count
def validate(self):
pass
def to_map(self):
result = dict()
if self.type is not None:
result['Type'] = self.type
if self.asset is not None:
result['Asset'] = self.asset
if self.count is not None:
result['Count'] = self.count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('Count') is not None:
self.count = m.get('Count')
return self
class ListOrgRiskyAssetsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
assets: List[ListOrgRiskyAssetsResponseBodyAssets] = None,
total: int = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.assets = assets
self.total = total
def validate(self):
if self.assets:
for k in self.assets:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Assets'] = []
if self.assets is not None:
for k in self.assets:
result['Assets'].append(k.to_map() if k else None)
if self.total is not None:
result['Total'] = self.total
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.assets = []
if m.get('Assets') is not None:
for k in m.get('Assets'):
temp_model = ListOrgRiskyAssetsResponseBodyAssets()
self.assets.append(temp_model.from_map(k))
if m.get('Total') is not None:
self.total = m.get('Total')
return self
class ListOrgRiskyAssetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgRiskyAssetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgRiskyAssetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgSubdomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
org_id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.org_id = org_id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgSubdomainsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
domain: str = None,
org_id: int = None,
subdomain: str = None,
updated_at: int = None,
id: int = None,
):
self.index = index
self.domain = domain
self.org_id = org_id
self.subdomain = subdomain
self.updated_at = updated_at
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.subdomain is not None:
result['Subdomain'] = self.subdomain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Subdomain') is not None:
self.subdomain = m.get('Subdomain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgSubdomainsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgSubdomainsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgSubdomainsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgSubdomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgSubdomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgSubdomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgVulFacetsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
org_id: int = None,
asset: str = None,
current_page: int = None,
lang: str = None,
page_size: int = None,
):
self.source_ip = source_ip
self.org_id = org_id
self.asset = asset
self.current_page = current_page
self.lang = lang
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.asset is not None:
result['Asset'] = self.asset
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.lang is not None:
result['Lang'] = self.lang
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Asset') is not None:
self.asset = m.get('Asset')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('Lang') is not None:
self.lang = m.get('Lang')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgVulFacetsResponseBodyVuls(TeaModel):
def __init__(
self,
index: int = None,
severity: str = None,
module_id: int = None,
classification: str = None,
name: str = None,
count: int = None,
):
self.index = index
self.severity = severity
self.module_id = module_id
self.classification = classification
self.name = name
self.count = count
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.severity is not None:
result['Severity'] = self.severity
if self.module_id is not None:
result['ModuleID'] = self.module_id
if self.classification is not None:
result['Classification'] = self.classification
if self.name is not None:
result['Name'] = self.name
if self.count is not None:
result['Count'] = self.count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Severity') is not None:
self.severity = m.get('Severity')
if m.get('ModuleID') is not None:
self.module_id = m.get('ModuleID')
if m.get('Classification') is not None:
self.classification = m.get('Classification')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Count') is not None:
self.count = m.get('Count')
return self
class ListOrgVulFacetsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
total: int = None,
vuls: List[ListOrgVulFacetsResponseBodyVuls] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.total = total
self.vuls = vuls
def validate(self):
if self.vuls:
for k in self.vuls:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.total is not None:
result['Total'] = self.total
result['Vuls'] = []
if self.vuls is not None:
for k in self.vuls:
result['Vuls'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('Total') is not None:
self.total = m.get('Total')
self.vuls = []
if m.get('Vuls') is not None:
for k in m.get('Vuls'):
temp_model = ListOrgVulFacetsResponseBodyVuls()
self.vuls.append(temp_model.from_map(k))
return self
class ListOrgVulFacetsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgVulFacetsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgVulFacetsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgWebPathsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
org_id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.org_id = org_id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgWebPathsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
org_id: int = None,
site: str = None,
path: str = None,
updated_at: int = None,
id: int = None,
):
self.index = index
self.org_id = org_id
self.site = site
self.path = path
self.updated_at = updated_at
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.site is not None:
result['Site'] = self.site
if self.path is not None:
result['Path'] = self.path
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('Site') is not None:
self.site = m.get('Site')
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgWebPathsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgWebPathsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgWebPathsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgWebPathsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgWebPathsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgWebPathsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListOrgWebTechsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
org_id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.org_id = org_id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListOrgWebTechsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
powered_by: str = None,
version: str = None,
org_id: int = None,
url: str = None,
server: str = None,
updated_at: int = None,
title: str = None,
name: str = None,
id: int = None,
):
self.index = index
self.powered_by = powered_by
self.version = version
self.org_id = org_id
self.url = url
self.server = server
self.updated_at = updated_at
self.title = title
self.name = name
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.powered_by is not None:
result['PoweredBy'] = self.powered_by
if self.version is not None:
result['Version'] = self.version
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.url is not None:
result['URL'] = self.url
if self.server is not None:
result['Server'] = self.server
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.title is not None:
result['Title'] = self.title
if self.name is not None:
result['Name'] = self.name
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('PoweredBy') is not None:
self.powered_by = m.get('PoweredBy')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('URL') is not None:
self.url = m.get('URL')
if m.get('Server') is not None:
self.server = m.get('Server')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Title') is not None:
self.title = m.get('Title')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListOrgWebTechsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListOrgWebTechsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListOrgWebTechsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListOrgWebTechsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListOrgWebTechsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListOrgWebTechsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserDNSMapRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserDNSMapResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
type: str = None,
domain: str = None,
subdomain: str = None,
updated_at: int = None,
record: str = None,
id: int = None,
):
self.index = index
self.type = type
self.domain = domain
self.subdomain = subdomain
self.updated_at = updated_at
self.record = record
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.type is not None:
result['Type'] = self.type
if self.domain is not None:
result['Domain'] = self.domain
if self.subdomain is not None:
result['Subdomain'] = self.subdomain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.record is not None:
result['Record'] = self.record
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Subdomain') is not None:
self.subdomain = m.get('Subdomain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Record') is not None:
self.record = m.get('Record')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserDNSMapResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserDNSMapResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserDNSMapResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserDNSMapResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserDNSMapResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserDNSMapResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserDNSMapHistoriesRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
id: int = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.id = id
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.id is not None:
result['Id'] = self.id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserDNSMapHistoriesResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
type: str = None,
domain: str = None,
created_at: int = None,
subdomain: str = None,
record: str = None,
task_id: int = None,
):
self.index = index
self.type = type
self.domain = domain
self.created_at = created_at
self.subdomain = subdomain
self.record = record
self.task_id = task_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.type is not None:
result['Type'] = self.type
if self.domain is not None:
result['Domain'] = self.domain
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.subdomain is not None:
result['Subdomain'] = self.subdomain
if self.record is not None:
result['Record'] = self.record
if self.task_id is not None:
result['TaskId'] = self.task_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('Subdomain') is not None:
self.subdomain = m.get('Subdomain')
if m.get('Record') is not None:
self.record = m.get('Record')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class ListUserDNSMapHistoriesResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserDNSMapHistoriesResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserDNSMapHistoriesResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserDNSMapHistoriesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserDNSMapHistoriesResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserDNSMapHistoriesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserDomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserDomainsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
domain: str = None,
updated_at: int = None,
id: int = None,
):
self.index = index
self.domain = domain
self.updated_at = updated_at
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserDomainsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserDomainsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserDomainsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserDomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserDomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserDomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserHostsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserHostsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
os: str = None,
state: str = None,
hostname: str = None,
updated_at: int = None,
ip: str = None,
id: int = None,
):
self.index = index
self.os = os
self.state = state
self.hostname = hostname
self.updated_at = updated_at
self.ip = ip
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.os is not None:
result['OS'] = self.os
if self.state is not None:
result['State'] = self.state
if self.hostname is not None:
result['Hostname'] = self.hostname
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.ip is not None:
result['IP'] = self.ip
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('OS') is not None:
self.os = m.get('OS')
if m.get('State') is not None:
self.state = m.get('State')
if m.get('Hostname') is not None:
self.hostname = m.get('Hostname')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('IP') is not None:
self.ip = m.get('IP')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserHostsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserHostsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserHostsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserHostsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserHostsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserHostsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserOrganizationsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserOrganizationsResponseBodyOrganizations(TeaModel):
def __init__(
self,
index: int = None,
description: str = None,
org_id: int = None,
created_at: int = None,
updated_at: int = None,
name: str = None,
):
self.index = index
self.description = description
self.org_id = org_id
self.created_at = created_at
self.updated_at = updated_at
self.name = name
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.description is not None:
result['Description'] = self.description
if self.org_id is not None:
result['OrgId'] = self.org_id
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ListUserOrganizationsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
organizations: List[ListUserOrganizationsResponseBodyOrganizations] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.organizations = organizations
def validate(self):
if self.organizations:
for k in self.organizations:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Organizations'] = []
if self.organizations is not None:
for k in self.organizations:
result['Organizations'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.organizations = []
if m.get('Organizations') is not None:
for k in m.get('Organizations'):
temp_model = ListUserOrganizationsResponseBodyOrganizations()
self.organizations.append(temp_model.from_map(k))
return self
class ListUserOrganizationsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserOrganizationsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserOrganizationsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserPortsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserPortsResponseBodyRecords(TeaModel):
def __init__(
self,
service: str = None,
index: int = None,
fingerprint: str = None,
version: str = None,
product: str = None,
protocol: str = None,
updated_at: int = None,
port: int = None,
ip: str = None,
id: int = None,
):
self.service = service
self.index = index
self.fingerprint = fingerprint
self.version = version
self.product = product
self.protocol = protocol
self.updated_at = updated_at
self.port = port
self.ip = ip
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.service is not None:
result['Service'] = self.service
if self.index is not None:
result['Index'] = self.index
if self.fingerprint is not None:
result['Fingerprint'] = self.fingerprint
if self.version is not None:
result['Version'] = self.version
if self.product is not None:
result['Product'] = self.product
if self.protocol is not None:
result['Protocol'] = self.protocol
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.port is not None:
result['Port'] = self.port
if self.ip is not None:
result['IP'] = self.ip
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Service') is not None:
self.service = m.get('Service')
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Fingerprint') is not None:
self.fingerprint = m.get('Fingerprint')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Product') is not None:
self.product = m.get('Product')
if m.get('Protocol') is not None:
self.protocol = m.get('Protocol')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Port') is not None:
self.port = m.get('Port')
if m.get('IP') is not None:
self.ip = m.get('IP')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserPortsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserPortsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserPortsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserPortsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserPortsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserPortsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserSubdomainsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserSubdomainsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
domain: str = None,
subdomain: str = None,
updated_at: int = None,
id: int = None,
):
self.index = index
self.domain = domain
self.subdomain = subdomain
self.updated_at = updated_at
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.domain is not None:
result['Domain'] = self.domain
if self.subdomain is not None:
result['Subdomain'] = self.subdomain
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Subdomain') is not None:
self.subdomain = m.get('Subdomain')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserSubdomainsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserSubdomainsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserSubdomainsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserSubdomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserSubdomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserSubdomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserWebPathsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserWebPathsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
site: str = None,
path: str = None,
updated_at: int = None,
id: int = None,
):
self.index = index
self.site = site
self.path = path
self.updated_at = updated_at
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.site is not None:
result['Site'] = self.site
if self.path is not None:
result['Path'] = self.path
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('Site') is not None:
self.site = m.get('Site')
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserWebPathsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserWebPathsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserWebPathsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserWebPathsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserWebPathsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserWebPathsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserWebTechsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
search: str = None,
current_page: int = None,
page_size: int = None,
):
self.source_ip = source_ip
self.search = search
self.current_page = current_page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.search is not None:
result['Search'] = self.search
if self.current_page is not None:
result['CurrentPage'] = self.current_page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUserWebTechsResponseBodyRecords(TeaModel):
def __init__(
self,
index: int = None,
powered_by: str = None,
version: str = None,
url: str = None,
server: str = None,
updated_at: int = None,
title: str = None,
name: str = None,
id: int = None,
):
self.index = index
self.powered_by = powered_by
self.version = version
self.url = url
self.server = server
self.updated_at = updated_at
self.title = title
self.name = name
self.id = id
def validate(self):
pass
def to_map(self):
result = dict()
if self.index is not None:
result['Index'] = self.index
if self.powered_by is not None:
result['PoweredBy'] = self.powered_by
if self.version is not None:
result['Version'] = self.version
if self.url is not None:
result['URL'] = self.url
if self.server is not None:
result['Server'] = self.server
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.title is not None:
result['Title'] = self.title
if self.name is not None:
result['Name'] = self.name
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Index') is not None:
self.index = m.get('Index')
if m.get('PoweredBy') is not None:
self.powered_by = m.get('PoweredBy')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('URL') is not None:
self.url = m.get('URL')
if m.get('Server') is not None:
self.server = m.get('Server')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Title') is not None:
self.title = m.get('Title')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ListUserWebTechsResponseBody(TeaModel):
def __init__(
self,
total_count: int = None,
page_size: int = None,
request_id: str = None,
current_page: int = None,
records: List[ListUserWebTechsResponseBodyRecords] = None,
):
self.total_count = total_count
self.page_size = page_size
self.request_id = request_id
self.current_page = current_page
self.records = records
def validate(self):
if self.records:
for k in self.records:
if k:
k.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.current_page is not None:
result['CurrentPage'] = self.current_page
result['Records'] = []
if self.records is not None:
for k in self.records:
result['Records'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('CurrentPage') is not None:
self.current_page = m.get('CurrentPage')
self.records = []
if m.get('Records') is not None:
for k in m.get('Records'):
temp_model = ListUserWebTechsResponseBodyRecords()
self.records.append(temp_model.from_map(k))
return self
class ListUserWebTechsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ListUserWebTechsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ListUserWebTechsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ModifyOrganizationRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
name: str = None,
description: str = None,
org_id: int = None,
):
self.source_ip = source_ip
self.name = name
self.description = description
self.org_id = org_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.name is not None:
result['Name'] = self.name
if self.description is not None:
result['Description'] = self.description
if self.org_id is not None:
result['OrgId'] = self.org_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('OrgId') is not None:
self.org_id = m.get('OrgId')
return self
class ModifyOrganizationResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ModifyOrganizationResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: ModifyOrganizationResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = ModifyOrganizationResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TagAssetsByRecordsRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
source: str = None,
asset_type: str = None,
tags: List[str] = None,
record_ids: List[int] = None,
):
self.source_ip = source_ip
self.source = source
self.asset_type = asset_type
self.tags = tags
self.record_ids = record_ids
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.source is not None:
result['Source'] = self.source
if self.asset_type is not None:
result['AssetType'] = self.asset_type
if self.tags is not None:
result['Tags'] = self.tags
if self.record_ids is not None:
result['RecordIds'] = self.record_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('AssetType') is not None:
self.asset_type = m.get('AssetType')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
if m.get('RecordIds') is not None:
self.record_ids = m.get('RecordIds')
return self
class TagAssetsByRecordsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TagAssetsByRecordsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: TagAssetsByRecordsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = TagAssetsByRecordsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TagAssetsBySearchRequest(TeaModel):
def __init__(
self,
source_ip: str = None,
source: str = None,
search: str = None,
asset_type: str = None,
tags: List[str] = None,
):
self.source_ip = source_ip
self.source = source
self.search = search
self.asset_type = asset_type
self.tags = tags
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_ip is not None:
result['SourceIp'] = self.source_ip
if self.source is not None:
result['Source'] = self.source
if self.search is not None:
result['Search'] = self.search
if self.asset_type is not None:
result['AssetType'] = self.asset_type
if self.tags is not None:
result['Tags'] = self.tags
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SourceIp') is not None:
self.source_ip = m.get('SourceIp')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('AssetType') is not None:
self.asset_type = m.get('AssetType')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
return self
class TagAssetsBySearchResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TagAssetsBySearchResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: TagAssetsBySearchResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = TagAssetsBySearchResponseBody()
self.body = temp_model.from_map(m['body'])
return self