infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/workers/dependencies.py

@@ -0,0 +1,143 @@
+from typing import Any
+
+from fast_depends import Depends, inject
+from infrahub_sdk.client import InfrahubClient
+from infrahub_sdk.config import Config
+
+from infrahub import config
+from infrahub.components import ComponentType
+from infrahub.constants.environment import INSTALLATION_TYPE
+from infrahub.database import InfrahubDatabase, get_db
+from infrahub.services.adapters.cache import InfrahubCache
+from infrahub.services.adapters.event import InfrahubEventService
+from infrahub.services.adapters.http import InfrahubHTTP
+from infrahub.services.adapters.http.httpx import HttpxAdapter
+from infrahub.services.adapters.message_bus import InfrahubMessageBus
+from infrahub.services.adapters.workflow import InfrahubWorkflow
+from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
+from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
+from infrahub.services.component import InfrahubComponent
+
+_singletons: dict[str, Any] = {}
+
+
+def set_component_type(component_type: ComponentType) -> None:
+    if "component_type" not in _singletons:
+        _singletons["component_type"] = component_type
+
+
+def get_component_type() -> ComponentType:
+    try:
+        return _singletons["component_type"]
+    except KeyError as exc:
+        raise ValueError("Component type is not set. It needs to be initialized before working with services.") from exc
+
+
+def build_client() -> InfrahubClient:
+    return InfrahubClient(config=Config(address=config.SETTINGS.main.internal_address, retry_on_failure=True))
+
+
+@inject
+def get_client(client: InfrahubClient = Depends(build_client)) -> InfrahubClient:  # noqa: B008
+    return client
+
+
+def build_installation_type() -> str:
+    return INSTALLATION_TYPE
+
+
+@inject
+def get_installation_type(installation_type: str = Depends(build_installation_type)) -> str:
+    return installation_type
+
+
+async def build_database() -> InfrahubDatabase:
+    if "database" not in _singletons:
+        _singletons["database"] = InfrahubDatabase(driver=await get_db(retry=5))
+    return _singletons["database"]
+
+
+@inject
+async def get_database(database: InfrahubDatabase = Depends(build_database)) -> InfrahubDatabase:  # noqa: B008
+    return database
+
+
+async def build_cache() -> InfrahubCache:
+    if "cache" not in _singletons:
+        _singletons["cache"] = config.OVERRIDE.cache or await InfrahubCache.new_from_driver(
+            driver=config.SETTINGS.cache.driver
+        )
+    return _singletons["cache"]
+
+
+@inject
+async def get_cache(cache: InfrahubCache = Depends(build_cache)) -> InfrahubCache:  # noqa: B008
+    return cache
+
+
+async def build_message_bus() -> InfrahubMessageBus:
+    if "message_bus" not in _singletons:
+        _singletons["message_bus"] = config.OVERRIDE.message_bus or (
+            await InfrahubMessageBus.new_from_driver(
+                component_type=get_component_type(), driver=config.SETTINGS.broker.driver
+            )
+        )
+    return _singletons["message_bus"]
+
+
+@inject
+async def get_message_bus(message_bus: InfrahubMessageBus = Depends(build_message_bus)) -> InfrahubMessageBus:  # noqa: B008
+    return message_bus
+
+
+async def build_event_service() -> InfrahubEventService:
+    if "event_service" not in _singletons:
+        _singletons["event_service"] = InfrahubEventService(message_bus=await get_message_bus())
+    return _singletons["event_service"]
+
+
+@inject
+async def get_event_service(event_service: InfrahubEventService = Depends(build_event_service)) -> InfrahubEventService:  # noqa: B008
+    return event_service
+
+
+def build_workflow() -> InfrahubWorkflow:
+    if "workflow" not in _singletons:
+        _singletons["workflow"] = config.OVERRIDE.workflow or (
+            WorkflowWorkerExecution()
+            if config.SETTINGS.workflow.driver == config.WorkflowDriver.WORKER
+            else WorkflowLocalExecution()
+        )
+    return _singletons["workflow"]
+
+
+@inject
+def get_workflow(workflow: InfrahubWorkflow = Depends(build_workflow)) -> InfrahubWorkflow:  # noqa: B008
+    return workflow
+
+
+def build_http_service() -> InfrahubHTTP:
+    if "http_service" not in _singletons:
+        _singletons["http_service"] = HttpxAdapter()
+    return _singletons["http_service"]
+
+
+@inject
+def get_http(http_service: InfrahubHTTP = Depends(build_http_service)) -> InfrahubHTTP:  # noqa: B008
+    return http_service
+
+
+async def build_component() -> InfrahubComponent:
+    if "component" not in _singletons:
+        _singletons["component"] = await InfrahubComponent.new(
+            cache=await get_cache(),
+            component_type=get_component_type(),
+            db=await get_database(),
+            message_bus=await get_message_bus(),
+        )
+    return _singletons["component"]
+
+
+@inject
+async def get_component(component: InfrahubComponent = Depends(build_component)) -> InfrahubComponent:  # noqa: B008
+    return component

