gcore 0.1.0a2__py3-none-any.whl → 0.3.0__py3-none-any.whl

gcore/types/waap/domain_list_params.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal, TypedDict
+
+from .waap_domain_status import WaapDomainStatus
+
+__all__ = ["DomainListParams"]
+
+
+class DomainListParams(TypedDict, total=False):
+    ids: Iterable[int]
+    """Filter domains based on their IDs"""
+
+    limit: int
+    """Number of items to return"""
+
+    name: str
+    """Filter domains based on the domain name. Supports '\\**' as a wildcard character"""
+
+    offset: int
+    """Number of items to skip"""
+
+    ordering: Literal["id", "name", "status", "created_at", "-id", "-name", "-status", "-created_at"]
+    """Sort the response by given field."""
+
+    status: WaapDomainStatus
+    """The different statuses a domain can have"""

gcore/types/waap/domain_list_rule_sets_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from .waap_rule_set import WaapRuleSet
+
+__all__ = ["DomainListRuleSetsResponse"]
+
+DomainListRuleSetsResponse: TypeAlias = List[WaapRuleSet]

gcore/types/waap/domain_update_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["DomainUpdateParams"]
+
+
+class DomainUpdateParams(TypedDict, total=False):
+    status: Literal["active", "monitor"]
+    """Domain statuses that can be used when updating a domain"""

gcore/types/waap/domains/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .insight_list_params import InsightListParams as InsightListParams
+from .api_path_list_params import APIPathListParams as APIPathListParams
+from .api_path_get_response import APIPathGetResponse as APIPathGetResponse
+from .setting_update_params import SettingUpdateParams as SettingUpdateParams
+from .api_path_create_params import APIPathCreateParams as APIPathCreateParams
+from .api_path_list_response import APIPathListResponse as APIPathListResponse
+from .api_path_update_params import APIPathUpdateParams as APIPathUpdateParams
+from .insight_replace_params import InsightReplaceParams as InsightReplaceParams
+from .custom_rule_list_params import CustomRuleListParams as CustomRuleListParams
+from .api_path_create_response import APIPathCreateResponse as APIPathCreateResponse
+from .advanced_rule_list_params import AdvancedRuleListParams as AdvancedRuleListParams
+from .custom_rule_create_params import CustomRuleCreateParams as CustomRuleCreateParams
+from .custom_rule_update_params import CustomRuleUpdateParams as CustomRuleUpdateParams
+from .firewall_rule_list_params import FirewallRuleListParams as FirewallRuleListParams
+from .advanced_rule_create_params import AdvancedRuleCreateParams as AdvancedRuleCreateParams
+from .advanced_rule_update_params import AdvancedRuleUpdateParams as AdvancedRuleUpdateParams
+from .firewall_rule_create_params import FirewallRuleCreateParams as FirewallRuleCreateParams
+from .firewall_rule_update_params import FirewallRuleUpdateParams as FirewallRuleUpdateParams
+from .insight_silence_list_params import InsightSilenceListParams as InsightSilenceListParams
+from .api_path_group_list_response import APIPathGroupListResponse as APIPathGroupListResponse
+from .insight_silence_create_params import InsightSilenceCreateParams as InsightSilenceCreateParams
+from .insight_silence_update_params import InsightSilenceUpdateParams as InsightSilenceUpdateParams
+from .analytics_list_ddos_info_params import AnalyticsListDDOSInfoParams as AnalyticsListDDOSInfoParams
+from .analytics_list_ddos_attacks_params import AnalyticsListDDOSAttacksParams as AnalyticsListDDOSAttacksParams
+from .custom_rule_delete_multiple_params import CustomRuleDeleteMultipleParams as CustomRuleDeleteMultipleParams
+from .analytics_list_event_traffic_params import AnalyticsListEventTrafficParams as AnalyticsListEventTrafficParams
+from .api_discovery_get_settings_response import APIDiscoveryGetSettingsResponse as APIDiscoveryGetSettingsResponse
+from .api_discovery_scan_openapi_response import APIDiscoveryScanOpenAPIResponse as APIDiscoveryScanOpenAPIResponse
+from .api_discovery_upload_openapi_params import APIDiscoveryUploadOpenAPIParams as APIDiscoveryUploadOpenAPIParams
+from .api_discovery_update_settings_params import APIDiscoveryUpdateSettingsParams as APIDiscoveryUpdateSettingsParams
+from .firewall_rule_delete_multiple_params import FirewallRuleDeleteMultipleParams as FirewallRuleDeleteMultipleParams
+from .analytics_get_event_statistics_params import (
+    AnalyticsGetEventStatisticsParams as AnalyticsGetEventStatisticsParams,
+)
+from .analytics_list_event_traffic_response import (
+    AnalyticsListEventTrafficResponse as AnalyticsListEventTrafficResponse,
+)
+from .api_discovery_upload_openapi_response import (
+    APIDiscoveryUploadOpenAPIResponse as APIDiscoveryUploadOpenAPIResponse,
+)
+from .api_discovery_update_settings_response import (
+    APIDiscoveryUpdateSettingsResponse as APIDiscoveryUpdateSettingsResponse,
+)

