opportify-sdk 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

{lib/v1/openapi_client → openapi_client}/__init__.py

@@ -37,6 +37,8 @@ from openapi_client.models.admin_contact import AdminContact
 from openapi_client.models.analyze_email200_response import AnalyzeEmail200Response
 from openapi_client.models.analyze_email400_response import AnalyzeEmail400Response
 from openapi_client.models.analyze_email400_response_error import AnalyzeEmail400ResponseError
+from openapi_client.models.analyze_email403_response import AnalyzeEmail403Response
+from openapi_client.models.analyze_email403_response_error import AnalyzeEmail403ResponseError
 from openapi_client.models.analyze_email500_response import AnalyzeEmail500Response
 from openapi_client.models.analyze_email500_response_error import AnalyzeEmail500ResponseError
 from openapi_client.models.analyze_email_request import AnalyzeEmailRequest
@@ -52,12 +54,15 @@ from openapi_client.models.email_dns import EmailDNS
 from openapi_client.models.geo import Geo
 from openapi_client.models.internalerror import INTERNALERROR
 from openapi_client.models.invalidemail import INVALIDEMAIL
+from openapi_client.models.invalidplan import INVALIDPLAN
+from openapi_client.models.invalidtoken import INVALIDTOKEN
 from openapi_client.models.ipvalidationfailed import IPVALIDATIONFAILED
 from openapi_client.models.malformedrequest import MALFORMEDREQUEST
 from openapi_client.models.malformedrequest1 import MALFORMEDREQUEST1
 from openapi_client.models.notfound import NOTFOUND
 from openapi_client.models.organization import Organization
-from openapi_client.models.risk_report import RiskReport
+from openapi_client.models.risk_report_email import RiskReportEmail
+from openapi_client.models.risk_report_ip import RiskReportIp
 from openapi_client.models.tech_contact import TechContact
 from openapi_client.models.trusted_provider import TrustedProvider
 from openapi_client.models.whois import Whois

{lib/v1/openapi_client → openapi_client}/api/email_insights_api.py

@@ -56,7 +56,7 @@ class EmailInsightsApi:
     ) -> AnalyzeEmail200Response:
         """Analyze Email
 
-        The **Analyze Email** endpoint validates an email address and returns its deliverability status, provider details, and potential corrections. This endpoint is ideal for ensuring accurate email data before usage.  ### Features: - Validate email syntax. - Identify email types (free, disposable, corporate or unknown). - Real time verifications:   - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.   - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.   - Catch-All: Detects if the domain accepts all emails (catch-all configuration). - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses. - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.  ### Example Request Body: ```json {   \"email\": \"my-email@company.com\",   \"enableAI\": true,   \"enableAutoCorrection\": true } ```  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+        The **Analyze Email** endpoint validates an email address and returns its deliverability status, provider details, and potential corrections. This endpoint is ideal for ensuring accurate email data before usage.  ### Features: - Validate email syntax. - Identify email types (free, disposable, private or unknown). - Real time verifications:   - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.   - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.   - Catch-All: Detects if the domain accepts all emails (catch-all configuration). - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses. - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.  ### Example Request Body: ```json {   \"email\": \"my-email@company.com\",   \"enableAI\": true,   \"enableAutoCorrection\": true } ```  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
 
         :param analyze_email_request: (required)
         :type analyze_email_request: AnalyzeEmailRequest
@@ -93,6 +93,7 @@ class EmailInsightsApi:
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "AnalyzeEmail200Response",
             '400': "AnalyzeEmail400Response",
+            '403': "AnalyzeEmail403Response",
             '500': "AnalyzeEmail500Response",
         }
         response_data = self.api_client.call_api(
@@ -125,7 +126,7 @@ class EmailInsightsApi:
     ) -> ApiResponse[AnalyzeEmail200Response]:
         """Analyze Email
 
-        The **Analyze Email** endpoint validates an email address and returns its deliverability status, provider details, and potential corrections. This endpoint is ideal for ensuring accurate email data before usage.  ### Features: - Validate email syntax. - Identify email types (free, disposable, corporate or unknown). - Real time verifications:   - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.   - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.   - Catch-All: Detects if the domain accepts all emails (catch-all configuration). - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses. - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.  ### Example Request Body: ```json {   \"email\": \"my-email@company.com\",   \"enableAI\": true,   \"enableAutoCorrection\": true } ```  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+        The **Analyze Email** endpoint validates an email address and returns its deliverability status, provider details, and potential corrections. This endpoint is ideal for ensuring accurate email data before usage.  ### Features: - Validate email syntax. - Identify email types (free, disposable, private or unknown). - Real time verifications:   - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.   - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.   - Catch-All: Detects if the domain accepts all emails (catch-all configuration). - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses. - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.  ### Example Request Body: ```json {   \"email\": \"my-email@company.com\",   \"enableAI\": true,   \"enableAutoCorrection\": true } ```  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
 
         :param analyze_email_request: (required)
         :type analyze_email_request: AnalyzeEmailRequest
@@ -162,6 +163,7 @@ class EmailInsightsApi:
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "AnalyzeEmail200Response",
             '400': "AnalyzeEmail400Response",
