gcore 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

gcore/types/waap/waap_captcha_page_data_param.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["WaapCaptchaPageDataParam"]
+
+
+class WaapCaptchaPageDataParam(TypedDict, total=False):
+    enabled: Required[bool]
+    """Indicates whether the custom custom page is active or inactive"""
+
+    error: str
+    """Error message"""
+
+    header: str
+    """The text to display in the header of the custom page"""
+
+    logo: str
+    """
+    Supported image types are JPEG, PNG and JPG, size is limited to width 450px,
+    height 130px. This should be a base 64 encoding of the full HTML img tag
+    compatible image, with the header included.
+    """
+
+    text: str
+    """The text to display in the body of the custom page"""
+
+    title: str
+    """The text to display in the title of the custom page"""

gcore/types/waap/waap_common_tag.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["WaapCommonTag"]
+
+
+class WaapCommonTag(BaseModel):
+    description: str
+    """Tag description information"""
+
+    display_name: str
+    """The tag's display name"""
+
+    tag: str
+    """Tag name"""

gcore/types/waap/waap_cookie_disabled_page_data.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["WaapCookieDisabledPageData"]
+
+
+class WaapCookieDisabledPageData(BaseModel):
+    enabled: bool
+    """Indicates whether the custom custom page is active or inactive"""
+
+    header: Optional[str] = None
+    """The text to display in the header of the custom page"""
+
+    text: Optional[str] = None
+    """The text to display in the body of the custom page"""

gcore/types/waap/waap_cookie_disabled_page_data_param.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["WaapCookieDisabledPageDataParam"]
+
+
+class WaapCookieDisabledPageDataParam(TypedDict, total=False):
+    enabled: Required[bool]
+    """Indicates whether the custom custom page is active or inactive"""
+
+    header: str
+    """The text to display in the header of the custom page"""
+
+    text: str
+    """The text to display in the body of the custom page"""

gcore/types/waap/waap_count_statistics.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union
+
+from ..._models import BaseModel
+
+__all__ = ["WaapCountStatistics"]
+
+
+class WaapCountStatistics(BaseModel):
+    action: List[List[Union[str, int]]]
+    """A collection of event counts per action.
+
+    The first item is the action's abbreviation/full action name, and the second
+    item is the number of events
+    """
+
+    country: List[List[Union[str, int]]]
+    """A collection of event counts per country of origin.
+
+    The first item is the country's ISO 3166-1 alpha-2, and the second item is the
+    number of events
+    """
+
+    org: List[List[Union[str, int]]]
+    """A collection of event counts per organization that owns the event's client IP.
+
+    The first item is the organization's name, and the second item is the number of
+    events
+    """
+
+    rule_name: List[List[Union[str, int]]]
+    """A collection of event counts per rule that triggered the event.
+
+    The first item is the rule's name, and the second item is the number of events
+    """

gcore/types/waap/waap_custom_page_preview.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["WaapCustomPagePreview"]
+
+
+class WaapCustomPagePreview(BaseModel):
+    html: str
+    """HTML content of the custom page"""

gcore/types/waap/waap_custom_page_set.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+from .waap_block_page_data import WaapBlockPageData
+from .waap_captcha_page_data import WaapCaptchaPageData
+from .waap_handshake_page_data import WaapHandshakePageData
+from .waap_block_csrf_page_data import WaapBlockCsrfPageData
+from .waap_cookie_disabled_page_data import WaapCookieDisabledPageData
+from .waap_javascript_disabled_page_data import WaapJavascriptDisabledPageData
+
+__all__ = ["WaapCustomPageSet"]
+
+
+class WaapCustomPageSet(BaseModel):
+    id: int
+    """The ID of the custom page set"""
+
+    name: str
+    """Name of the custom page set"""
+
+    block: Optional[WaapBlockPageData] = None
+
+    block_csrf: Optional[WaapBlockCsrfPageData] = None
+
+    captcha: Optional[WaapCaptchaPageData] = None
+
+    cookie_disabled: Optional[WaapCookieDisabledPageData] = None
+
+    domains: Optional[List[int]] = None
+    """List of domain IDs that are associated with this page set"""
+
+    handshake: Optional[WaapHandshakePageData] = None
+
+    javascript_disabled: Optional[WaapJavascriptDisabledPageData] = None