gcore/types/waap/domains/advanced_rule_create_params.py

@@ -0,0 +1,80 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["AdvancedRuleCreateParams", "Action", "ActionBlock", "ActionTag"]
+
+
+class AdvancedRuleCreateParams(TypedDict, total=False):
+    action: Required[Action]
+    """The action that a WAAP rule takes when triggered"""
+
+    enabled: Required[bool]
+    """Whether or not the rule is enabled"""
+
+    name: Required[str]
+    """The name assigned to the rule"""
+
+    source: Required[str]
+    """A CEL syntax expression that contains the rule's conditions.
+
+    Allowed objects are: request, whois, session, response, tags,
+    `user_defined_tags`, `user_agent`, `client_data`. More info can be found here:
+    https://gcore.com/docs/waap/waap-rules/advanced-rules
+    """
+
+    description: Optional[str]
+    """The description assigned to the rule"""
+
+    phase: Optional[Literal["access", "header_filter", "body_filter"]]
+    """The WAAP request/response phase for applying the rule.
+
+    Default is "access". The "access" phase is responsible for modifying the request
+    before it is sent to the origin server. The "`header_filter`" phase is
+    responsible for modifying the HTTP headers of a response before they are sent
+    back to the client. The "`body_filter`" phase is responsible for modifying the
+    body of a response before it is sent back to the client.
+    """
+
+
+class ActionBlock(TypedDict, total=False):
+    action_duration: Optional[str]
+    """How long a rule's block action will apply to subsequent requests.
+
+    Can be specified in seconds or by using a numeral followed by 's', 'm', 'h', or
+    'd' to represent time format (seconds, minutes, hours, or days)
+    """
+
+    status_code: Optional[Literal[403, 405, 418, 429]]
+    """Designates the HTTP status code to deliver when a request is blocked."""
+
+
+class ActionTag(TypedDict, total=False):
+    tags: Required[List[str]]
+    """The list of user defined tags to tag the request with"""
+
+
+class Action(TypedDict, total=False):
+    allow: Optional[object]
+    """The WAAP allowed the request"""
+
+    block: Optional[ActionBlock]
+    """
+    WAAP block action behavior could be configured with response status code and
+    action duration.
+    """
+
+    captcha: Optional[object]
+    """The WAAP presented the user with a captcha"""
+
+    handshake: Optional[object]
+    """The WAAP performed automatic browser validation"""
+
+    monitor: Optional[object]
+    """The WAAP monitored the request but took no action"""
+
+    tag: Optional[ActionTag]
+    """WAAP tag action gets a list of tags to tag the request scope with"""

gcore/types/waap/domains/advanced_rule_list_params.py