+            '403': "AnalyzeEmail403Response",
             '500': "AnalyzeEmail500Response",
         }
         response_data = self.api_client.call_api(
@@ -194,7 +196,7 @@ class EmailInsightsApi:
     ) -> RESTResponseType:
         """Analyze Email
 
-        The **Analyze Email** endpoint validates an email address and returns its deliverability status, provider details, and potential corrections. This endpoint is ideal for ensuring accurate email data before usage.  ### Features: - Validate email syntax. - Identify email types (free, disposable, corporate or unknown). - Real time verifications:   - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.   - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.   - Catch-All: Detects if the domain accepts all emails (catch-all configuration). - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses. - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.  ### Example Request Body: ```json {   \"email\": \"my-email@company.com\",   \"enableAI\": true,   \"enableAutoCorrection\": true } ```  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+        The **Analyze Email** endpoint validates an email address and returns its deliverability status, provider details, and potential corrections. This endpoint is ideal for ensuring accurate email data before usage.  ### Features: - Validate email syntax. - Identify email types (free, disposable, private or unknown). - Real time verifications:   - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.   - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.   - Catch-All: Detects if the domain accepts all emails (catch-all configuration). - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses. - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.  ### Example Request Body: ```json {   \"email\": \"my-email@company.com\",   \"enableAI\": true,   \"enableAutoCorrection\": true } ```  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
 
         :param analyze_email_request: (required)
         :type analyze_email_request: AnalyzeEmailRequest
@@ -231,6 +233,7 @@ class EmailInsightsApi:
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "AnalyzeEmail200Response",
             '400': "AnalyzeEmail400Response",
+            '403': "AnalyzeEmail403Response",
             '500': "AnalyzeEmail500Response",
         }
         response_data = self.api_client.call_api(

{lib/v1/openapi_client → openapi_client}/api/ip_insights_api.py

@@ -90,12 +90,11 @@ class IPInsightsApi:
             _host_index=_host_index
         )
 
-        print ("_param", _param)
-
         _response_types_map: Dict[str, Optional[str]] = {
             '200': "AnalyzeIp200Response",
             '400': "AnalyzeIp400Response",
             '404': "AnalyzeIp404Response",
+            '403': "AnalyzeEmail403Response",
             '500': "AnalyzeIp500Response",
         }
         response_data = self.api_client.call_api(
@@ -166,6 +165,7 @@ class IPInsightsApi:
             '200': "AnalyzeIp200Response",
             '400': "AnalyzeIp400Response",
             '404': "AnalyzeIp404Response",
+            '403': "AnalyzeEmail403Response",
             '500': "AnalyzeIp500Response",
         }
         response_data = self.api_client.call_api(
@@ -236,6 +236,7 @@ class IPInsightsApi:
             '200': "AnalyzeIp200Response",
             '400': "AnalyzeIp400Response",
             '404': "AnalyzeIp404Response",
+            '403': "AnalyzeEmail403Response",
             '500': "AnalyzeIp500Response",
         }
         response_data = self.api_client.call_api(

{lib/v1/openapi_client → openapi_client}/models/__init__.py

@@ -19,6 +19,8 @@ from openapi_client.models.admin_contact import AdminContact
 from openapi_client.models.analyze_email200_response import AnalyzeEmail200Response
 from openapi_client.models.analyze_email400_response import AnalyzeEmail400Response
 from openapi_client.models.analyze_email400_response_error import AnalyzeEmail400ResponseError
+from openapi_client.models.analyze_email403_response import AnalyzeEmail403Response
+from openapi_client.models.analyze_email403_response_error import AnalyzeEmail403ResponseError
 from openapi_client.models.analyze_email500_response import AnalyzeEmail500Response
 from openapi_client.models.analyze_email500_response_error import AnalyzeEmail500ResponseError
 from openapi_client.models.analyze_email_request import AnalyzeEmailRequest
@@ -34,12 +36,15 @@ from openapi_client.models.email_dns import EmailDNS
 from openapi_client.models.geo import Geo
 from openapi_client.models.internalerror import INTERNALERROR
 from openapi_client.models.invalidemail import INVALIDEMAIL
+from openapi_client.models.invalidplan import INVALIDPLAN
+from openapi_client.models.invalidtoken import INVALIDTOKEN
 from openapi_client.models.ipvalidationfailed import IPVALIDATIONFAILED
 from openapi_client.models.malformedrequest import MALFORMEDREQUEST
 from openapi_client.models.malformedrequest1 import MALFORMEDREQUEST1
 from openapi_client.models.notfound import NOTFOUND
 from openapi_client.models.organization import Organization
-from openapi_client.models.risk_report import RiskReport
+from openapi_client.models.risk_report_email import RiskReportEmail
+from openapi_client.models.risk_report_ip import RiskReportIp
 from openapi_client.models.tech_contact import TechContact
 from openapi_client.models.trusted_provider import TrustedProvider
 from openapi_client.models.whois import Whois

{lib/v1/openapi_client → openapi_client}/models/analyze_email200_response.py

@@ -20,7 +20,7 @@ import json
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List
 from openapi_client.models.email_dns import EmailDNS
-from openapi_client.models.risk_report import RiskReport
+from openapi_client.models.risk_report_email import RiskReportEmail
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -30,15 +30,16 @@ class AnalyzeEmail200Response(BaseModel):
     """ # noqa: E501
     email_address: StrictStr = Field(description="The validated email address.", alias="emailAddress")
     email_provider: StrictStr = Field(description="The email provider or domain name.", alias="emailProvider")
-    email_type: StrictStr = Field(description="Type of email address (e.g., free, disposable, corporate, unknown).", alias="emailType")
+    email_type: StrictStr = Field(description="Type of email address (e.g., free, disposable, private, unknown).", alias="emailType")
     is_format_valid: StrictBool = Field(description="Indicates if the email address has a valid format.", alias="isFormatValid")
     email_correction: StrictStr = Field(description="Suggested corrected email address, if applicable.", alias="emailCorrection")
-    is_deliverable: StrictBool = Field(description="Checks if the email address exists and is deliverable using SMTP handshake simulation. This involves connecting to the mail server and issuing commands to verify deliverability. ", alias="isDeliverable")
+    is_deliverable: StrictStr = Field(description="Checks if the email address exists and is deliverable using SMTP handshake simulation. This involves connecting to the mail server and issuing commands to verify deliverability. The possible answers are `yes`, `no`, or `unknown`. We guarantee a high confidence level on this parameter since this is a real time verification. ", alias="isDeliverable")
     is_catch_all: StrictBool = Field(description="Determines if the email domain is configured as a catch-all, which accepts emails for all addresses within the domain. This is verified through multiple email tests. ", alias="isCatchAll")
+    is_mailbox_full: StrictBool = Field(description="Determines if the mailbox associated with the email is full, in association with isDeliverable field, it can give a reason why the email is not deliverable. ", alias="isMailboxFull")
     is_reachable: StrictBool = Field(description="Confirms if the email domain has valid MX DNS records using DNS lookup.", alias="isReachable")
     email_dns: EmailDNS = Field(alias="emailDNS")
-    risk_report: RiskReport = Field(alias="riskReport")
-    __properties: ClassVar[List[str]] = ["emailAddress", "emailProvider", "emailType", "isFormatValid", "emailCorrection", "isDeliverable", "isCatchAll", "isReachable", "emailDNS", "riskReport"]
+    risk_report: RiskReportEmail = Field(alias="riskReport")
+    __properties: ClassVar[List[str]] = ["emailAddress", "emailProvider", "emailType", "isFormatValid", "emailCorrection", "isDeliverable", "isCatchAll", "isMailboxFull", "isReachable", "emailDNS", "riskReport"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -104,9 +105,10 @@ class AnalyzeEmail200Response(BaseModel):
             "emailCorrection": obj.get("emailCorrection"),
             "isDeliverable": obj.get("isDeliverable"),
             "isCatchAll": obj.get("isCatchAll"),
+            "isMailboxFull": obj.get("isMailboxFull"),
             "isReachable": obj.get("isReachable"),
             "emailDNS": EmailDNS.from_dict(obj["emailDNS"]) if obj.get("emailDNS") is not None else None,
-            "riskReport": RiskReport.from_dict(obj["riskReport"]) if obj.get("riskReport") is not None else None
+            "riskReport": RiskReportEmail.from_dict(obj["riskReport"]) if obj.get("riskReport") is not None else None
         })
         return _obj
 