gcore/types/waap/waap_custom_rule.py

@@ -0,0 +1,373 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = [
+    "WaapCustomRule",
+    "Action",
+    "ActionBlock",
+    "ActionTag",
+    "Condition",
+    "ConditionContentType",
+    "ConditionCountry",
+    "ConditionFileExtension",
+    "ConditionHeader",
+    "ConditionHeaderExists",
+    "ConditionHTTPMethod",
+    "ConditionIP",
+    "ConditionIPRange",
+    "ConditionOrganization",
+    "ConditionOwnerTypes",
+    "ConditionRequestRate",
+    "ConditionResponseHeader",
+    "ConditionResponseHeaderExists",
+    "ConditionSessionRequestCount",
+    "ConditionTags",
+    "ConditionURL",
+    "ConditionUserAgent",
+    "ConditionUserDefinedTags",
+]
+
+
+class ActionBlock(BaseModel):
+    action_duration: Optional[str] = None
+    """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]] = None
+    """Designates the HTTP status code to deliver when a request is blocked."""
+
+
+class ActionTag(BaseModel):
+    tags: List[str]
+    """The list of user defined tags to tag the request with"""
+
+
+class Action(BaseModel):
+    allow: Optional[object] = None
+    """The WAAP allowed the request"""
+
+    block: Optional[ActionBlock] = None
+    """
+    WAAP block action behavior could be configured with response status code and
+    action duration.
+    """
+
+    captcha: Optional[object] = None
+    """The WAAP presented the user with a captcha"""
+
+    handshake: Optional[object] = None
+    """The WAAP performed automatic browser validation"""
+
+    monitor: Optional[object] = None
+    """The WAAP monitored the request but took no action"""
+
+    tag: Optional[ActionTag] = None
+    """WAAP tag action gets a list of tags to tag the request scope with"""
+
+
+class ConditionContentType(BaseModel):
+    content_type: List[str]
+    """The list of content types to match against"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionCountry(BaseModel):
+    country_code: List[str]
+    """
+    A list of ISO 3166-1 alpha-2 formatted strings representing the countries to
+    match against
+    """
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionFileExtension(BaseModel):
+    file_extension: List[str]
+    """The list of file extensions to match against"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionHeader(BaseModel):
+    header: str
+    """The request header name"""
+
+    value: str
+    """The request header value"""
+
+    match_type: Optional[Literal["Exact", "Contains"]] = None
+    """The type of matching condition for header and value."""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionHeaderExists(BaseModel):
+    header: str
+    """The request header name"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionHTTPMethod(BaseModel):
+    http_method: Literal["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"]
+    """HTTP methods and descriptions Methods from the following RFCs are all observed:
+
+    - RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+    - RFC 5789: PATCH Method for HTTP
+    """
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionIP(BaseModel):
+    ip_address: str
+    """A single IPv4 or IPv6 address"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionIPRange(BaseModel):
+    lower_bound: str
+    """The lower bound IPv4 or IPv6 address to match against"""
+
+    upper_bound: str
+    """The upper bound IPv4 or IPv6 address to match against"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionOrganization(BaseModel):
+    organization: str
+    """The organization to match against"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionOwnerTypes(BaseModel):
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+    owner_types: Optional[
+        List[
+            Literal[
+                "COMMERCIAL",
+                "EDUCATIONAL",
+                "GOVERNMENT",
+                "HOSTING_SERVICES",
+                "ISP",
+                "MOBILE_NETWORK",
+                "NETWORK",
+                "RESERVED",
+            ]
+        ]
+    ] = None
+    """
+    Match the type of organization that owns the IP address making an incoming
+    request
+    """
+
+
+class ConditionRequestRate(BaseModel):
+    path_pattern: str
+    """A regular expression matching the URL path of the incoming request"""
+
+    requests: int
+    """
+    The number of incoming requests over the given time that can trigger a request
+    rate condition
+    """
+
+    time: int
+    """
+    The number of seconds that the WAAP measures incoming requests over before
+    triggering a request rate condition
+    """
+
+    http_methods: Optional[
+        List[Literal["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"]]
+    ] = None
+    """Possible HTTP request methods that can trigger a request rate condition"""
+
+    ips: Optional[List[str]] = None
+    """A list of source IPs that can trigger a request rate condition"""
+
+    user_defined_tag: Optional[str] = None
+    """
+    A user-defined tag that can be included in incoming requests and used to trigger
+    a request rate condition
+    """
+
+
+class ConditionResponseHeader(BaseModel):
+    header: str
+    """The response header name"""
+
+    value: str
+    """The response header value"""
+
+    match_type: Optional[Literal["Exact", "Contains"]] = None
+    """The type of matching condition for header and value."""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionResponseHeaderExists(BaseModel):
+    header: str
+    """The response header name"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionSessionRequestCount(BaseModel):
+    request_count: int
+    """The number of dynamic requests in the session"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionTags(BaseModel):
+    tags: List[str]
+    """A list of tags to match against the request tags"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionURL(BaseModel):
+    url: str
+    """The pattern to match against the request URL.
+
+    If `match_type` is `Regex` the value must be a valid regular expression that
+    does not use lookahead or lookbehind constructs
+    """
+
+    match_type: Optional[Literal["Exact", "Contains", "Regex"]] = None
+    """The type of matching condition."""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionUserAgent(BaseModel):
+    user_agent: str
+    """The user agent value to match"""
+
+    match_type: Optional[Literal["Exact", "Contains"]] = None
+    """The type of matching condition."""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class ConditionUserDefinedTags(BaseModel):
+    tags: List[str]
+    """A list of user-defined tags to match against the request tags"""
+
+    negation: Optional[bool] = None
+    """Whether or not to apply a boolean NOT operation to the rule's condition"""
+
+
+class Condition(BaseModel):
+    content_type: Optional[ConditionContentType] = None
+    """Match the requested Content-Type"""
+
+    country: Optional[ConditionCountry] = None
+    """Match the country that the request originated from"""
+
+    file_extension: Optional[ConditionFileExtension] = None
+    """Match the incoming file extension"""
+
+    header: Optional[ConditionHeader] = None
+    """Match an incoming request header"""
+
+    header_exists: Optional[ConditionHeaderExists] = None
+    """Match when an incoming request header is present"""
+
+    http_method: Optional[ConditionHTTPMethod] = None
+    """Match the incoming HTTP method"""
+
+    ip: Optional[ConditionIP] = None
+    """Match the incoming request against a single IP address"""
+
+    ip_range: Optional[ConditionIPRange] = None
+    """Match the incoming request against an IP range"""
+
+    organization: Optional[ConditionOrganization] = None
+    """
+    Match the organization the request originated from, as determined by a WHOIS
+    lookup of the requesting IP
+    """
+
+    owner_types: Optional[ConditionOwnerTypes] = None
+    """
+    Match the type of organization that owns the IP address making an incoming
+    request
+    """
+
+    request_rate: Optional[ConditionRequestRate] = None
+    """Match the rate at which requests come in that match certain conditions"""
+
+    response_header: Optional[ConditionResponseHeader] = None
+    """Match a response header"""
+
+    response_header_exists: Optional[ConditionResponseHeaderExists] = None
+    """Match when a response header is present"""
+
+    session_request_count: Optional[ConditionSessionRequestCount] = None
+    """Match the number of dynamic page requests made in a WAAP session"""
+
+    tags: Optional[ConditionTags] = None
+    """Matches requests based on specified tags"""
+
+    url: Optional[ConditionURL] = None
+    """Match the incoming request URL"""
+
+    user_agent: Optional[ConditionUserAgent] = None
+    """Match the user agent making the request"""
+
+    user_defined_tags: Optional[ConditionUserDefinedTags] = None
+    """Matches requests based on user-defined tags"""
+
+
+class WaapCustomRule(BaseModel):
+    id: int
+    """The unique identifier for the rule"""
+
+    action: Action
+    """The action that a WAAP rule takes when triggered"""
+
+    conditions: List[Condition]
+    """The conditions required for the WAAP engine to trigger the rule.
+
+    Rules may have between 1 and 5 conditions. All conditions must pass for the rule
+    to trigger
+    """
+
+    enabled: bool
+    """Whether or not the rule is enabled"""
+
+    name: str
+    """The name assigned to the rule"""
+
+    description: Optional[str] = None
+    """The description assigned to the rule"""