@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+from ..waap_rule_action_type import WaapRuleActionType
+
+__all__ = ["AdvancedRuleListParams"]
+
+
+class AdvancedRuleListParams(TypedDict, total=False):
+    action: WaapRuleActionType
+    """Filter to refine results by specific actions"""
+
+    description: str
+    """Filter rules based on their description. Supports '\\**' as a wildcard character."""
+
+    enabled: bool
+    """Filter rules based on their active status"""
+
+    limit: int
+    """Number of items to return"""
+
+    name: str
+    """Filter rules based on their name. Supports '\\**' as a wildcard character."""
+
+    offset: int
+    """Number of items to skip"""
+
+    ordering: Optional[
+        Literal[
+            "id",
+            "name",
+            "description",
+            "enabled",
+            "action",
+            "phase",
+            "-id",
+            "-name",
+            "-description",
+            "-enabled",
+            "-action",
+            "-phase",
+        ]
+    ]
+    """Determine the field to order results by"""
+
+    phase: Literal["access", "header_filter", "body_filter"]
+    """
+    Filter rules based on the WAAP request/response phase for applying the rule. The
+    "access" phase is responsible for modifying the request before it is sent to the
+    origin server. The "`header_filter`" phase is responsible for modifying the HTTP
+    headers of a response before they are sent back to the client. The
+    "`body_filter`" phase is responsible for modifying the body of a response before
+    it is sent back to the client.
+    """

gcore/types/waap/domains/advanced_rule_update_params.py

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["AdvancedRuleUpdateParams", "Action", "ActionBlock", "ActionTag"]
+
+
+class AdvancedRuleUpdateParams(TypedDict, total=False):
+    domain_id: Required[int]
+    """The domain ID"""
+
+    action: Optional[Action]
+    """The action that a WAAP rule takes when triggered"""
+
+    description: Optional[str]
+    """The description assigned to the rule"""
+
+    enabled: Optional[bool]
+    """Whether or not the rule is enabled"""
+
+    name: Optional[str]
+    """The name assigned to the rule"""
+
+    phase: Optional[Literal["access", "header_filter", "body_filter"]]
+    """
+    The WAAP request/response phase for applying the rule. The "access" phase is
+    responsible for modifying the request before it is sent to the origin server.
+    The "`header_filter`" phase is responsible for modifying the HTTP headers of a
+    response before they are sent back to the client. The "`body_filter`" phase is
+    responsible for modifying the body of a response before it is sent back to the
+    client.
+    """
+
+    source: Optional[str]
+    """A CEL syntax expression that contains the rule's conditions.
+
+    Allowed objects are: request, whois, session, response, tags,
+    `user_defined_tags`, `user_agent`, `client_data`. More info can be found here:
+    https://gcore.com/docs/waap/waap-rules/advanced-rules
+    """
+
+
+class ActionBlock(TypedDict, total=False):
+    action_duration: Optional[str]
+    """How long a rule's block action will apply to subsequent requests.
+
+    Can be specified in seconds or by using a numeral followed by 's', 'm', 'h', or
+    'd' to represent time format (seconds, minutes, hours, or days)
+    """
+
+    status_code: Optional[Literal[403, 405, 418, 429]]
+    """Designates the HTTP status code to deliver when a request is blocked."""
+
+
+class ActionTag(TypedDict, total=False):
+    tags: Required[List[str]]
+    """The list of user defined tags to tag the request with"""
+
+
+class Action(TypedDict, total=False):
+    allow: Optional[object]
+    """The WAAP allowed the request"""
+
+    block: Optional[ActionBlock]
+    """
+    WAAP block action behavior could be configured with response status code and
+    action duration.
+    """
+
+    captcha: Optional[object]
+    """The WAAP presented the user with a captcha"""
+
+    handshake: Optional[object]
+    """The WAAP performed automatic browser validation"""
+
+    monitor: Optional[object]
+    """The WAAP monitored the request but took no action"""
+
+    tag: Optional[ActionTag]
+    """WAAP tag action gets a list of tags to tag the request scope with"""

gcore/types/waap/domains/analytics/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .request_list_params import RequestListParams as RequestListParams