openapi_client/models/analyze_email403_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Opportify Insights API
+
+    ## Overview  The **Opportify Insights API** provides access to a powerful and up-to-date platform. With advanced data warehousing and AI-driven capabilities, this API is designed to empower your business to make informed, data-driven decisions and effectively assess potential risks.  ### Base URL Use the following base URL for all API requests:  ```plaintext https://api.opportify.ai/insights/v1/<service>/<endpoint> ```  ### Features - [**Email Insights:**](/docs/api-reference/email-insights)   - Validate email syntax.   - Identify email types (free, disposable, corporate or unknown).   - Real time verifications:     - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.     - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.     - Catch-All: Detects if the domain accepts all emails (catch-all configuration).   - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses.   - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.      [Access Documentation >>](/docs/api-reference/email-insights)  - [**IP Insights:**](/docs/api-reference/ip-insights)   - Connection types: Detects connection types such as `wired`, `mobile`, `enterprise`, `satellite`, `VPN`, `cloud-provider`, `open-proxy`, or `Tor`.   - Geo location: Delivers detailed insights such as country, city, timezone, language preferences, and additional location-based information to enhance regional understanding.   - WHOIS: Provides main details including RIR, ASN, organization, and abuse/admin/technical contacts.   - Trusted Provider Recognition: Identifies if the IP is part of a known trusted provider (e.g., ZTNA - Zero Trust Network Access).   - Blocklist Reports: Retrieves up-to-date blocklist statuses, active reports, and the latest detections.   - Risk Report: Delivers an AI-driven normalized score (200-1000) to evaluate IP risk, supported by predefined thresholds.    [Access Documentation >>](/docs/api-reference/ip-insights)  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from openapi_client.models.analyze_email403_response_error import AnalyzeEmail403ResponseError
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AnalyzeEmail403Response(BaseModel):
+    """
+    AnalyzeEmail403Response
+    """ # noqa: E501
+    error: Optional[AnalyzeEmail403ResponseError] = None
+    __properties: ClassVar[List[str]] = ["error"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AnalyzeEmail403Response from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of error
+        if self.error:
+            _dict['error'] = self.error.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AnalyzeEmail403Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "error": AnalyzeEmail403ResponseError.from_dict(obj["error"]) if obj.get("error") is not None else None
+        })
+        return _obj
+
+

openapi_client/models/analyze_email403_response_error.py