infrahub/workers/infrahub_async.py

@@ -18,17 +18,19 @@ from infrahub import config
 from infrahub.components import ComponentType
 from infrahub.core import registry
 from infrahub.core.initialization import initialization
-from infrahub.database import InfrahubDatabase, get_db
 from infrahub.dependencies.registry import build_component_registry
 from infrahub.git import initialize_repositories_directory
 from infrahub.lock import initialize_lock
 from infrahub.services import InfrahubServices
-from infrahub.services.adapters.cache import InfrahubCache
-from infrahub.services.adapters.message_bus import InfrahubMessageBus
-from infrahub.services.adapters.workflow import InfrahubWorkflow
-from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
-from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
 from infrahub.trace import configure_trace
+from infrahub.workers.dependencies import (
+    get_cache,
+    get_component,
+    get_database,
+    get_message_bus,
+    get_workflow,
+    set_component_type,
+)
 from infrahub.workers.utils import inject_service_parameter, load_flow_function
 from infrahub.workflows.models import TASK_RESULT_STORAGE_NAME
 
@@ -63,6 +65,7 @@ class InfrahubWorkerAsync(BaseWorker):
     _logo_url = "https://example.com/logo"
     _description = "Infrahub worker designed to run the flow in the main async loop."
     service: InfrahubServices  # keep a reference to `service` so we can inject it within flows parameters.
+    component_type = ComponentType.GIT_AGENT
 
     async def setup(
         self,
@@ -115,6 +118,7 @@ class InfrahubWorkerAsync(BaseWorker):
             )
         )
 
+        set_component_type(component_type=self.component_type)
         await self._init_services(client=client)
 
         if not registry.schema_has_been_initialized():
@@ -141,22 +145,18 @@ class InfrahubWorkerAsync(BaseWorker):
         entrypoint: str = configuration._related_objects["deployment"].entrypoint
 
         file_path, flow_name = entrypoint.split(":")
-        file_path.replace("/", ".")
-        module_path = file_path.replace("backend/", "").replace(".py", "").replace("/", ".")
+        module_path = file_path.removeprefix("backend/").removesuffix(".py").replace("/", ".")
         flow_func = load_flow_function(module_path=module_path, flow_name=flow_name)
         inject_service_parameter(func=flow_func, parameters=flow_run.parameters, service=self.service)
         flow_run_logger.debug("Validating parameters")
         params = flow_func.validate_parameters(parameters=flow_run.parameters)
 
         if task_status:
-            task_status.started()
+            task_status.started(True)
 
         await run_flow_async(flow=flow_func, flow_run=flow_run, parameters=params, return_type="state")
 
-        return InfrahubWorkerAsyncResult(
-            status_code=0,
-            identifier=str(flow_run.id),
-        )
+        return InfrahubWorkerAsyncResult(status_code=0, identifier=str(flow_run.id))
 
     def _init_logger(self) -> None:
         """Initialize loggers to use the API handle provided by Prefect."""
@@ -182,41 +182,17 @@ class InfrahubWorkerAsync(BaseWorker):
 
         return client
 