gcore/types/waap/domains/analytics/request_list_params.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from ....._utils import PropertyInfo
+from ...waap_traffic_type import WaapTrafficType
+
+__all__ = ["RequestListParams"]
+
+
+class RequestListParams(TypedDict, total=False):
+    start: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """Filter traffic starting from a specified date in ISO 8601 format"""
+
+    actions: List[Literal["allow", "block", "captcha", "handshake"]]
+    """Filter the response by actions."""
+
+    countries: List[str]
+    """Filter the response by country codes in ISO 3166-1 alpha-2 format."""
+
+    end: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Filter traffic up to a specified end date in ISO 8601 format.
+
+    If not provided, defaults to the current date and time.
+    """
+
+    ip: str
+    """Filter the response by IP."""
+
+    limit: int
+    """Number of items to return"""
+
+    offset: int
+    """Number of items to skip"""
+
+    ordering: str
+    """Sort the response by given field."""
+
+    reference_id: str
+    """Filter the response by reference ID."""
+
+    security_rule_name: str
+    """Filter the response by security rule name."""
+
+    status_code: int
+    """Filter the response by response code."""
+
+    traffic_types: List[WaapTrafficType]
+    """Filter the response by traffic types."""

gcore/types/waap/domains/analytics_get_event_statistics_params.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+
+__all__ = ["AnalyticsGetEventStatisticsParams"]
+
+
+class AnalyticsGetEventStatisticsParams(TypedDict, total=False):
+    start: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """Filter traffic starting from a specified date in ISO 8601 format"""
+
+    action: Optional[List[Literal["block", "captcha", "handshake", "monitor"]]]
+    """A list of action names to filter on."""
+
+    end: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Filter traffic up to a specified end date in ISO 8601 format.
+
+    If not provided, defaults to the current date and time.
+    """
+
+    ip: Optional[List[str]]
+    """A list of IPs to filter event statistics."""
+
+    reference_id: Optional[List[str]]
+    """A list of reference IDs to filter event statistics."""
+
+    result: Optional[List[Literal["passed", "blocked", "monitored", "allowed"]]]
+    """A list of results to filter event statistics."""

gcore/types/waap/domains/analytics_list_ddos_attacks_params.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+
+__all__ = ["AnalyticsListDDOSAttacksParams"]
+
+
+class AnalyticsListDDOSAttacksParams(TypedDict, total=False):
+    end_time: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter attacks up to a specified end date in ISO 8601 format"""
+
+    limit: int
+    """Number of items to return"""
+
+    offset: int
+    """Number of items to skip"""
+
+    ordering: Literal["start_time", "-start_time", "end_time", "-end_time"]
+    """Sort the response by given field."""
+
+    start_time: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Filter attacks starting from a specified date in ISO 8601 format"""

gcore/types/waap/domains/analytics_list_ddos_info_params.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+
+__all__ = ["AnalyticsListDDOSInfoParams"]
+
+
+class AnalyticsListDDOSInfoParams(TypedDict, total=False):
+    group_by: Required[Literal["URL", "User-Agent", "IP"]]
+    """The identity of the requests to group by"""
+
+    start: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """Filter traffic starting from a specified date in ISO 8601 format"""
+
+    end: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Filter traffic up to a specified end date in ISO 8601 format.
+
+    If not provided, defaults to the current date and time.
+    """
+
+    limit: int
+    """Number of items to return"""
+
+    offset: int
+    """Number of items to skip"""

gcore/types/waap/domains/analytics_list_event_traffic_params.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+from typing_extensions import Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ..waap_resolution import WaapResolution
+
+__all__ = ["AnalyticsListEventTrafficParams"]
+
+
+class AnalyticsListEventTrafficParams(TypedDict, total=False):
+    resolution: Required[WaapResolution]
+    """Specifies the granularity of the result data."""
+
+    start: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """Filter traffic starting from a specified date in ISO 8601 format"""
+
+    end: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Filter traffic up to a specified end date in ISO 8601 format.
+
+    If not provided, defaults to the current date and time.
+    """

gcore/types/waap/domains/analytics_list_event_traffic_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from ..waap_traffic_metrics import WaapTrafficMetrics
+
+__all__ = ["AnalyticsListEventTrafficResponse"]
+
+AnalyticsListEventTrafficResponse: TypeAlias = List[WaapTrafficMetrics]