@@ -0,0 +1,137 @@
+# coding: utf-8
+
+"""
+    Opportify Insights API
+
+    ## Overview  The **Opportify Insights API** provides access to a powerful and up-to-date platform. With advanced data warehousing and AI-driven capabilities, this API is designed to empower your business to make informed, data-driven decisions and effectively assess potential risks.  ### Base URL Use the following base URL for all API requests:  ```plaintext https://api.opportify.ai/insights/v1/<service>/<endpoint> ```  ### Features - [**Email Insights:**](/docs/api-reference/email-insights)   - Validate email syntax.   - Identify email types (free, disposable, corporate or unknown).   - Real time verifications:     - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.     - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.     - Catch-All: Detects if the domain accepts all emails (catch-all configuration).   - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses.   - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.      [Access Documentation >>](/docs/api-reference/email-insights)  - [**IP Insights:**](/docs/api-reference/ip-insights)   - Connection types: Detects connection types such as `wired`, `mobile`, `enterprise`, `satellite`, `VPN`, `cloud-provider`, `open-proxy`, or `Tor`.   - Geo location: Delivers detailed insights such as country, city, timezone, language preferences, and additional location-based information to enhance regional understanding.   - WHOIS: Provides main details including RIR, ASN, organization, and abuse/admin/technical contacts.   - Trusted Provider Recognition: Identifies if the IP is part of a known trusted provider (e.g., ZTNA - Zero Trust Network Access).   - Blocklist Reports: Retrieves up-to-date blocklist statuses, active reports, and the latest detections.   - Risk Report: Delivers an AI-driven normalized score (200-1000) to evaluate IP risk, supported by predefined thresholds.    [Access Documentation >>](/docs/api-reference/ip-insights)  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from openapi_client.models.invalidplan import INVALIDPLAN
+from openapi_client.models.invalidtoken import INVALIDTOKEN
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+ANALYZEEMAIL403RESPONSEERROR_ONE_OF_SCHEMAS = ["INVALIDPLAN", "INVALIDTOKEN"]
+
+class AnalyzeEmail403ResponseError(BaseModel):
+    """
+    AnalyzeEmail403ResponseError
+    """
+    # data type: INVALIDPLAN
+    oneof_schema_1_validator: Optional[INVALIDPLAN] = None
+    # data type: INVALIDTOKEN
+    oneof_schema_2_validator: Optional[INVALIDTOKEN] = None
+    actual_instance: Optional[Union[INVALIDPLAN, INVALIDTOKEN]] = None
+    one_of_schemas: Set[str] = { "INVALIDPLAN", "INVALIDTOKEN" }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = AnalyzeEmail403ResponseError.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: INVALIDPLAN
+        if not isinstance(v, INVALIDPLAN):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `INVALIDPLAN`")
+        else:
+            match += 1
+        # validate data type: INVALIDTOKEN
+        if not isinstance(v, INVALIDTOKEN):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `INVALIDTOKEN`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in AnalyzeEmail403ResponseError with oneOf schemas: INVALIDPLAN, INVALIDTOKEN. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in AnalyzeEmail403ResponseError with oneOf schemas: INVALIDPLAN, INVALIDTOKEN. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into INVALIDPLAN
+        try:
+            instance.actual_instance = INVALIDPLAN.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into INVALIDTOKEN
+        try:
+            instance.actual_instance = INVALIDTOKEN.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into AnalyzeEmail403ResponseError with oneOf schemas: INVALIDPLAN, INVALIDTOKEN. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into AnalyzeEmail403ResponseError with oneOf schemas: INVALIDPLAN, INVALIDTOKEN. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], INVALIDPLAN, INVALIDTOKEN]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

{lib/v1/openapi_client → openapi_client}/models/analyze_ip200_response.py

@@ -21,7 +21,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List
 from openapi_client.models.block_listed import BlockListed
 from openapi_client.models.geo import Geo
-from openapi_client.models.risk_report import RiskReport
+from openapi_client.models.risk_report_ip import RiskReportIp
 from openapi_client.models.trusted_provider import TrustedProvider
 from openapi_client.models.whois import Whois
 from typing import Optional, Set
@@ -41,7 +41,7 @@ class AnalyzeIp200Response(BaseModel):
     whois: Whois
     trusted_provider: TrustedProvider = Field(alias="trustedProvider")
     blocklisted: BlockListed
-    risk_report: RiskReport = Field(alias="riskReport")
+    risk_report: RiskReportIp = Field(alias="riskReport")
     __properties: ClassVar[List[str]] = ["ipAddress", "ipAddressNumber", "ipType", "ipCidr", "connectionType", "hostReverse", "geo", "whois", "trustedProvider", "blocklisted", "riskReport"]
 
     model_config = ConfigDict(
@@ -120,7 +120,7 @@ class AnalyzeIp200Response(BaseModel):
             "whois": Whois.from_dict(obj["whois"]) if obj.get("whois") is not None else None,
             "trustedProvider": TrustedProvider.from_dict(obj["trustedProvider"]) if obj.get("trustedProvider") is not None else None,
             "blocklisted": BlockListed.from_dict(obj["blocklisted"]) if obj.get("blocklisted") is not None else None,
-            "riskReport": RiskReport.from_dict(obj["riskReport"]) if obj.get("riskReport") is not None else None
+            "riskReport": RiskReportIp.from_dict(obj["riskReport"]) if obj.get("riskReport") is not None else None
         })
         return _obj
 

openapi_client/models/invalidplan.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Opportify Insights API
+
+    ## Overview  The **Opportify Insights API** provides access to a powerful and up-to-date platform. With advanced data warehousing and AI-driven capabilities, this API is designed to empower your business to make informed, data-driven decisions and effectively assess potential risks.  ### Base URL Use the following base URL for all API requests:  ```plaintext https://api.opportify.ai/insights/v1/<service>/<endpoint> ```  ### Features - [**Email Insights:**](/docs/api-reference/email-insights)   - Validate email syntax.   - Identify email types (free, disposable, corporate or unknown).   - Real time verifications:     - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.     - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.     - Catch-All: Detects if the domain accepts all emails (catch-all configuration).   - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses.   - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.      [Access Documentation >>](/docs/api-reference/email-insights)  - [**IP Insights:**](/docs/api-reference/ip-insights)   - Connection types: Detects connection types such as `wired`, `mobile`, `enterprise`, `satellite`, `VPN`, `cloud-provider`, `open-proxy`, or `Tor`.   - Geo location: Delivers detailed insights such as country, city, timezone, language preferences, and additional location-based information to enhance regional understanding.   - WHOIS: Provides main details including RIR, ASN, organization, and abuse/admin/technical contacts.   - Trusted Provider Recognition: Identifies if the IP is part of a known trusted provider (e.g., ZTNA - Zero Trust Network Access).   - Blocklist Reports: Retrieves up-to-date blocklist statuses, active reports, and the latest detections.   - Risk Report: Delivers an AI-driven normalized score (200-1000) to evaluate IP risk, supported by predefined thresholds.    [Access Documentation >>](/docs/api-reference/ip-insights)  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class INVALIDPLAN(BaseModel):
+    """
+    INVALIDPLAN
+    """ # noqa: E501
+    message: Optional[StrictStr] = None
+    code: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["message", "code"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of INVALIDPLAN from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of INVALIDPLAN from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message"),
+            "code": obj.get("code")
+        })
+        return _obj
+
+

openapi_client/models/invalidtoken.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Opportify Insights API
+
+    ## Overview  The **Opportify Insights API** provides access to a powerful and up-to-date platform. With advanced data warehousing and AI-driven capabilities, this API is designed to empower your business to make informed, data-driven decisions and effectively assess potential risks.  ### Base URL Use the following base URL for all API requests:  ```plaintext https://api.opportify.ai/insights/v1/<service>/<endpoint> ```  ### Features - [**Email Insights:**](/docs/api-reference/email-insights)   - Validate email syntax.   - Identify email types (free, disposable, corporate or unknown).   - Real time verifications:     - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.     - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.     - Catch-All: Detects if the domain accepts all emails (catch-all configuration).   - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses.   - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.      [Access Documentation >>](/docs/api-reference/email-insights)  - [**IP Insights:**](/docs/api-reference/ip-insights)   - Connection types: Detects connection types such as `wired`, `mobile`, `enterprise`, `satellite`, `VPN`, `cloud-provider`, `open-proxy`, or `Tor`.   - Geo location: Delivers detailed insights such as country, city, timezone, language preferences, and additional location-based information to enhance regional understanding.   - WHOIS: Provides main details including RIR, ASN, organization, and abuse/admin/technical contacts.   - Trusted Provider Recognition: Identifies if the IP is part of a known trusted provider (e.g., ZTNA - Zero Trust Network Access).   - Blocklist Reports: Retrieves up-to-date blocklist statuses, active reports, and the latest detections.   - Risk Report: Delivers an AI-driven normalized score (200-1000) to evaluate IP risk, supported by predefined thresholds.    [Access Documentation >>](/docs/api-reference/ip-insights)  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class INVALIDTOKEN(BaseModel):
+    """
+    INVALIDTOKEN
+    """ # noqa: E501
+    message: Optional[StrictStr] = None
+    code: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["message", "code"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of INVALIDTOKEN from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of INVALIDTOKEN from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message"),
+            "code": obj.get("code")
+        })
+        return _obj
+
+

openapi_client/models/risk_report_email.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Opportify Insights API
+
+    ## Overview  The **Opportify Insights API** provides access to a powerful and up-to-date platform. With advanced data warehousing and AI-driven capabilities, this API is designed to empower your business to make informed, data-driven decisions and effectively assess potential risks.  ### Base URL Use the following base URL for all API requests:  ```plaintext https://api.opportify.ai/insights/v1/<service>/<endpoint> ```  ### Features - [**Email Insights:**](/docs/api-reference/email-insights)   - Validate email syntax.   - Identify email types (free, disposable, corporate or unknown).   - Real time verifications:     - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.     - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.     - Catch-All: Detects if the domain accepts all emails (catch-all configuration).   - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses.   - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.      [Access Documentation >>](/docs/api-reference/email-insights)  - [**IP Insights:**](/docs/api-reference/ip-insights)   - Connection types: Detects connection types such as `wired`, `mobile`, `enterprise`, `satellite`, `VPN`, `cloud-provider`, `open-proxy`, or `Tor`.   - Geo location: Delivers detailed insights such as country, city, timezone, language preferences, and additional location-based information to enhance regional understanding.   - WHOIS: Provides main details including RIR, ASN, organization, and abuse/admin/technical contacts.   - Trusted Provider Recognition: Identifies if the IP is part of a known trusted provider (e.g., ZTNA - Zero Trust Network Access).   - Blocklist Reports: Retrieves up-to-date blocklist statuses, active reports, and the latest detections.   - Risk Report: Delivers an AI-driven normalized score (200-1000) to evaluate IP risk, supported by predefined thresholds.    [Access Documentation >>](/docs/api-reference/ip-insights)  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RiskReportEmail(BaseModel):
+    """
+    ### Risk Level Determination This documentation outlines how the risk report is determined based on a `normalizedScore` generated by analyzing multiple email-related parameters against predefined risk factors (`baseAnalysis`). The risk report encapsulates the likelihood of various risk scenarios, enabling effective classification and prioritization of risks.     The underlying analysis evaluates the provided email information against key risk factors, such as the likelihood of bounces, fraud detection signals, and email deliverability issues. These insights are used to generate a comprehensive risk report, which is then mapped to static risk levels for easier interpretation.      ---  > **IMPORTANT:**  > The risk report model is not available in the free plan. To access this feature, you need to subscribe to a paid plan.  ---  #### How the Score is Generated  The risk score (`normalizedScore`) is derived from a multivariate analysis of input parameters, comparing them against risk factors included in `baseAnalysis`. This process involves:  ##### Key Features of the Model: 1. **Dynamic Scoring:** The model assigns weights to various risk factors, dynamically updating them based on training with new data. 2. **Constant Training:** The model is continuously retrained with the latest data to improve accuracy and adapt to evolving risk patterns. 3. **Scalability:** The model supports multiple features and their interactions, deriving a comprehensive and reliable risk score.  The output score is normalized to a range of **200–1000** for easier interpretation and alignment with industry practices.  ---  #### Risk Level Thresholds  The risk level is a static representation of the `normalizedScore`, categorized into five distinct levels:  | **Risk Level** | **Score Range**          | **Description**                                                                 | |----------------|--------------------------|---------------------------------------------------------------------------------| | `highest`      | `normalizedScore > 800` | Represents the most critical level of risk. Immediate attention is required.   | | `high`         | `600 < normalizedScore <= 800` | Indicates a high level of risk. Consider mitigation actions promptly.          | | `medium`       | `400 < normalizedScore <= 600` | Reflects a moderate level of risk. Monitoring and possible action advised.     | | `low`          | `300 < normalizedScore <= 400` | Denotes a low level of risk. Regular monitoring is sufficient.                 | | `lowest`       | `normalizedScore <= 300` | The lowest level of risk. Risk is considered negligible or minimal.            |  ---  #### Usage  This risk level determination serves as a human-readable representation of the machine learning model's output. It enables: - **Risk Monitoring:** Identifying entities that require immediate attention. - **Action Prioritization:** Guiding mitigation efforts based on the severity of the risk. - **Decision-Making:** Providing clear thresholds for automated and manual workflows.  ---  #### Key Notes 1. **Dynamic Scoring, Static Levels:**   - While the score is dynamically updated through a multivariate linear regression model, the risk levels remain static to maintain consistency and interpretability.  2. **Customizable Thresholds:**   - The thresholds for the levels are configurable based on organizational needs or domain-specific requirements.  3. **Model Retraining:**    - Regular updates to the model ensure that scores accurately reflect real-world risk trends, improving the reliability of level assignments.  ---  This approach combines the adaptability of multivariate linear regression with the simplicity of static thresholds, offering a robust framework for risk assessment and decision-making.  ---  ### Response Elements 
+    """ # noqa: E501
+    score: Optional[StrictInt] = Field(default=None, description="Risk score normalized to a range of 200–1000.")
+    level: Optional[StrictStr] = Field(default=None, description="Static representation of the risk level.")
+    base_analysis: Optional[List[StrictStr]] = Field(default=None, description="Provide the breakdown of the predefined risk factors used in the analysis.", alias="baseAnalysis")
+    __properties: ClassVar[List[str]] = ["score", "level", "baseAnalysis"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RiskReportEmail from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RiskReportEmail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "score": obj.get("score"),
+            "level": obj.get("level"),
+            "baseAnalysis": obj.get("baseAnalysis")
+        })
+        return _obj
+
+

openapi_client/models/risk_report_ip.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Opportify Insights API
+
+    ## Overview  The **Opportify Insights API** provides access to a powerful and up-to-date platform. With advanced data warehousing and AI-driven capabilities, this API is designed to empower your business to make informed, data-driven decisions and effectively assess potential risks.  ### Base URL Use the following base URL for all API requests:  ```plaintext https://api.opportify.ai/insights/v1/<service>/<endpoint> ```  ### Features - [**Email Insights:**](/docs/api-reference/email-insights)   - Validate email syntax.   - Identify email types (free, disposable, corporate or unknown).   - Real time verifications:     - Reachable: Confirms if the email domain has valid MX DNS records using DNS lookup.     - Deliverable: Simulates an SMTP handshake to check if the email address exists and is deliverable.     - Catch-All: Detects if the domain accepts all emails (catch-all configuration).   - Intelligent Error Correction: Automatically corrects well-known misspelled email addresses.   - Risk Report: Provides an AI-driven normalized score (200-1000) to evaluate email risk, using predefined thresholds.      [Access Documentation >>](/docs/api-reference/email-insights)  - [**IP Insights:**](/docs/api-reference/ip-insights)   - Connection types: Detects connection types such as `wired`, `mobile`, `enterprise`, `satellite`, `VPN`, `cloud-provider`, `open-proxy`, or `Tor`.   - Geo location: Delivers detailed insights such as country, city, timezone, language preferences, and additional location-based information to enhance regional understanding.   - WHOIS: Provides main details including RIR, ASN, organization, and abuse/admin/technical contacts.   - Trusted Provider Recognition: Identifies if the IP is part of a known trusted provider (e.g., ZTNA - Zero Trust Network Access).   - Blocklist Reports: Retrieves up-to-date blocklist statuses, active reports, and the latest detections.   - Risk Report: Delivers an AI-driven normalized score (200-1000) to evaluate IP risk, supported by predefined thresholds.    [Access Documentation >>](/docs/api-reference/ip-insights)  ### Authentication & Security - **API Key:** Access to the API requires an API key, which must be included in the request headers. Businesses can generate unlimited API keys directly from their account, offering flexibility and ease of use.  - **ACL Rules:** Enhance security with Access Control Lists (ACL), allowing you to restrict API access from specific IP addresses or ranges. This feature provides an additional layer of protection by ensuring only authorized IPs can interact with the API. - **No Query Parameters:** As a precautionary measure, our API avoids the use of query parameters for all operations, including authentication and handling Personally Identifiable Information (PII). This approach minimizes security risks by preventing sensitive data from being exposed in access logs, browser history, cached URLs, debugging tools, or inadvertently shared URLs. All sensitive information is securely transmitted through headers or the request body. 
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RiskReportIp(BaseModel):
+    """
+    ### Risk Level Determination This documentation outlines how the risk level is determined based on a `normalizedScore` generated by a **multivariate linear regression model**. The risk level provides a static representation of thresholds to classify the severity of risk for an entity.  ---  > **IMPORTANT:**  > The risk report model is not available in the free plan. To access this feature, you need to subscribe to a paid plan.  ---  #### How the Score is Generated  The risk score (`normalizedScore`) is computed using a **multivariate linear regression model**, a machine learning approach that evaluates multiple input features to predict the risk score.  ##### Key Features of the Model: 1. **Dynamic Scoring:** The model assigns weights to various risk factors, dynamically updating them based on training with new data. 2. **Constant Training:** The model is continuously retrained with the latest data to improve accuracy and adapt to evolving risk patterns. 3. **Scalability:** The model supports multiple features and their interactions, deriving a comprehensive and reliable risk score.  The output score is normalized to a range of **200–1000** for easier interpretation and alignment with industry practices.  ---  #### Risk Level Thresholds  The risk level is a static representation of the `normalizedScore`, categorized into five distinct levels:  | **Risk Level** | **Score Range**          | **Description**                                                                 | |----------------|--------------------------|---------------------------------------------------------------------------------| | `highest`      | `normalizedScore > 800` | Represents the most critical level of risk. Immediate attention is required.   | | `high`         | `600 < normalizedScore <= 800` | Indicates a high level of risk. Consider mitigation actions promptly.          | | `medium`       | `400 < normalizedScore <= 600` | Reflects a moderate level of risk. Monitoring and possible action advised.     | | `low`          | `300 < normalizedScore <= 400` | Denotes a low level of risk. Regular monitoring is sufficient.                 | | `lowest`       | `normalizedScore <= 300` | The lowest level of risk. Risk is considered negligible or minimal.            |  ---  #### Usage  This risk level determination serves as a human-readable representation of the machine learning model's output. It enables: - **Risk Monitoring:** Identifying entities that require immediate attention. - **Action Prioritization:** Guiding mitigation efforts based on the severity of the risk. - **Decision-Making:** Providing clear thresholds for automated and manual workflows.  ---  #### Key Notes 1. **Dynamic Scoring, Static Levels:**   - While the score is dynamically updated through a multivariate linear regression model, the risk levels remain static to maintain consistency and interpretability.  2. **Customizable Thresholds:**   - The thresholds for the levels are configurable based on organizational needs or domain-specific requirements.  3. **Model Retraining:**    - Regular updates to the model ensure that scores accurately reflect real-world risk trends, improving the reliability of level assignments.  ---  This approach combines the adaptability of multivariate linear regression with the simplicity of static thresholds, offering a robust framework for risk assessment and decision-making.  ---  ### Response Elements 
+    """ # noqa: E501
+    score: Optional[StrictInt] = Field(default=None, description="Risk score normalized to a range of 200–1000.")
+    level: Optional[StrictStr] = Field(default=None, description="Static representation of the risk level.")
+    __properties: ClassVar[List[str]] = ["score", "level"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RiskReportIp from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RiskReportIp from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "score": obj.get("score"),
+            "level": obj.get("level")
+        })
+        return _obj
+
+

{src → opportify_sdk}/ip_insights.py

@@ -15,7 +15,7 @@ class IpInsights:
         """
         self.config = ApiConfiguration()
         self.config.api_key = {"opportifyToken": api_key}
