ghostcrawl 2.1.2__tar.gz → 2.2.0__tar.gz

ghostcrawl-2.2.0/LICENSE

@@ -0,0 +1,46 @@
+GhostCrawl Software License
+
+Copyright (c) 2026 GhostCrawl, LLC. All rights reserved.
+
+This software — including the GhostCrawl SDKs, command-line interface, example
+code, documentation, and the GhostCrawl self-host image (collectively, the
+"Software") — is the proprietary property of GhostCrawl, LLC ("GhostCrawl") and
+its licensors. It is licensed, not sold.
+
+1. LICENSE GRANT. Subject to your continuous compliance with this License and the
+   GhostCrawl Terms of Service (https://docs.ghostcrawl.io/legal/terms),
+   GhostCrawl grants you a limited, revocable, non-exclusive, non-transferable,
+   and non-sublicensable license to install and use the Software, including
+   within your own applications, solely to access and use the GhostCrawl service
+   under a valid GhostCrawl account.
+
+2. RESTRICTIONS. Except as expressly permitted in Section 1, you may not, in
+   whole or in part: (a) copy the Software except as strictly necessary to use it
+   as permitted; (b) modify, adapt, translate, or create derivative works of the
+   Software; (c) distribute, publish, sublicense, sell, resell, rent, lease,
+   lend, or otherwise transfer the Software, or make it available to any third
+   party, including as a hosted or managed service; (d) reverse engineer,
+   decompile, disassemble, or otherwise attempt to derive the source code,
+   structure, or internal design of any compiled component of the Software;
+   (e) circumvent, disable, or tamper with any license, authentication,
+   usage-metering, watermarking, or security mechanism; or (f) remove, alter, or
+   obscure any proprietary, copyright, or attribution notice.
+
+3. OWNERSHIP. GhostCrawl and its licensors retain all right, title, and interest
+   in and to the Software and all intellectual property rights therein. No rights
+   are granted to you except as expressly set out in this License. All rights
+   reserved.
+
+4. TERMINATION. This License terminates automatically, without notice, if you
+   breach any of its terms or cease to maintain a valid GhostCrawl account where
+   one is required. Upon termination you must cease all use of the Software and
+   destroy all copies in your possession or control.
+
+5. NO WARRANTY; LIMITATION OF LIABILITY. THE SOFTWARE IS PROVIDED "AS IS" WITHOUT
+   WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. TO THE MAXIMUM EXTENT PERMITTED BY
+   LAW, GHOSTCRAWL AND ITS LICENSORS WILL NOT BE LIABLE FOR ANY CLAIM, DAMAGES, OR
+   OTHER LIABILITY ARISING FROM OR IN CONNECTION WITH THE SOFTWARE OR ITS USE. The
+   GhostCrawl Terms of Service and Acceptable Use Policy
+   (https://docs.ghostcrawl.io/legal/terms) are incorporated by reference.
+
+For licensing inquiries, contact legal@ghostcrawl.io.

{ghostcrawl-2.1.2 → ghostcrawl-2.2.0}/MANIFEST.in

@@ -5,5 +5,4 @@ prune tests
 prune ghostcrawl/tests
 prune examples
 prune _operator
-recursive-exclude ghostcrawl reference.md
 global-exclude __pycache__ *.pyc

ghostcrawl-2.2.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: ghostcrawl
+Version: 2.2.0
+Summary: Official Python SDK for the Ghostcrawl local orchestration API.
+Author: Ghostcrawl
+License: Proprietary — see LICENSE
+Project-URL: Homepage, https://github.com/ghostcrawl/ghostcrawl
+Keywords: ghostcrawl,scraping,browser,automation,agent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.13
+Requires-Dist: typer>=0.12
+Requires-Dist: mcp>=1.27.1
+Requires-Dist: microsoft-kiota-abstractions>=1.7.0
+Requires-Dist: microsoft-kiota-http>=1.10.0
+Requires-Dist: microsoft-kiota-serialization-json>=1.7.0
+Requires-Dist: microsoft-kiota-serialization-text>=1.0.0
+Requires-Dist: microsoft-kiota-serialization-form>=1.0.0
+Requires-Dist: microsoft-kiota-serialization-multipart>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: respx>=0.23.1; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# ghostcrawl — Python SDK
+
+The official Python client for the [GhostCrawl](https://ghostcrawl.io) API. Collect web data at scale — scrape, crawl, search, extract structured data, manage browser sessions, and automate the full data-collection pipeline.
+
+## Install
+
+```bash
+pip install ghostcrawl
+```
+
+Requires Python 3.10+. Runtime dependencies: `httpx>=0.28.1`.
+
+## Quickstart
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+# Reads GHOSTCRAWL_API_KEY from environment, or pass token= explicitly
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Scrape a URL
+result = client.scrape(url="https://example.com", format="markdown")
+print(result["content"])
+
+# Start a crawl
+run = client.crawl_runs.start(url="https://example.com", max_depth=2, max_pages=50)
+print(run["run_id"])
+
+# Web search
+results = client.search(query="latest AI research", engine="google", limit=10)
+for r in results["results"]:
+    print(r["title"], r["url"])
+```
+
+## Authentication
+
+```python
+import os
+from ghostcrawl import GhostcrawlClient
+
+# Option 1: pass token directly
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Option 2: set environment variable (recommended for production)
+os.environ["GHOSTCRAWL_API_KEY"] = "gck_live_YOUR_KEY"
+client = GhostcrawlClient()
+```
+
+Every request sends `Authorization: Bearer <token>`. This is the only auth scheme the API accepts.
+
+## Extract structured data
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Define a schema and extract matching data
+data = client.extract(
+    url="https://example.com/product",
+    schema={
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "price": {"type": "number"},
+            "description": {"type": "string"},
+        },
+    },
+)
+print(data["name"], data["price"])
+```
+
+## Browser sessions
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Create a session
+session = client.sessions.create(profile_name="my-profile")
+session_id = session["session_id"]
+
+# Extend and release
+client.sessions.extend(session_id, duration_seconds=600)
+client.sessions.release(session_id)
+```
+
+## Error handling
+
+```python
+from ghostcrawl import GhostcrawlClient, AuthenticationError, RateLimitError, APIError
+
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+try:
+    result = client.scrape(url="https://example.com")
+except AuthenticationError:
+    print("Invalid API key — check your token")
+except RateLimitError:
+    print("Rate limit reached — retry after a short delay")
+except APIError as e:
+    print(f"Server error: {e.status_code}")
+```
+
+## Context manager
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+with GhostcrawlClient(token="gck_live_YOUR_KEY") as client:
+    result = client.scrape(url="https://example.com")
+    print(result)
+# HTTP connection is closed automatically
+```
+
+## All resources
+
+| Resource | Client attribute | Key operations |
+|----------|-----------------|----------------|
+| Scraping | `client.scrape(url=…)` | Render and return page content |
+| Web search | `client.search(query=…)` | Search Google, Bing, DuckDuckGo |
+| Data extraction | `client.extract(url=…, schema=…)` | Structured JSON from any page |
+| Deep crawl | `client.crawl(url=…)` | Crawl a site depth-first |
+| URL map | `client.map(url=…)` | Discover all reachable URLs |
+| Crawl runs | `client.crawl_runs` | start, list, get, cancel |
+| Sessions | `client.sessions` | create, extend, release |
+| Profiles | `client.profiles` | list, get, create, update, delete |
+| Webhooks | `client.webhooks` | list, get, create, delete, rotate-secret |
+| Schedules | `client.schedules` | list, get, create, delete |
+| Datasets | `client.datasets` | list, get, create, delete, append rows |
+| Recordings | `client.recordings` | list, get, delete |
+| Key-Value Store | `client.kv` | get, set, delete |
+| Account | `client.me()` | Get account info and usage |
+
+## LangChain integration
+
+```bash
+pip install ghostcrawl-langchain
+```
+
+```python
+from ghostcrawl_langchain import GhostcrawlScrape, GhostcrawlSearch
+
+scrape_tool = GhostcrawlScrape()
+search_tool = GhostcrawlSearch()
+```
+
+## Self-hosted
+
+```python
+client = GhostcrawlClient(
+    token="gck_live_YOUR_KEY",
+    base_url="http://localhost:8080",  # your self-hosted instance
+)
+```
+
+## License
+
+Proprietary — GhostCrawl Software License. See [LICENSE](LICENSE).

ghostcrawl-2.2.0/README.md

@@ -0,0 +1,160 @@
+# ghostcrawl — Python SDK
+
+The official Python client for the [GhostCrawl](https://ghostcrawl.io) API. Collect web data at scale — scrape, crawl, search, extract structured data, manage browser sessions, and automate the full data-collection pipeline.
+
+## Install
+
+```bash
+pip install ghostcrawl
+```
+
+Requires Python 3.10+. Runtime dependencies: `httpx>=0.28.1`.
+
+## Quickstart
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+# Reads GHOSTCRAWL_API_KEY from environment, or pass token= explicitly
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Scrape a URL
+result = client.scrape(url="https://example.com", format="markdown")
+print(result["content"])
+
+# Start a crawl
+run = client.crawl_runs.start(url="https://example.com", max_depth=2, max_pages=50)
+print(run["run_id"])
+
+# Web search
+results = client.search(query="latest AI research", engine="google", limit=10)
+for r in results["results"]:
+    print(r["title"], r["url"])
+```
+
+## Authentication
+
+```python
+import os
+from ghostcrawl import GhostcrawlClient
+
+# Option 1: pass token directly
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Option 2: set environment variable (recommended for production)
+os.environ["GHOSTCRAWL_API_KEY"] = "gck_live_YOUR_KEY"
+client = GhostcrawlClient()
+```
+
+Every request sends `Authorization: Bearer <token>`. This is the only auth scheme the API accepts.
+
+## Extract structured data
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Define a schema and extract matching data
+data = client.extract(
+    url="https://example.com/product",
+    schema={
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "price": {"type": "number"},
+            "description": {"type": "string"},
+        },
+    },
+)
+print(data["name"], data["price"])
+```
+
+## Browser sessions
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+# Create a session
+session = client.sessions.create(profile_name="my-profile")
+session_id = session["session_id"]
+
+# Extend and release
+client.sessions.extend(session_id, duration_seconds=600)
+client.sessions.release(session_id)
+```
+
+## Error handling
+
+```python
+from ghostcrawl import GhostcrawlClient, AuthenticationError, RateLimitError, APIError
+
+client = GhostcrawlClient(token="gck_live_YOUR_KEY")
+
+try:
+    result = client.scrape(url="https://example.com")
+except AuthenticationError:
+    print("Invalid API key — check your token")
+except RateLimitError:
+    print("Rate limit reached — retry after a short delay")
+except APIError as e:
+    print(f"Server error: {e.status_code}")
+```
+
+## Context manager
+
+```python
+from ghostcrawl import GhostcrawlClient
+
+with GhostcrawlClient(token="gck_live_YOUR_KEY") as client:
+    result = client.scrape(url="https://example.com")
+    print(result)
+# HTTP connection is closed automatically
+```
+
+## All resources
+
+| Resource | Client attribute | Key operations |
+|----------|-----------------|----------------|
+| Scraping | `client.scrape(url=…)` | Render and return page content |
+| Web search | `client.search(query=…)` | Search Google, Bing, DuckDuckGo |
+| Data extraction | `client.extract(url=…, schema=…)` | Structured JSON from any page |
+| Deep crawl | `client.crawl(url=…)` | Crawl a site depth-first |
+| URL map | `client.map(url=…)` | Discover all reachable URLs |
+| Crawl runs | `client.crawl_runs` | start, list, get, cancel |
+| Sessions | `client.sessions` | create, extend, release |
+| Profiles | `client.profiles` | list, get, create, update, delete |
+| Webhooks | `client.webhooks` | list, get, create, delete, rotate-secret |
+| Schedules | `client.schedules` | list, get, create, delete |
+| Datasets | `client.datasets` | list, get, create, delete, append rows |
+| Recordings | `client.recordings` | list, get, delete |
+| Key-Value Store | `client.kv` | get, set, delete |
+| Account | `client.me()` | Get account info and usage |
+
+## LangChain integration
+
+```bash
+pip install ghostcrawl-langchain
+```
+
+```python
+from ghostcrawl_langchain import GhostcrawlScrape, GhostcrawlSearch
+
+scrape_tool = GhostcrawlScrape()
+search_tool = GhostcrawlSearch()
+```
+
+## Self-hosted
+
+```python
+client = GhostcrawlClient(
+    token="gck_live_YOUR_KEY",
+    base_url="http://localhost:8080",  # your self-hosted instance
+)
+```
+
+## License
+
+Proprietary — GhostCrawl Software License. See [LICENSE](LICENSE).

ghostcrawl-2.2.0/_generated/ghostcrawl_client.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from collections.abc import Callable
+from kiota_abstractions.api_client_builder import enable_backing_store_for_serialization_writer_factory, register_default_deserializer, register_default_serializer
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.request_adapter import RequestAdapter
+from kiota_abstractions.serialization import ParseNodeFactoryRegistry, SerializationWriterFactoryRegistry
+from kiota_serialization_form.form_parse_node_factory import FormParseNodeFactory
+from kiota_serialization_form.form_serialization_writer_factory import FormSerializationWriterFactory
+from kiota_serialization_json.json_parse_node_factory import JsonParseNodeFactory
+from kiota_serialization_json.json_serialization_writer_factory import JsonSerializationWriterFactory
+from kiota_serialization_multipart.multipart_serialization_writer_factory import MultipartSerializationWriterFactory
+from kiota_serialization_text.text_parse_node_factory import TextParseNodeFactory
+from kiota_serialization_text.text_serialization_writer_factory import TextSerializationWriterFactory
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .v1.v1_request_builder import V1RequestBuilder
+
+class GhostcrawlClient(BaseRequestBuilder):
+    """
+    The main entry point of the SDK, exposes the configuration and the fluent API.
+    """
+    def __init__(self,request_adapter: RequestAdapter) -> None:
+        """
+        Instantiates a new GhostcrawlClient and sets the default values.
+        param request_adapter: The request adapter to use to execute the requests.
+        Returns: None
+        """
+        if request_adapter is None:
+            raise TypeError("request_adapter cannot be null.")
+        super().__init__(request_adapter, "{+baseurl}", None)
+        register_default_serializer(JsonSerializationWriterFactory)
+        register_default_serializer(TextSerializationWriterFactory)
+        register_default_serializer(FormSerializationWriterFactory)
+        register_default_serializer(MultipartSerializationWriterFactory)
+        register_default_deserializer(JsonParseNodeFactory)
+        register_default_deserializer(TextParseNodeFactory)
+        register_default_deserializer(FormParseNodeFactory)
+    
+    @property
+    def v1(self) -> V1RequestBuilder:
+        """
+        The v1 property
+        """
+        from .v1.v1_request_builder import V1RequestBuilder
+
+        return V1RequestBuilder(self.request_adapter, self.path_parameters)
+    
+

ghostcrawl-2.2.0/_generated/models/audit_event_out.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .audit_event_out_actor_ip import AuditEventOut_actor_ip
+    from .audit_event_out_actor_token_id import AuditEventOut_actor_token_id
+    from .audit_event_out_actor_user_agent import AuditEventOut_actor_user_agent
+    from .audit_event_out_actor_user_id import AuditEventOut_actor_user_id
+    from .audit_event_out_metadata import AuditEventOut_metadata
+    from .audit_event_out_org_id import AuditEventOut_org_id
+    from .audit_event_out_target_id import AuditEventOut_target_id
+    from .audit_event_out_target_kind import AuditEventOut_target_kind
+
+@dataclass
+class AuditEventOut(AdditionalDataHolder, Parsable):
+    """
+    Public audit event shape — chain hashes excluded.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The action property
+    action: Optional[str] = None
+    # The actor_ip property
+    actor_ip: Optional[AuditEventOut_actor_ip] = None
+    # The actor_token_id property
+    actor_token_id: Optional[AuditEventOut_actor_token_id] = None
+    # The actor_user_agent property
+    actor_user_agent: Optional[AuditEventOut_actor_user_agent] = None
+    # The actor_user_id property
+    actor_user_id: Optional[AuditEventOut_actor_user_id] = None
+    # The created_at property
+    created_at: Optional[datetime.datetime] = None
+    # The id property
+    id: Optional[str] = None
+    # The metadata property
+    metadata: Optional[AuditEventOut_metadata] = None
+    # The org_id property
+    org_id: Optional[AuditEventOut_org_id] = None
+    # The outcome property
+    outcome: Optional[str] = None
+    # The target_id property
+    target_id: Optional[AuditEventOut_target_id] = None
+    # The target_kind property
+    target_kind: Optional[AuditEventOut_target_kind] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AuditEventOut:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AuditEventOut
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AuditEventOut()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_event_out_actor_ip import AuditEventOut_actor_ip
+        from .audit_event_out_actor_token_id import AuditEventOut_actor_token_id
+        from .audit_event_out_actor_user_agent import AuditEventOut_actor_user_agent
+        from .audit_event_out_actor_user_id import AuditEventOut_actor_user_id
+        from .audit_event_out_metadata import AuditEventOut_metadata
+        from .audit_event_out_org_id import AuditEventOut_org_id
+        from .audit_event_out_target_id import AuditEventOut_target_id
+        from .audit_event_out_target_kind import AuditEventOut_target_kind
+
+        from .audit_event_out_actor_ip import AuditEventOut_actor_ip
+        from .audit_event_out_actor_token_id import AuditEventOut_actor_token_id
+        from .audit_event_out_actor_user_agent import AuditEventOut_actor_user_agent
+        from .audit_event_out_actor_user_id import AuditEventOut_actor_user_id
+        from .audit_event_out_metadata import AuditEventOut_metadata
+        from .audit_event_out_org_id import AuditEventOut_org_id
+        from .audit_event_out_target_id import AuditEventOut_target_id
+        from .audit_event_out_target_kind import AuditEventOut_target_kind
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "action": lambda n : setattr(self, 'action', n.get_str_value()),
+            "actor_ip": lambda n : setattr(self, 'actor_ip', n.get_object_value(AuditEventOut_actor_ip)),
+            "actor_token_id": lambda n : setattr(self, 'actor_token_id', n.get_object_value(AuditEventOut_actor_token_id)),
+            "actor_user_agent": lambda n : setattr(self, 'actor_user_agent', n.get_object_value(AuditEventOut_actor_user_agent)),
+            "actor_user_id": lambda n : setattr(self, 'actor_user_id', n.get_object_value(AuditEventOut_actor_user_id)),
+            "created_at": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "metadata": lambda n : setattr(self, 'metadata', n.get_object_value(AuditEventOut_metadata)),
+            "org_id": lambda n : setattr(self, 'org_id', n.get_object_value(AuditEventOut_org_id)),
+            "outcome": lambda n : setattr(self, 'outcome', n.get_str_value()),
+            "target_id": lambda n : setattr(self, 'target_id', n.get_object_value(AuditEventOut_target_id)),
+            "target_kind": lambda n : setattr(self, 'target_kind', n.get_object_value(AuditEventOut_target_kind)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("action", self.action)
+        writer.write_object_value("actor_ip", self.actor_ip)
+        writer.write_object_value("actor_token_id", self.actor_token_id)
+        writer.write_object_value("actor_user_agent", self.actor_user_agent)
+        writer.write_object_value("actor_user_id", self.actor_user_id)
+        writer.write_datetime_value("created_at", self.created_at)
+        writer.write_str_value("id", self.id)
+        writer.write_object_value("metadata", self.metadata)
+        writer.write_object_value("org_id", self.org_id)
+        writer.write_str_value("outcome", self.outcome)
+        writer.write_object_value("target_id", self.target_id)
+        writer.write_object_value("target_kind", self.target_kind)
+        writer.write_additional_data_value(self.additional_data)
+    
+

ghostcrawl-2.2.0/_generated/models/audit_event_out_actor_ip.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import ComposedTypeWrapper, Parsable, ParseNode, ParseNodeHelper, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .audit_event_out_actor_ip_member1 import AuditEventOut_actor_ipMember1
+
+@dataclass
+class AuditEventOut_actor_ip(ComposedTypeWrapper, Parsable):
+    """
+    Composed type wrapper for classes AuditEventOut_actor_ipMember1, str
+    """
+    # Composed type representation for type AuditEventOut_actor_ipMember1
+    audit_event_out_actor_ip_member1: Optional[AuditEventOut_actor_ipMember1] = None
+    # Composed type representation for type str
+    string: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AuditEventOut_actor_ip:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AuditEventOut_actor_ip
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        result = AuditEventOut_actor_ip()
+        if string_value := parse_node.get_str_value():
+            result.string = string_value
+        else:
+            from .audit_event_out_actor_ip_member1 import AuditEventOut_actor_ipMember1
+
+            result.audit_event_out_actor_ip_member1 = AuditEventOut_actor_ipMember1()
+        return result
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_event_out_actor_ip_member1 import AuditEventOut_actor_ipMember1
+
+        if self.audit_event_out_actor_ip_member1:
+            return ParseNodeHelper.merge_deserializers_for_intersection_wrapper(self.audit_event_out_actor_ip_member1)
+        return {}
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        if self.string:
+            writer.write_str_value(None, self.string)
+        else:
+            writer.write_object_value(None, self.audit_event_out_actor_ip_member1)
+    
+

ghostcrawl-2.2.0/_generated/models/audit_event_out_actor_ip_member1.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AuditEventOut_actor_ipMember1(AdditionalDataHolder, Parsable):
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AuditEventOut_actor_ipMember1:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AuditEventOut_actor_ipMember1
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AuditEventOut_actor_ipMember1()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_additional_data_value(self.additional_data)
+    
+