gcore/types/waap/domains/api_discovery/__init__.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .scan_result_list_params import ScanResultListParams as ScanResultListParams
+from .scan_result_get_response import ScanResultGetResponse as ScanResultGetResponse
+from .scan_result_list_response import ScanResultListResponse as ScanResultListResponse

gcore/types/waap/domains/api_discovery/scan_result_get_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ....._models import BaseModel
+
+__all__ = ["ScanResultGetResponse"]
+
+
+class ScanResultGetResponse(BaseModel):
+    id: str
+    """The scan ID"""
+
+    end_time: Optional[datetime] = None
+    """The date and time the scan ended"""
+
+    message: str
+    """The message associated with the scan"""
+
+    start_time: datetime
+    """The date and time the scan started"""
+
+    status: Literal["SUCCESS", "FAILURE", "IN_PROGRESS"]
+    """The different statuses a task result can have"""
+
+    type: Literal["TRAFFIC_SCAN", "API_DESCRIPTION_FILE_SCAN"]
+    """The different types of scans that can be performed"""

gcore/types/waap/domains/api_discovery/scan_result_list_params.py

@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ScanResultListParams"]
+
+
+class ScanResultListParams(TypedDict, total=False):
+    limit: int
+    """Number of items to return"""
+
+    message: Optional[str]
+    """Filter by the message of the scan. Supports '\\**' as a wildcard character"""
+
+    offset: int
+    """Number of items to skip"""
+
+    ordering: Literal[
+        "id",
+        "type",
+        "start_time",
+        "end_time",
+        "status",
+        "message",
+        "-id",
+        "-type",
+        "-start_time",
+        "-end_time",
+        "-status",
+        "-message",
+    ]
+    """Sort the response by given field."""
+
+    status: Optional[Literal["SUCCESS", "FAILURE", "IN_PROGRESS"]]
+    """The different statuses a task result can have"""
+
+    type: Optional[Literal["TRAFFIC_SCAN", "API_DESCRIPTION_FILE_SCAN"]]
+    """The different types of scans that can be performed"""

gcore/types/waap/domains/api_discovery/scan_result_list_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ....._models import BaseModel
+
+__all__ = ["ScanResultListResponse"]
+
+
+class ScanResultListResponse(BaseModel):
+    id: str
+    """The scan ID"""
+
+    end_time: Optional[datetime] = None
+    """The date and time the scan ended"""
+
+    message: str
+    """The message associated with the scan"""
+
+    start_time: datetime
+    """The date and time the scan started"""
+
+    status: Literal["SUCCESS", "FAILURE", "IN_PROGRESS"]
+    """The different statuses a task result can have"""
+
+    type: Literal["TRAFFIC_SCAN", "API_DESCRIPTION_FILE_SCAN"]
+    """The different types of scans that can be performed"""

gcore/types/waap/domains/api_discovery_get_settings_response.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from pydantic import Field as FieldInfo
+
+from ...._models import BaseModel
+
+__all__ = ["APIDiscoveryGetSettingsResponse"]
+
+
+class APIDiscoveryGetSettingsResponse(BaseModel):
+    description_file_location: Optional[str] = FieldInfo(alias="descriptionFileLocation", default=None)
+    """The URL of the API description file.
+
+    This will be periodically scanned if `descriptionFileScanEnabled` is enabled.
+    Supported formats are YAML and JSON, and it must adhere to OpenAPI versions 2,
+    3, or 3.1.
+    """
+
+    description_file_scan_enabled: Optional[bool] = FieldInfo(alias="descriptionFileScanEnabled", default=None)
+    """Indicates if periodic scan of the description file is enabled"""
+
+    description_file_scan_interval_hours: Optional[int] = FieldInfo(
+        alias="descriptionFileScanIntervalHours", default=None
+    )
+    """The interval in hours for scanning the description file"""
+
+    traffic_scan_enabled: Optional[bool] = FieldInfo(alias="trafficScanEnabled", default=None)
+    """Indicates if traffic scan is enabled.
+
+    Traffic scan is used to discover undocumented APIs
+    """
+
+    traffic_scan_interval_hours: Optional[int] = FieldInfo(alias="trafficScanIntervalHours", default=None)
+    """The interval in hours for scanning the traffic"""