-        self.host = "https://api.opportify.com"
+        self.host = "https://api.opportify.ai"
         self.version = "v1"
         self.debug_mode = False
         self.api_instance = None

{opportify_sdk-0.1.1.dist-info → opportify_sdk-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: opportify_sdk
-Version: 0.1.1
+Version: 0.1.3
 Summary: Opportify Insights API
 Home-page: https://github.com/opportify/opportify-sdk-python
 Author: Opportify & OpenAPI-Generator
@@ -11,6 +11,13 @@ Requires-Dist: urllib3<3.0.0,>=1.25.3
 Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: pydantic>=2
 Requires-Dist: typing-extensions>=4.7.1
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: summary
 
 # Opportify-SDK-Python
 
@@ -97,7 +104,7 @@ except Exception as e:
 
 ```python
 ip_insights.set_version("v1").set_debug_mode(True)
-email_insights.set_version("v1").set_debug_mode(False)
+email_insights.set_version("v1").set_debug_mode(True)
 ```
 
 ## About this package

opportify_sdk-0.1.3.dist-info/RECORD

@@ -0,0 +1,53 @@
+openapi_client/__init__.py,sha256=StzTZIaM5CNZPP5MDOf_TO1vkRkdS3tGsNv3_Qu3NQU,6356
+openapi_client/api_client.py,sha256=v_S3upItmHMMZXNSWYBtFIy2SSjt_MLAOcXpMiBST8g,30433
+openapi_client/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
+openapi_client/configuration.py,sha256=8U7Zd4rziMXTXvviDquxlSdDgSuSmsttGYeGDNOkod0,21544
+openapi_client/exceptions.py,sha256=tHCC6Ij9c8ScVmZyCL5thgYXpopuUG1NSpILlHI_-Sg,8938
+openapi_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openapi_client/rest.py,sha256=QwKi4N39ZgYVtBPrXQzw8bkhpiZbfUUPuWhi44tMst0,12378
+openapi_client/api/__init__.py,sha256=_2MpmNT7so7K9CyzP-_2Sd_1EU8-Gq10jtUKccY86-Q,176
+openapi_client/api/email_insights_api.py,sha256=hLzQQ__3skAxZSElPD-hzNylWmRAEawcfPzecLSZNZs,20799
+openapi_client/api/ip_insights_api.py,sha256=FpnXjak3cNO9zrRIoAVrHKOZ0g8qieFTabqKhMmzVC8,21921
+openapi_client/models/__init__.py,sha256=MgeOgO8BXAbb_ZqEj1bXmQcEzLj5vz2g_QHpefnNvM0,5684
+openapi_client/models/abuse_contact.py,sha256=MqF8oUU6hxU4vLXlC6ykcpJiZhjRw6EiJDfeDWYCBxQ,6560
+openapi_client/models/admin_contact.py,sha256=HOmd_CnYyKtOPR-mGL3hbMZ8E5_TKlBlFgMVZOvfGH8,6560
+openapi_client/models/analyze_email200_response.py,sha256=K_dG0wDv37iR4dmcRwUCshYlbnjT0JYIJpa81Z55ZeQ,8516
+openapi_client/models/analyze_email400_response.py,sha256=BrhikNZYFE0L1SScOlmZKh1CQNsOWi8m8e1fOzG9nus,5843
+openapi_client/models/analyze_email400_response_error.py,sha256=oxfixZuiMnwbqRwdDzO7q4MKhQgVyFwxjOKdXpVLc_E,8391
+openapi_client/models/analyze_email403_response.py,sha256=u2mVjGG6jgQjqPL7UOeXo17DyJswvZucsckO0sF3gFY,5843
+openapi_client/models/analyze_email403_response_error.py,sha256=hhu2Pe8evQ0yagEud6W5RwGgYG90x6Ky_D7qVBB3zZw,8306
+openapi_client/models/analyze_email500_response.py,sha256=gAKw0QyVwBZdr52qCrSbRA8kdtBcIn-oW83hvK411j0,5843
+openapi_client/models/analyze_email500_response_error.py,sha256=LuKvELP551F70uAKOnQ_0eVI9fK1V5RLdksgCMtTEwA,5615
+openapi_client/models/analyze_email_request.py,sha256=yzu8AV6wBKWhbBUO7GtsCuKgX_KYJAg9c8bIWjMPJc4,6063
+openapi_client/models/analyze_ip200_response.py,sha256=4Pz8nWAbPsBFLo6Ncwaqb2xfMPBsagf8VsmjF_PX_tM,9152
+openapi_client/models/analyze_ip400_response.py,sha256=aLPWgDU-QbKLzTD1KzHna3VURVRfqwP5m8WM4GINZPM,5819
+openapi_client/models/analyze_ip400_response_error.py,sha256=X2wjsiTtaSWmC-zeKYgwtlQ-N_onhB3Fv2pvFhsOWmg,8486
+openapi_client/models/analyze_ip404_response.py,sha256=mzS98l1DlVKFCFaOmhBc9XjUA7DdGJSXDBmFuL8Yjyk,5748
+openapi_client/models/analyze_ip500_response.py,sha256=FPgWlfRyaFWGNk4xmh6UBiG_Xiys-i7IMZOWu2HoCY8,5768
+openapi_client/models/analyze_ip_request.py,sha256=SZHr8Gd0mRrziip0VH5bgPZu84JCXGKjTSOzO8iSczc,5741
+openapi_client/models/asn.py,sha256=_PtsmGJCAogM2DryLp5SuIgKZ_5H4zkLQvBcYV8-F90,6237
+openapi_client/models/block_listed.py,sha256=UK0LxB8cPQzr6RP18p1GfLiLyVNJqPdYYrJyuhQiwdU,6815
+openapi_client/models/email_dns.py,sha256=0Ttu0-pEQke0lnwkA4Tq8ZKvED6nRn6abSGkPqVEa24,5546
+openapi_client/models/geo.py,sha256=GtTV2s0pDguxBBCbkViNidTmFmRsxfMqMwbb0IWnYkQ,9879
+openapi_client/models/internalerror.py,sha256=_LhOiY2kPKsN_WDU7tVuY65A9-mNiamedWqJddWKRZQ,5555
+openapi_client/models/invalidemail.py,sha256=-ofiTmHw2O61p_hzzELf_wpa9zgi5FjV_Kc-duJFY-o,5551
+openapi_client/models/invalidplan.py,sha256=uwgCaZ2MWv6fUkz2ptX8zivFz8gMLXVWzPjdi66Pi_U,5547
+openapi_client/models/invalidtoken.py,sha256=YxplE1S-VDOol7_zEBcRzpS_G630QeqQPHNz20LvN8o,5551
+openapi_client/models/ipvalidationfailed.py,sha256=Clmw3EqB48h6mfhUzNnWvgO5IzfLq03pMbtWfzxD8xo,5575
+openapi_client/models/malformedrequest.py,sha256=gaOr0Bh_d_Fy0gstnQzurGUD6JAF_kk2fi7Y7PnitB0,5567
+openapi_client/models/malformedrequest1.py,sha256=PZ1e26zin5yhpjwnsuht8XNIHweURLb3n1NwR8rTvV8,5571
+openapi_client/models/notfound.py,sha256=HifW-VdCOp0mn5RQdeM6QVQR1kZc5PlENAik0b9SGDo,5535
+openapi_client/models/organization.py,sha256=IcJr7vJXyKwE9VjlWwJh1PeRar3_gQ4sNkvniMSLQzk,7130
+openapi_client/models/risk_report.py,sha256=ANg1NOURvS-2mXbU8lNHgAlTNuNUYw4NkF43TR5ujsc,9132
+openapi_client/models/risk_report_email.py,sha256=Lz7DCiTIE4x1DCE5RsbdxlPB4yEwbDpA0RiK0zKh6lY,9789
+openapi_client/models/risk_report_ip.py,sha256=ctLbSRt1llA5a0KI3nJVir4Kj0BoHcUd-OKM4QD9f78,9138
+openapi_client/models/tech_contact.py,sha256=AF9myIFacYEMknGN_gGrqjRn8_mpiI7Y_fGhp1wHWpE,6549
+openapi_client/models/trusted_provider.py,sha256=DI33v3eTc6fUhx5NqbjOE7ZpA2VcKbNLSV5MWqodGB0,6174
+openapi_client/models/whois.py,sha256=Yoo9QsUHPMjo9nwSR_H8ZHMhP2fYNRug3jBk3Do6vcw,8833
+opportify_sdk/__init__.py,sha256=b5dO5TZ0ac8L7meGstmpAzIWXS9jwPqV1EruY32dffk,139
+opportify_sdk/email_insights.py,sha256=i4NaYLZiJfXeHaNRZz3V15q8nsgGMcC37iBG5AaDj-Q,3283
+opportify_sdk/ip_insights.py,sha256=hJOAqrETps6J8J5Gb5BWeisDLsdQ4ndUH9namV4f0G0,3007
+opportify_sdk-0.1.3.dist-info/METADATA,sha256=wjJ-x4MxXgqTL5WXo1Ej0JPPqvVkhA_VH-fmxXNzhV4,2606
+opportify_sdk-0.1.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+opportify_sdk-0.1.3.dist-info/top_level.txt,sha256=90CufmKPfMOr0lxs06ndbpvXPdVbmArXAorIu2p-giU,29
+opportify_sdk-0.1.3.dist-info/RECORD,,

{opportify_sdk-0.1.1.dist-info → opportify_sdk-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

opportify_sdk-0.1.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+openapi_client
+opportify_sdk

opportify_sdk-0.1.1.dist-info/RECORD

@@ -1,49 +0,0 @@
-lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lib/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lib/v1/openapi_client/__init__.py,sha256=4YbyZsJjF4Ig1mWXt6fxS7uhdr0uDEQPZQ-xsbDIwDI,5986
-lib/v1/openapi_client/api_client.py,sha256=v_S3upItmHMMZXNSWYBtFIy2SSjt_MLAOcXpMiBST8g,30433
-lib/v1/openapi_client/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-lib/v1/openapi_client/configuration.py,sha256=8U7Zd4rziMXTXvviDquxlSdDgSuSmsttGYeGDNOkod0,21544
-lib/v1/openapi_client/exceptions.py,sha256=tHCC6Ij9c8ScVmZyCL5thgYXpopuUG1NSpILlHI_-Sg,8938
-lib/v1/openapi_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lib/v1/openapi_client/rest.py,sha256=QwKi4N39ZgYVtBPrXQzw8bkhpiZbfUUPuWhi44tMst0,12378
-lib/v1/openapi_client/api/__init__.py,sha256=_2MpmNT7so7K9CyzP-_2Sd_1EU8-Gq10jtUKccY86-Q,176
-lib/v1/openapi_client/api/email_insights_api.py,sha256=bbstLmF0CoBah5qxImN--ic1lBD1uMZ7jr0-ZpWUoAc,20667
-lib/v1/openapi_client/api/ip_insights_api.py,sha256=oCmkRBxVMaVBzrBsA6BoumRl7PvhlyMJla-xYPHMxww,21817
-lib/v1/openapi_client/models/__init__.py,sha256=9VT3hqjFqoCePDx2FhQ2qHjG4dIUbzc8VkBWgsrPtyc,5314
-lib/v1/openapi_client/models/abuse_contact.py,sha256=MqF8oUU6hxU4vLXlC6ykcpJiZhjRw6EiJDfeDWYCBxQ,6560
-lib/v1/openapi_client/models/admin_contact.py,sha256=HOmd_CnYyKtOPR-mGL3hbMZ8E5_TKlBlFgMVZOvfGH8,6560
-lib/v1/openapi_client/models/analyze_email200_response.py,sha256=0YCuUfjKTB_J7FPCHeiPDG-bK5NMf-U-qFvGtQG6h-c,8043
-lib/v1/openapi_client/models/analyze_email400_response.py,sha256=BrhikNZYFE0L1SScOlmZKh1CQNsOWi8m8e1fOzG9nus,5843
-lib/v1/openapi_client/models/analyze_email400_response_error.py,sha256=oxfixZuiMnwbqRwdDzO7q4MKhQgVyFwxjOKdXpVLc_E,8391
-lib/v1/openapi_client/models/analyze_email500_response.py,sha256=gAKw0QyVwBZdr52qCrSbRA8kdtBcIn-oW83hvK411j0,5843
-lib/v1/openapi_client/models/analyze_email500_response_error.py,sha256=LuKvELP551F70uAKOnQ_0eVI9fK1V5RLdksgCMtTEwA,5615
-lib/v1/openapi_client/models/analyze_email_request.py,sha256=yzu8AV6wBKWhbBUO7GtsCuKgX_KYJAg9c8bIWjMPJc4,6063
-lib/v1/openapi_client/models/analyze_ip200_response.py,sha256=_8uU_YPLrwTc-Mth3keN7TlWkm7jCiIYi2i1UHzWySk,9143
-lib/v1/openapi_client/models/analyze_ip400_response.py,sha256=aLPWgDU-QbKLzTD1KzHna3VURVRfqwP5m8WM4GINZPM,5819
-lib/v1/openapi_client/models/analyze_ip400_response_error.py,sha256=X2wjsiTtaSWmC-zeKYgwtlQ-N_onhB3Fv2pvFhsOWmg,8486
-lib/v1/openapi_client/models/analyze_ip404_response.py,sha256=mzS98l1DlVKFCFaOmhBc9XjUA7DdGJSXDBmFuL8Yjyk,5748
-lib/v1/openapi_client/models/analyze_ip500_response.py,sha256=FPgWlfRyaFWGNk4xmh6UBiG_Xiys-i7IMZOWu2HoCY8,5768
-lib/v1/openapi_client/models/analyze_ip_request.py,sha256=SZHr8Gd0mRrziip0VH5bgPZu84JCXGKjTSOzO8iSczc,5741
-lib/v1/openapi_client/models/asn.py,sha256=_PtsmGJCAogM2DryLp5SuIgKZ_5H4zkLQvBcYV8-F90,6237
-lib/v1/openapi_client/models/block_listed.py,sha256=UK0LxB8cPQzr6RP18p1GfLiLyVNJqPdYYrJyuhQiwdU,6815
-lib/v1/openapi_client/models/email_dns.py,sha256=0Ttu0-pEQke0lnwkA4Tq8ZKvED6nRn6abSGkPqVEa24,5546
-lib/v1/openapi_client/models/geo.py,sha256=GtTV2s0pDguxBBCbkViNidTmFmRsxfMqMwbb0IWnYkQ,9879
-lib/v1/openapi_client/models/internalerror.py,sha256=_LhOiY2kPKsN_WDU7tVuY65A9-mNiamedWqJddWKRZQ,5555
-lib/v1/openapi_client/models/invalidemail.py,sha256=-ofiTmHw2O61p_hzzELf_wpa9zgi5FjV_Kc-duJFY-o,5551
-lib/v1/openapi_client/models/ipvalidationfailed.py,sha256=Clmw3EqB48h6mfhUzNnWvgO5IzfLq03pMbtWfzxD8xo,5575
-lib/v1/openapi_client/models/malformedrequest.py,sha256=gaOr0Bh_d_Fy0gstnQzurGUD6JAF_kk2fi7Y7PnitB0,5567
-lib/v1/openapi_client/models/malformedrequest1.py,sha256=PZ1e26zin5yhpjwnsuht8XNIHweURLb3n1NwR8rTvV8,5571
-lib/v1/openapi_client/models/notfound.py,sha256=HifW-VdCOp0mn5RQdeM6QVQR1kZc5PlENAik0b9SGDo,5535
-lib/v1/openapi_client/models/organization.py,sha256=IcJr7vJXyKwE9VjlWwJh1PeRar3_gQ4sNkvniMSLQzk,7130
-lib/v1/openapi_client/models/risk_report.py,sha256=ANg1NOURvS-2mXbU8lNHgAlTNuNUYw4NkF43TR5ujsc,9132
-lib/v1/openapi_client/models/tech_contact.py,sha256=AF9myIFacYEMknGN_gGrqjRn8_mpiI7Y_fGhp1wHWpE,6549
-lib/v1/openapi_client/models/trusted_provider.py,sha256=DI33v3eTc6fUhx5NqbjOE7ZpA2VcKbNLSV5MWqodGB0,6174
-lib/v1/openapi_client/models/whois.py,sha256=Yoo9QsUHPMjo9nwSR_H8ZHMhP2fYNRug3jBk3Do6vcw,8833
-src/__init__.py,sha256=b5dO5TZ0ac8L7meGstmpAzIWXS9jwPqV1EruY32dffk,139
-src/email_insights.py,sha256=i4NaYLZiJfXeHaNRZz3V15q8nsgGMcC37iBG5AaDj-Q,3283
-src/ip_insights.py,sha256=yaydXslmi5e_cSFCniJTFCWazE1Zw4K-ZlXiLxGbfkU,3008
-opportify_sdk-0.1.1.dist-info/METADATA,sha256=6bRgIBmdzuGi30ooeYSN51obEPgcVW-etXYZI7SwV8o,2459
-opportify_sdk-0.1.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-opportify_sdk-0.1.1.dist-info/top_level.txt,sha256=4zVviOxxwoucHwO4Z7OzyNBMPn7vZjaTdyfvDO-OZfg,8
-opportify_sdk-0.1.1.dist-info/RECORD,,

opportify_sdk-0.1.1.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-lib
-src