synqly 2.0.82__tar.gz → 2.0.83__tar.gz

{synqly-2.0.82 → synqly-2.0.83}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synqly
-Version: 2.0.82
+Version: 2.0.83
 Summary: SDK for Synqly APIs
 Requires-Python: >=3.7,<4.0
 Classifier: Programming Language :: Python :: 3

{synqly-2.0.82 → synqly-2.0.83}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "synqly"
-version = "2.0.82"
+version = "2.0.83"
 description = "SDK for Synqly APIs"
 readme = "README.md"
 authors = []

{synqly-2.0.82 → synqly-2.0.83}/src/synqly/engine/__init__.py

@@ -324,8 +324,10 @@ if typing.TYPE_CHECKING:
     from .networksecurity import (
         DnsEvent,
         DnsLogConfiguration,
+        FirewallRuleRecord,
         QueryDnsEventsResponse,
         QueryDnsLogConfigurationsResponse,
+        QueryFirewallRulesResponse,
         QueryTrafficEventsResponse,
         QueryTrafficLogConfigurationsResponse,
         TrafficEvent,
@@ -615,6 +617,7 @@ _dynamic_imports: typing.Dict[str, str] = {
     "ExecuteRemoteScriptResponse": ".edr",
     "ExecuteRemoteScriptResult": ".edr",
     "FindingId": ".appsec",
+    "FirewallRuleRecord": ".networksecurity",
     "ForbiddenError": ".common",
     "GatewayTimeoutError": ".common",
     "GetAlertResponse": ".siem",
@@ -775,6 +778,7 @@ _dynamic_imports: typing.Dict[str, str] = {
     "QueryEventsResponse": ".cloudsecurity",
     "QueryExclusionsResponse": ".edr",
     "QueryFindingsResponse": ".vulnerabilities",
+    "QueryFirewallRulesResponse": ".networksecurity",
     "QueryGroupsResponse": ".identity",
     "QueryIdentityAuditLogResponse": ".identity",
     "QueryIdentityRiskEventsResponse": ".identity",
@@ -1058,6 +1062,7 @@ __all__ = [
     "ExecuteRemoteScriptResponse",
     "ExecuteRemoteScriptResult",
     "FindingId",
+    "FirewallRuleRecord",
     "ForbiddenError",
     "GatewayTimeoutError",
     "GetAlertResponse",
@@ -1218,6 +1223,7 @@ __all__ = [
     "QueryEventsResponse",
     "QueryExclusionsResponse",
     "QueryFindingsResponse",
+    "QueryFirewallRulesResponse",
     "QueryGroupsResponse",
     "QueryIdentityAuditLogResponse",
     "QueryIdentityRiskEventsResponse",

{synqly-2.0.82 → synqly-2.0.83}/src/synqly/engine/core/client_wrapper.py

@@ -39,7 +39,7 @@ class BaseClientWrapper:
             **(self.get_custom_headers() or {}),
         }
         headers["Authorization"] = f"Bearer {self._get_token()}"
-        headers["User-Agent"] = "Synqly-Python-SDK/2.0.82"
+        headers["User-Agent"] = "Synqly-Python-SDK/2.0.83"
         return headers
 
     def _get_token(self) -> str:
@@ -142,5 +142,5 @@ class AsyncClientWrapper(BaseClientWrapper):
         if self._async_token is not None:
             token = await self._async_token()
             headers["Authorization"] = f"Bearer {token}"
-        headers["User-Agent"] = "Synqly-Python-SDK/2.0.82"
+        headers["User-Agent"] = "Synqly-Python-SDK/2.0.83"
         return headers

{synqly-2.0.82 → synqly-2.0.83}/src/synqly/engine/networksecurity/__init__.py

@@ -9,8 +9,10 @@ if typing.TYPE_CHECKING:
     from .types import (
         DnsEvent,
         DnsLogConfiguration,
+        FirewallRuleRecord,
         QueryDnsEventsResponse,
         QueryDnsLogConfigurationsResponse,
+        QueryFirewallRulesResponse,
         QueryTrafficEventsResponse,
         QueryTrafficLogConfigurationsResponse,
         TrafficEvent,
@@ -19,8 +21,10 @@ if typing.TYPE_CHECKING:
 _dynamic_imports: typing.Dict[str, str] = {
     "DnsEvent": ".types",
     "DnsLogConfiguration": ".types",
+    "FirewallRuleRecord": ".types",
     "QueryDnsEventsResponse": ".types",
     "QueryDnsLogConfigurationsResponse": ".types",
+    "QueryFirewallRulesResponse": ".types",
     "QueryTrafficEventsResponse": ".types",
     "QueryTrafficLogConfigurationsResponse": ".types",
     "TrafficEvent": ".types",
@@ -52,8 +56,10 @@ def __dir__():
 __all__ = [
     "DnsEvent",
     "DnsLogConfiguration",
+    "FirewallRuleRecord",
     "QueryDnsEventsResponse",
     "QueryDnsLogConfigurationsResponse",
+    "QueryFirewallRulesResponse",
     "QueryTrafficEventsResponse",
     "QueryTrafficLogConfigurationsResponse",
     "TrafficEvent",

{synqly-2.0.82 → synqly-2.0.83}/src/synqly/engine/networksecurity/client.py

@@ -7,6 +7,7 @@ from ..core.request_options import RequestOptions
 from .raw_client import AsyncRawNetworksecurityClient, RawNetworksecurityClient
 from .types.query_dns_events_response import QueryDnsEventsResponse
 from .types.query_dns_log_configurations_response import QueryDnsLogConfigurationsResponse
+from .types.query_firewall_rules_response import QueryFirewallRulesResponse
 from .types.query_traffic_events_response import QueryTrafficEventsResponse
 from .types.query_traffic_log_configurations_response import QueryTrafficLogConfigurationsResponse
 
@@ -180,6 +181,45 @@ class NetworksecurityClient:
         )
         return _response.data
 
+    def query_firewall_rules(
+        self,
+        *,
+        meta: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        limit: typing.Optional[int] = None,
+        filter: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        cursor: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> QueryFirewallRulesResponse:
+        """
+        Returns the firewall rules that control traffic within the integration's scope. Built-in default rules that the provider's API does not
+        report are not included. A rule that applies to several networks is returned once per network
+
+        Parameters
+        ----------
+        meta : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Add metadata to the response by invoking meta functions. Documentation for [meta functions](https://docs.synqly.com/api-reference/meta-functions) is available. Not all meta functions are available at every endpoint.
+
+        limit : typing.Optional[int]
+            Number of firewall rules to return. Defaults to 100 with a maximum of 200. If a provider has a maximum limit lower than 200, the provider's maximum limit will be used instead.
+
+        filter : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Filter results by this query. For more information on filtering, refer to our [Filtering Guide](https://docs.synqly.com/guides/connectors/networksecurity/query-filters). Defaults to no filter. If used more than once, the queries are ANDed together. No network security provider currently supports filters on this endpoint, so a request that includes a filter is rejected with a 400 error.
+
+        cursor : typing.Optional[str]
+            Start search from cursor position.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        QueryFirewallRulesResponse
+        """
+        _response = self._raw_client.query_firewall_rules(
+            meta=meta, limit=limit, filter=filter, cursor=cursor, request_options=request_options
+        )
+        return _response.data
+
 
 class AsyncNetworksecurityClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -349,3 +389,42 @@ class AsyncNetworksecurityClient:
             meta=meta, limit=limit, filter=filter, cursor=cursor, request_options=request_options
         )
         return _response.data
+
+    async def query_firewall_rules(
+        self,
+        *,
+        meta: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        limit: typing.Optional[int] = None,
+        filter: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        cursor: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> QueryFirewallRulesResponse:
+        """
+        Returns the firewall rules that control traffic within the integration's scope. Built-in default rules that the provider's API does not
+        report are not included. A rule that applies to several networks is returned once per network
+
+        Parameters
+        ----------
+        meta : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Add metadata to the response by invoking meta functions. Documentation for [meta functions](https://docs.synqly.com/api-reference/meta-functions) is available. Not all meta functions are available at every endpoint.
+
+        limit : typing.Optional[int]
+            Number of firewall rules to return. Defaults to 100 with a maximum of 200. If a provider has a maximum limit lower than 200, the provider's maximum limit will be used instead.
+
+        filter : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Filter results by this query. For more information on filtering, refer to our [Filtering Guide](https://docs.synqly.com/guides/connectors/networksecurity/query-filters). Defaults to no filter. If used more than once, the queries are ANDed together. No network security provider currently supports filters on this endpoint, so a request that includes a filter is rejected with a 400 error.
+
+        cursor : typing.Optional[str]
+            Start search from cursor position.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        QueryFirewallRulesResponse
+        """
+        _response = await self._raw_client.query_firewall_rules(
+            meta=meta, limit=limit, filter=filter, cursor=cursor, request_options=request_options
+        )
+        return _response.data

{synqly-2.0.82 → synqly-2.0.83}/src/synqly/engine/networksecurity/raw_client.py

@@ -25,6 +25,7 @@ from ..core.request_options import RequestOptions
 from ..core.unchecked_base_model import construct_type
 from .types.query_dns_events_response import QueryDnsEventsResponse
 from .types.query_dns_log_configurations_response import QueryDnsLogConfigurationsResponse
+from .types.query_firewall_rules_response import QueryFirewallRulesResponse
 from .types.query_traffic_events_response import QueryTrafficEventsResponse
 from .types.query_traffic_log_configurations_response import QueryTrafficLogConfigurationsResponse
 from pydantic import ValidationError
@@ -860,6 +861,213 @@ class RawNetworksecurityClient:
             )
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def query_firewall_rules(
+        self,
+        *,
+        meta: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        limit: typing.Optional[int] = None,
+        filter: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        cursor: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[QueryFirewallRulesResponse]:
+        """
+        Returns the firewall rules that control traffic within the integration's scope. Built-in default rules that the provider's API does not
+        report are not included. A rule that applies to several networks is returned once per network
+
+        Parameters
+        ----------
+        meta : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Add metadata to the response by invoking meta functions. Documentation for [meta functions](https://docs.synqly.com/api-reference/meta-functions) is available. Not all meta functions are available at every endpoint.
+
+        limit : typing.Optional[int]
+            Number of firewall rules to return. Defaults to 100 with a maximum of 200. If a provider has a maximum limit lower than 200, the provider's maximum limit will be used instead.
+
+        filter : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Filter results by this query. For more information on filtering, refer to our [Filtering Guide](https://docs.synqly.com/guides/connectors/networksecurity/query-filters). Defaults to no filter. If used more than once, the queries are ANDed together. No network security provider currently supports filters on this endpoint, so a request that includes a filter is rejected with a 400 error.
+
+        cursor : typing.Optional[str]
+            Start search from cursor position.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[QueryFirewallRulesResponse]
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/network-security/firewall-rules",
+            method="GET",
+            params={
+                "meta": meta,
+                "limit": limit,
+                "filter": filter,
+                "cursor": cursor,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    QueryFirewallRulesResponse,
+                    construct_type(
+                        type_=QueryFirewallRulesResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 405:
+                raise MethodNotAllowedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 415:
+                raise UnsupportedMediaTypeError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 429:
+                raise TooManyRequestsError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 501:
+                raise NotImplementedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 502:
+                raise BadGatewayError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 504:
+                raise GatewayTimeoutError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
 
 class AsyncRawNetworksecurityClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -1690,3 +1898,210 @@ class AsyncRawNetworksecurityClient:
                 status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
             )
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def query_firewall_rules(
+        self,
+        *,
+        meta: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        limit: typing.Optional[int] = None,
+        filter: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        cursor: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[QueryFirewallRulesResponse]:
+        """
+        Returns the firewall rules that control traffic within the integration's scope. Built-in default rules that the provider's API does not
+        report are not included. A rule that applies to several networks is returned once per network
+
+        Parameters
+        ----------
+        meta : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Add metadata to the response by invoking meta functions. Documentation for [meta functions](https://docs.synqly.com/api-reference/meta-functions) is available. Not all meta functions are available at every endpoint.
+
+        limit : typing.Optional[int]
+            Number of firewall rules to return. Defaults to 100 with a maximum of 200. If a provider has a maximum limit lower than 200, the provider's maximum limit will be used instead.
+
+        filter : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            Filter results by this query. For more information on filtering, refer to our [Filtering Guide](https://docs.synqly.com/guides/connectors/networksecurity/query-filters). Defaults to no filter. If used more than once, the queries are ANDed together. No network security provider currently supports filters on this endpoint, so a request that includes a filter is rejected with a 400 error.
+
+        cursor : typing.Optional[str]
+            Start search from cursor position.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[QueryFirewallRulesResponse]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/network-security/firewall-rules",
+            method="GET",
+            params={
+                "meta": meta,
+                "limit": limit,
+                "filter": filter,
+                "cursor": cursor,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    QueryFirewallRulesResponse,
+                    construct_type(
+                        type_=QueryFirewallRulesResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 405:
+                raise MethodNotAllowedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 415:
+                raise UnsupportedMediaTypeError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 429:
+                raise TooManyRequestsError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 501:
+                raise NotImplementedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 502:
+                raise BadGatewayError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 503:
+                raise ServiceUnavailableError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 504:
+                raise GatewayTimeoutError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        Problem,
+                        construct_type(
+                            type_=Problem,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

{synqly-2.0.82 → synqly-2.0.83}/src/synqly/engine/networksecurity/types/__init__.py

@@ -8,8 +8,10 @@ from importlib import import_module
 if typing.TYPE_CHECKING:
     from .dns_event import DnsEvent
     from .dns_log_configuration import DnsLogConfiguration
+    from .firewall_rule_record import FirewallRuleRecord
     from .query_dns_events_response import QueryDnsEventsResponse
     from .query_dns_log_configurations_response import QueryDnsLogConfigurationsResponse
+    from .query_firewall_rules_response import QueryFirewallRulesResponse
     from .query_traffic_events_response import QueryTrafficEventsResponse
     from .query_traffic_log_configurations_response import QueryTrafficLogConfigurationsResponse
     from .traffic_event import TrafficEvent
@@ -17,8 +19,10 @@ if typing.TYPE_CHECKING:
 _dynamic_imports: typing.Dict[str, str] = {
     "DnsEvent": ".dns_event",
     "DnsLogConfiguration": ".dns_log_configuration",
+    "FirewallRuleRecord": ".firewall_rule_record",
     "QueryDnsEventsResponse": ".query_dns_events_response",
     "QueryDnsLogConfigurationsResponse": ".query_dns_log_configurations_response",
+    "QueryFirewallRulesResponse": ".query_firewall_rules_response",
     "QueryTrafficEventsResponse": ".query_traffic_events_response",
     "QueryTrafficLogConfigurationsResponse": ".query_traffic_log_configurations_response",
     "TrafficEvent": ".traffic_event",
@@ -50,8 +54,10 @@ def __dir__():
 __all__ = [
     "DnsEvent",
     "DnsLogConfiguration",
+    "FirewallRuleRecord",
     "QueryDnsEventsResponse",
     "QueryDnsLogConfigurationsResponse",
+    "QueryFirewallRulesResponse",
     "QueryTrafficEventsResponse",
     "QueryTrafficLogConfigurationsResponse",
     "TrafficEvent",

synqly-2.0.83/src/synqly/engine/networksecurity/types/firewall_rule_record.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...ocsf.v_1_8_0.cloudresourcesinventoryinfo.classes.types.cloud_resources_inventory_info import (
+    CloudResourcesInventoryInfo,
+)
+
+FirewallRuleRecord = CloudResourcesInventoryInfo
+"""
+Firewall rule discovered for the integration.
+"""