gcore/types/waap/waap_customer_rule_state.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["WaapCustomerRuleState"]
+
+WaapCustomerRuleState: TypeAlias = Literal["enable", "disable"]

gcore/types/waap/waap_ddos_attack.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from ..._models import BaseModel
+
+__all__ = ["WaapDDOSAttack"]
+
+
+class WaapDDOSAttack(BaseModel):
+    end_time: Optional[datetime] = None
+    """End time of DDoS attack"""
+
+    start_time: Optional[datetime] = None
+    """Start time of DDoS attack"""

gcore/types/waap/waap_ddos_info.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["WaapDDOSInfo"]
+
+
+class WaapDDOSInfo(BaseModel):
+    count: int
+    """The number of requests made"""
+
+    identity: str
+    """The value for the grouped by type"""
+
+    type: Literal["URL", "IP", "User-Agent"]

gcore/types/waap/{waap_api_urls.py → waap_domain_api_settings.py}

@@ -4,12 +4,19 @@ from typing import List, Optional
 
 from ..._models import BaseModel
 
-__all__ = ["WaapAPIURLs"]
+__all__ = ["WaapDomainAPISettings"]
 
 
-class WaapAPIURLs(BaseModel):
+class WaapDomainAPISettings(BaseModel):
     api_urls: Optional[List[str]] = None
     """The API URLs for a domain.
 
     If your domain has a common base URL for all API paths, it can be set here
     """