-    async def _init_database(self) -> InfrahubDatabase:
-        return InfrahubDatabase(driver=await get_db(retry=1))
-
-    async def _init_workflow(self) -> InfrahubWorkflow:
-        return config.OVERRIDE.workflow or (
-            WorkflowWorkerExecution()
-            if config.SETTINGS.workflow.driver == config.WorkflowDriver.WORKER
-            else WorkflowLocalExecution()
-        )
-
-    async def _init_message_bus(self, component_type: ComponentType) -> InfrahubMessageBus:
-        return config.OVERRIDE.message_bus or (
-            await InfrahubMessageBus.new_from_driver(
-                component_type=component_type, driver=config.SETTINGS.broker.driver
-            )
-        )
-
-    async def _init_cache(self) -> InfrahubCache:
-        return config.OVERRIDE.cache or (await InfrahubCache.new_from_driver(driver=config.SETTINGS.cache.driver))
-
     async def _init_services(self, client: InfrahubClient) -> None:
-        component_type = ComponentType.GIT_AGENT
         client = await self._init_infrahub_client(client=client)
-        database = await self._init_database()
-        workflow = await self._init_workflow()
-        message_bus = await self._init_message_bus(component_type=component_type)
-        cache = await self._init_cache()
 
         service = await InfrahubServices.new(
-            cache=cache,
+            cache=await get_cache(),
             client=client,
-            database=database,
-            message_bus=message_bus,
-            workflow=workflow,
-            component_type=component_type,
+            database=await get_database(),
+            message_bus=await get_message_bus(),
+            workflow=get_workflow(),
+            component=await get_component(),
+            component_type=self.component_type,
         )
 
         self.service = service

infrahub/workflows/catalogue.py

@@ -1,5 +1,7 @@
 import random
 
+from fast_depends import Depends, inject
+
 from .constants import WorkflowTag, WorkflowType
 from .models import WorkerPoolDefinition, WorkflowDefinition
 
@@ -529,9 +531,9 @@ VALIDATE_SCHEMA_NUMBER_POOLS = WorkflowDefinition(
 )
 
 
-worker_pools = [INFRAHUB_WORKER_POOL]
+WORKER_POOLS = [INFRAHUB_WORKER_POOL]
 