+
+    is_api: Optional[bool] = None
+    """Indicates if the domain is an API domain.
+
+    All requests to an API domain are treated as API requests. If this is set to
+    true then the `api_urls` field is ignored.
+    """

gcore/types/waap/waap_domain_policy.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+from .waap_policy_action import WaapPolicyAction
+
+__all__ = ["WaapDomainPolicy"]
+
+
+class WaapDomainPolicy(BaseModel):
+    id: str
+    """Unique identifier for the security rule"""
+
+    action: WaapPolicyAction
+    """The action taken by the WAAP upon rule activation."""
+
+    description: str
+    """Detailed description of the security rule"""
+
+    group: str
+    """The rule set group name to which the rule belongs"""
+
+    mode: bool
+    """Indicates if the security rule is active"""
+
+    name: str
+    """Name of the security rule"""
+
+    rule_set_id: int
+    """Identifier of the rule set to which the rule belongs"""

gcore/types/waap/{waap_domain_settings.py → waap_domain_settings_model.py}

@@ -1,14 +1,14 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from ..._models import BaseModel
-from .waap_api_urls import WaapAPIURLs
+from .waap_domain_api_settings import WaapDomainAPISettings
 from .waap_domain_ddos_settings import WaapDomainDDOSSettings
 
-__all__ = ["WaapDomainSettings"]
+__all__ = ["WaapDomainSettingsModel"]
 
 
-class WaapDomainSettings(BaseModel):
-    api: WaapAPIURLs
+class WaapDomainSettingsModel(BaseModel):
+    api: WaapDomainAPISettings
     """API settings of a domain"""
 
     ddos: WaapDomainDDOSSettings

gcore/types/waap/waap_event_statistics.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+from .waap_count_statistics import WaapCountStatistics
+from .waap_blocked_statistics import WaapBlockedStatistics
+
+__all__ = ["WaapEventStatistics"]
+
+
+class WaapEventStatistics(BaseModel):
+    blocked: WaapBlockedStatistics
+    """A collection of total numbers of events with blocked results per criteria"""
+
+    count: WaapCountStatistics
+    """A collection of total numbers of events per criteria"""