-workflows = [
+WORKFLOWS = [
     ACTION_ADD_NODE_TO_GROUP,
     ACTION_RUN_GENERATOR,
     ACTION_RUN_GENERATOR_GROUP_EVENT,
@@ -603,3 +605,15 @@ workflows = [
     WEBHOOK_DELETE_AUTOMATION,
     WEBHOOK_PROCESS,
 ]
+
+
+# Use this dependency injection mechanism to easily add new workflows within infrahub-enterprise
+def build_workflows_definitions() -> list[WorkflowDefinition]:
+    return WORKFLOWS
+
+
+@inject
+def get_workflows(
+    workflows: list[WorkflowDefinition] = Depends(build_workflows_definitions),  # noqa: B008
+) -> list[WorkflowDefinition]:
+    return workflows

infrahub/workflows/initialization.py

@@ -11,19 +11,20 @@ from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.trigger.models import TriggerType
 from infrahub.trigger.setup import setup_triggers
 
-from .catalogue import worker_pools, workflows
+from .catalogue import WORKER_POOLS, get_workflows
 from .models import TASK_RESULT_STORAGE_NAME
 
 
 @task(name="task-manager-setup-worker-pools", task_run_name="Setup Worker pools", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_worker_pools(client: PrefectClient) -> None:
     log = get_run_logger()
-    for worker in worker_pools:
+    for worker in WORKER_POOLS:
         wp = WorkPoolCreate(
             name=worker.name,
             type=worker.worker_type or config.SETTINGS.workflow.default_worker_type,
             description=worker.description,
         )
+
         try:
             await client.create_work_pool(work_pool=wp, overwrite=True)
             log.info(f"Work pool {worker.name} created successfully ... ")
@@ -34,10 +35,10 @@ async def setup_worker_pools(client: PrefectClient) -> None:
 @task(name="task-manager-setup-deployments", task_run_name="Setup Deployments", cache_policy=NONE)  # type: ignore[arg-type]
 async def setup_deployments(client: PrefectClient) -> None:
     log = get_run_logger()
-    for workflow in workflows:
+    for workflow in get_workflows():
         # For now the workpool is hardcoded but
         # later we need to make it dynamic to have a different worker based on the type of the workflow
-        work_pool = worker_pools[0]
+        work_pool = WORKER_POOLS[0]
         await workflow.save(client=client, work_pool=work_pool)
         log.info(f"Flow {workflow.name}, created successfully ... ")
 

infrahub/workflows/models.py

@@ -51,6 +51,8 @@ class WorkflowDefinition(BaseModel):
 
     @property
     def entrypoint(self) -> str:
+        if self.type == WorkflowType.USER:
+            return f"{self.module}:{self.function}"
         return f"backend/{self.module.replace('.', '/')}:{self.function}"
 
     @property

infrahub_sdk/client.py

@@ -250,7 +250,7 @@ class BaseClient:
 
         return Mutation(
             name="AllocateIPAddress",
-            mutation="IPAddressPoolGetResource",
+            mutation="InfrahubIPAddressPoolGetResource",
             query={"ok": None, "node": {"id": None, "kind": None, "identifier": None, "display_label": None}},
             input_data={"data": input_data},
         )
@@ -281,7 +281,7 @@ class BaseClient:
 
         return Mutation(
             name="AllocateIPPrefix",
-            mutation="IPPrefixPoolGetResource",
+            mutation="InfrahubIPPrefixPoolGetResource",
             query={"ok": None, "node": {"id": None, "kind": None, "identifier": None, "display_label": None}},
             input_data={"data": input_data},
         )
@@ -1300,7 +1300,7 @@ class InfrahubClient(BaseClient):
             raise ValueError("resource_pool is not an IP address pool")
 
         branch = branch or self.default_branch
-        mutation_name = "IPAddressPoolGetResource"
+        mutation_name = "InfrahubIPAddressPoolGetResource"
 
         query = self._build_ip_address_allocation_query(
             resource_pool_id=resource_pool.id,
@@ -1452,7 +1452,7 @@ class InfrahubClient(BaseClient):
             raise ValueError("resource_pool is not an IP prefix pool")
 
         branch = branch or self.default_branch
-        mutation_name = "IPPrefixPoolGetResource"
+        mutation_name = "InfrahubIPPrefixPoolGetResource"
 
         query = self._build_ip_prefix_allocation_query(
             resource_pool_id=resource_pool.id,
@@ -2438,7 +2438,7 @@ class InfrahubClientSync(BaseClient):
             raise ValueError("resource_pool is not an IP address pool")
 
         branch = branch or self.default_branch
-        mutation_name = "IPAddressPoolGetResource"
+        mutation_name = "InfrahubIPAddressPoolGetResource"
 
         query = self._build_ip_address_allocation_query(
             resource_pool_id=resource_pool.id,
@@ -2586,7 +2586,7 @@ class InfrahubClientSync(BaseClient):
             raise ValueError("resource_pool is not an IP prefix pool")
 
         branch = branch or self.default_branch
-        mutation_name = "IPPrefixPoolGetResource"
+        mutation_name = "InfrahubIPPrefixPoolGetResource"
 
         query = self._build_ip_prefix_allocation_query(
             resource_pool_id=resource_pool.id,

infrahub_sdk/ctl/repository.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
 from typing import Optional
 
 import typer
 import yaml
+from copier import run_copy
 from pydantic import ValidationError
 from rich.console import Console
 from rich.table import Table
@@ -165,3 +167,52 @@ async def list(
         )
 
     console.print(table)
+
+
+@app.command()
+async def init(
+    directory: Path = typer.Argument(help="Directory path for the new project."),
+    template: str = typer.Option(
+        default="https://github.com/opsmill/infrahub-template.git",
+        help="Template to use for the new repository. Can be a local path or a git repository URL.",
+    ),
+    data: Optional[Path] = typer.Option(default=None, help="Path to YAML file containing answers to CLI prompt."),
+    vcs_ref: Optional[str] = typer.Option(
+        default="HEAD",
+        help="VCS reference to use for the template. Defaults to HEAD.",
+    ),
+    trust: Optional[bool] = typer.Option(
+        default=False,
+        help="Trust the template repository. If set, the template will be cloned without verification.",
+    ),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Initialize a new Infrahub repository."""
+
+    config_data = None
+    if data:
+        try:
+            with Path.open(data, encoding="utf-8") as file:
+                config_data = yaml.safe_load(file)
+            typer.echo(f"Loaded config: {config_data}")
+        except Exception as exc:
+            typer.echo(f"Error loading YAML file: {exc}", err=True)
+            raise typer.Exit(code=1)
+
+    # Allow template to be a local path or a URL
+    template_source = template or ""
+    if template and Path(template).exists():
+        template_source = str(Path(template).resolve())
+
+    try:
+        await asyncio.to_thread(
+            run_copy,
+            template_source,
+            str(directory),
+            data=config_data,
+            vcs_ref=vcs_ref,
+            unsafe=trust,
+        )
+    except Exception as e:
+        typer.echo(f"Error running copier: {e}", err=True)
+        raise typer.Exit(code=1)

infrahub_sdk/ctl/schema.py

@@ -36,7 +36,7 @@ def validate_schema_content_and_exit(client: InfrahubClient, schemas: list[Schem
     has_error: bool = False
     for schema_file in schemas:
         try:
-            client.schema.validate(data=schema_file.content)
+            client.schema.validate(data=schema_file.payload)
         except ValidationError as exc:
             console.print(f"[red]Schema not valid, found '{len(exc.errors())}' error(s) in {schema_file.location}")
             has_error = True
@@ -48,7 +48,7 @@ def validate_schema_content_and_exit(client: InfrahubClient, schemas: list[Schem
         raise typer.Exit(1)
 
 
-def display_schema_load_errors(response: dict[str, Any], schemas_data: list[dict]) -> None:
+def display_schema_load_errors(response: dict[str, Any], schemas_data: list[SchemaFile]) -> None:
     console.print("[red]Unable to load the schema:")
     if "detail" not in response:
         handle_non_detail_errors(response=response)
@@ -87,7 +87,7 @@ def handle_non_detail_errors(response: dict[str, Any]) -> None:
     if "error" in response:
         console.print(f"  {response.get('error')}")
     elif "errors" in response:
-        for error in response.get("errors"):
+        for error in response["errors"]:
             console.print(f"  {error.get('message')}")
     else:
         console.print(f"  '{response}'")
@@ -97,9 +97,9 @@ def valid_error_path(loc_path: list[Any]) -> bool:
     return len(loc_path) >= 6 and loc_path[0] == "body" and loc_path[1] == "schemas"
 
 
-def get_node(schemas_data: list[dict], schema_index: int, node_index: int) -> dict | None:
-    if schema_index < len(schemas_data) and node_index < len(schemas_data[schema_index].content["nodes"]):
-        return schemas_data[schema_index].content["nodes"][node_index]
+def get_node(schemas_data: list[SchemaFile], schema_index: int, node_index: int) -> dict | None:
+    if schema_index < len(schemas_data) and node_index < len(schemas_data[schema_index].payload["nodes"]):
+        return schemas_data[schema_index].payload["nodes"][node_index]
     return None
 
 
@@ -122,7 +122,7 @@ async def load(
     validate_schema_content_and_exit(client=client, schemas=schemas_data)
 
     start_time = time.time()
-    response = await client.schema.load(schemas=[item.content for item in schemas_data], branch=branch)
+    response = await client.schema.load(schemas=[item.payload for item in schemas_data], branch=branch)
     loading_time = time.time() - start_time
 
     if response.errors:
@@ -170,10 +170,10 @@ async def check(
     client = initialize_client()
     validate_schema_content_and_exit(client=client, schemas=schemas_data)
 
-    success, response = await client.schema.check(schemas=[item.content for item in schemas_data], branch=branch)
+    success, response = await client.schema.check(schemas=[item.payload for item in schemas_data], branch=branch)
 
     if not success:
-        display_schema_load_errors(response=response, schemas_data=schemas_data)
+        display_schema_load_errors(response=response or {}, schemas_data=schemas_data)
     else:
         for schema_file in schemas_data:
             console.print(f"[green] schema '{schema_file.location}' is Valid!")

infrahub_sdk/protocols.py

@@ -233,6 +233,10 @@ class CoreWebhook(CoreNode):
     validate_certificates: BooleanOptional
 
 
+class CoreWeightedPoolResource(CoreNode):
+    allocation_weight: IntegerOptional
+
+
 class LineageOwner(CoreNode):
     pass
 
@@ -321,6 +325,7 @@ class CoreCheckDefinition(CoreTaskTarget):
 
 
 class CoreCustomWebhook(CoreWebhook, CoreTaskTarget):
+    shared_key: StringOptional
     transformation: RelatedNode
 
 
@@ -405,12 +410,12 @@ class CoreGraphQLQueryGroup(CoreGroup):
 
 
 class CoreGroupAction(CoreAction):
-    add_members: Boolean
+    member_action: Dropdown
     group: RelatedNode
 
 
 class CoreGroupTriggerRule(CoreTriggerRule):
-    members_added: Boolean
+    member_update: Dropdown
     group: RelatedNode
 
 
@@ -442,7 +447,7 @@ class CoreNodeTriggerAttributeMatch(CoreNodeTriggerMatch):
 
 class CoreNodeTriggerRelationshipMatch(CoreNodeTriggerMatch):
     relationship_name: String
-    added: Boolean
+    modification_type: Dropdown
     peer: StringOptional
 
 
@@ -457,6 +462,7 @@ class CoreNumberPool(CoreResourcePool, LineageSource):
     node_attribute: String
     start_range: Integer
     end_range: Integer
+    pool_type: Enum
 
 
 class CoreObjectPermission(CoreBasePermission):
@@ -481,7 +487,10 @@ class CoreProposedChange(CoreTaskTarget):
     source_branch: String
     destination_branch: String
     state: Enum
+    is_draft: Boolean
+    total_comments: IntegerOptional
     approved_by: RelationshipManager
+    rejected_by: RelationshipManager
     reviewers: RelationshipManager
     created_by: RelatedNode
     comments: RelationshipManager
@@ -555,6 +564,14 @@ class InternalAccountToken(CoreNode):
     account: RelatedNode
 
 
+class InternalIPPrefixAvailable(BuiltinIPPrefix):
+    pass
+
+
+class InternalIPRangeAvailable(BuiltinIPAddress):
+    last_address: IPHost
+
+
 class InternalRefreshToken(CoreNode):
     expiration: DateTime
     account: RelatedNode
@@ -766,6 +783,10 @@ class CoreWebhookSync(CoreNodeSync):
     validate_certificates: BooleanOptional
 
 
+class CoreWeightedPoolResourceSync(CoreNodeSync):
+    allocation_weight: IntegerOptional
+
+
 class LineageOwnerSync(CoreNodeSync):
     pass
 
@@ -854,6 +875,7 @@ class CoreCheckDefinitionSync(CoreTaskTargetSync):
 
 
 class CoreCustomWebhookSync(CoreWebhookSync, CoreTaskTargetSync):
+    shared_key: StringOptional
     transformation: RelatedNodeSync
 
 
@@ -938,12 +960,12 @@ class CoreGraphQLQueryGroupSync(CoreGroupSync):
 
 
 class CoreGroupActionSync(CoreActionSync):
-    add_members: Boolean
+    member_action: Dropdown
     group: RelatedNodeSync
 
 
 class CoreGroupTriggerRuleSync(CoreTriggerRuleSync):
-    members_added: Boolean
+    member_update: Dropdown
     group: RelatedNodeSync
 
 
@@ -975,7 +997,7 @@ class CoreNodeTriggerAttributeMatchSync(CoreNodeTriggerMatchSync):
 
 class CoreNodeTriggerRelationshipMatchSync(CoreNodeTriggerMatchSync):
     relationship_name: String
-    added: Boolean
+    modification_type: Dropdown
     peer: StringOptional
 
 
@@ -990,6 +1012,7 @@ class CoreNumberPoolSync(CoreResourcePoolSync, LineageSourceSync):
     node_attribute: String
     start_range: Integer
     end_range: Integer
+    pool_type: Enum
 
 
 class CoreObjectPermissionSync(CoreBasePermissionSync):
@@ -1014,7 +1037,10 @@ class CoreProposedChangeSync(CoreTaskTargetSync):
     source_branch: String
     destination_branch: String
     state: Enum
+    is_draft: Boolean
+    total_comments: IntegerOptional
     approved_by: RelationshipManagerSync
+    rejected_by: RelationshipManagerSync
     reviewers: RelationshipManagerSync
     created_by: RelatedNodeSync
     comments: RelationshipManagerSync
@@ -1088,6 +1114,14 @@ class InternalAccountTokenSync(CoreNodeSync):
     account: RelatedNodeSync
 
 
+class InternalIPPrefixAvailableSync(BuiltinIPPrefixSync):
+    pass
+
+
+class InternalIPRangeAvailableSync(BuiltinIPAddressSync):
+    last_address: IPHost
+
+
 class InternalRefreshTokenSync(CoreNodeSync):
     expiration: DateTime
     account: RelatedNodeSync