cribl-control-plane 0.4.0b23__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

cribl_control_plane/models/functionlocalsearchdatatypeparser.py

@@ -1,6 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemalocalsearchdatatypeparser import (
+    FunctionConfSchemaLocalSearchDatatypeParser,
+    FunctionConfSchemaLocalSearchDatatypeParserTypedDict,
+)
 from cribl_control_plane.types import BaseModel
 from enum import Enum
 import pydantic
@@ -12,16 +16,6 @@ class FunctionLocalSearchDatatypeParserID(str, Enum):
     LOCAL_SEARCH_DATATYPE_PARSER = "local_search_datatype_parser"
 
 
-class FunctionLocalSearchDatatypeParserSchemaTypedDict(TypedDict):
-    ruleset_id: str
-    r"""ID of the local search datatype ruleset"""
-
-
-class FunctionLocalSearchDatatypeParserSchema(BaseModel):
-    ruleset_id: Annotated[str, pydantic.Field(alias="rulesetId")]
-    r"""ID of the local search datatype ruleset"""
-
-
 class FunctionLocalSearchDatatypeParserTypedDict(TypedDict):
     filename: str
     group: str
@@ -36,7 +30,7 @@ class FunctionLocalSearchDatatypeParserTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionLocalSearchDatatypeParserSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaLocalSearchDatatypeParserTypedDict]
 
 
 class FunctionLocalSearchDatatypeParser(BaseModel):
@@ -71,6 +65,6 @@ class FunctionLocalSearchDatatypeParser(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionLocalSearchDatatypeParserSchema],
+        Optional[FunctionConfSchemaLocalSearchDatatypeParser],
         pydantic.Field(alias="schema"),
     ] = None

cribl_control_plane/models/functionlocalsearchrulesetrunner.py

@@ -1,13 +1,13 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import models, utils
+from .functionconfschemalocalsearchrulesetrunner import (
+    FunctionConfSchemaLocalSearchRulesetRunner,
+    FunctionConfSchemaLocalSearchRulesetRunnerTypedDict,
+)
 from cribl_control_plane.types import BaseModel
-from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
-from pydantic import field_serializer
-from pydantic.functional_validators import PlainValidator
 from typing import Any, Dict, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -16,34 +16,6 @@ class FunctionLocalSearchRulesetRunnerID(str, Enum):
     LOCAL_SEARCH_RULESET_RUNNER = "local_search_ruleset_runner"
 
 
-class RulesetType(str, Enum, metaclass=utils.OpenEnumMeta):
-    DATASET = "dataset"
-    DATATYPE = "datatype"
-
-
-class FunctionLocalSearchRulesetRunnerSchemaTypedDict(TypedDict):
-    ruleset_type: NotRequired[RulesetType]
-    ruleset_id: NotRequired[str]
-
-
-class FunctionLocalSearchRulesetRunnerSchema(BaseModel):
-    ruleset_type: Annotated[
-        Annotated[Optional[RulesetType], PlainValidator(validate_open_enum(False))],
-        pydantic.Field(alias="rulesetType"),
-    ] = None
-
-    ruleset_id: Annotated[Optional[str], pydantic.Field(alias="rulesetId")] = None
-
-    @field_serializer("ruleset_type")
-    def serialize_ruleset_type(self, value):
-        if isinstance(value, str):
-            try:
-                return models.RulesetType(value)
-            except ValueError:
-                return value
-        return value
-
-
 class FunctionLocalSearchRulesetRunnerTypedDict(TypedDict):
     filename: str
     group: str
@@ -58,7 +30,7 @@ class FunctionLocalSearchRulesetRunnerTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionLocalSearchRulesetRunnerSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaLocalSearchRulesetRunnerTypedDict]
 
 
 class FunctionLocalSearchRulesetRunner(BaseModel):
@@ -93,5 +65,6 @@ class FunctionLocalSearchRulesetRunner(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionLocalSearchRulesetRunnerSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaLocalSearchRulesetRunner],
+        pydantic.Field(alias="schema"),
     ] = None

cribl_control_plane/models/functionlookup.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemalookup import (
+    FunctionConfSchemaLookup,
+    FunctionConfSchemaLookupTypedDict,
+)
 from cribl_control_plane.types import BaseModel
 from enum import Enum
 import pydantic
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -12,89 +16,6 @@ class FunctionLookupID(str, Enum):
     LOOKUP = "lookup"
 
 
-class InFieldTypedDict(TypedDict):
-    event_field: str
-    r"""Field name as it appears in events"""
-    lookup_field: NotRequired[str]
-    r"""Optional: The field name as it appears in the lookup file. Defaults to event field name"""
-
-
-class InField(BaseModel):
-    event_field: Annotated[str, pydantic.Field(alias="eventField")]
-    r"""Field name as it appears in events"""
-
-    lookup_field: Annotated[Optional[str], pydantic.Field(alias="lookupField")] = None
-    r"""Optional: The field name as it appears in the lookup file. Defaults to event field name"""
-
-
-class OutFieldTypedDict(TypedDict):
-    lookup_field: str
-    r"""The field name as it appears in the lookup file"""
-    event_field: NotRequired[str]
-    r"""Optional: Field name to add to event. Defaults to lookup field name."""
-    default_value: NotRequired[str]
-    r"""Optional: Value to assign if lookup entry is not found"""
-
-
-class OutField(BaseModel):
-    lookup_field: Annotated[str, pydantic.Field(alias="lookupField")]
-    r"""The field name as it appears in the lookup file"""
-
-    event_field: Annotated[Optional[str], pydantic.Field(alias="eventField")] = None
-    r"""Optional: Field name to add to event. Defaults to lookup field name."""
-
-    default_value: Annotated[Optional[str], pydantic.Field(alias="defaultValue")] = None
-    r"""Optional: Value to assign if lookup entry is not found"""
-
-
-class FunctionLookupSchemaTypedDict(TypedDict):
-    file: str
-    r"""Path to the lookup file. Reference environment variables via $. Example: $HOME/file.csv"""
-    db_lookup: NotRequired[bool]
-    r"""Enable to use a disk-based lookup. This option displays only the settings relevant to disk-based mode and hides those for in-memory lookups."""
-    match_mode: NotRequired[Any]
-    match_type: NotRequired[Any]
-    reload_period_sec: NotRequired[Any]
-    in_fields: NotRequired[List[InFieldTypedDict]]
-    r"""Fields that should be used to key into the lookup table"""
-    out_fields: NotRequired[List[OutFieldTypedDict]]
-    r"""Fields to add to events after matching lookup. Defaults to all if not specified."""
-    add_to_event: NotRequired[bool]
-    r"""Add the looked-up values to _raw, as key=value pairs"""
-    ignore_case: NotRequired[Any]
-
-
-class FunctionLookupSchema(BaseModel):
-    file: str
-    r"""Path to the lookup file. Reference environment variables via $. Example: $HOME/file.csv"""
-
-    db_lookup: Annotated[Optional[bool], pydantic.Field(alias="dbLookup")] = False
-    r"""Enable to use a disk-based lookup. This option displays only the settings relevant to disk-based mode and hides those for in-memory lookups."""
-
-    match_mode: Annotated[Optional[Any], pydantic.Field(alias="matchMode")] = None
-
-    match_type: Annotated[Optional[Any], pydantic.Field(alias="matchType")] = None
-
-    reload_period_sec: Annotated[
-        Optional[Any], pydantic.Field(alias="reloadPeriodSec")
-    ] = None
-
-    in_fields: Annotated[Optional[List[InField]], pydantic.Field(alias="inFields")] = (
-        None
-    )
-    r"""Fields that should be used to key into the lookup table"""
-
-    out_fields: Annotated[
-        Optional[List[OutField]], pydantic.Field(alias="outFields")
-    ] = None
-    r"""Fields to add to events after matching lookup. Defaults to all if not specified."""
-
-    add_to_event: Annotated[Optional[bool], pydantic.Field(alias="addToEvent")] = False
-    r"""Add the looked-up values to _raw, as key=value pairs"""
-
-    ignore_case: Annotated[Optional[Any], pydantic.Field(alias="ignoreCase")] = None
-
-
 class FunctionLookupTypedDict(TypedDict):
     filename: str
     group: str
@@ -109,7 +30,7 @@ class FunctionLookupTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionLookupSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaLookupTypedDict]
 
 
 class FunctionLookup(BaseModel):
@@ -144,5 +65,5 @@ class FunctionLookup(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionLookupSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaLookup], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionmask.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemamask import (
+    FunctionConfSchemaMask,
+    FunctionConfSchemaMaskTypedDict,
+)
 from cribl_control_plane.types import BaseModel
 from enum import Enum
 import pydantic
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -12,62 +16,6 @@ class FunctionMaskID(str, Enum):
     MASK = "mask"
 
 
-class FunctionMaskRuleTypedDict(TypedDict):
-    match_regex: str
-    r"""Pattern to replace. Use /g to replace all matches."""
-    replace_expr: NotRequired[str]
-    r"""A JavaScript expression or literal to replace the matching content. Capturing groups can be referenced as g1, g2, and so on, and event fields as event.<fieldName>."""
-    disabled: NotRequired[bool]
-    r"""Set to No to disable the evaluation of an individual rule"""
-
-
-class FunctionMaskRule(BaseModel):
-    match_regex: Annotated[str, pydantic.Field(alias="matchRegex")]
-    r"""Pattern to replace. Use /g to replace all matches."""
-
-    replace_expr: Annotated[Optional[str], pydantic.Field(alias="replaceExpr")] = "''"
-    r"""A JavaScript expression or literal to replace the matching content. Capturing groups can be referenced as g1, g2, and so on, and event fields as event.<fieldName>."""
-
-    disabled: Optional[bool] = False
-    r"""Set to No to disable the evaluation of an individual rule"""
-
-
-class FunctionMaskFlagTypedDict(TypedDict):
-    value: str
-    r"""JavaScript expression to compute the value (can be constant)"""
-    name: NotRequired[str]
-
-
-class FunctionMaskFlag(BaseModel):
-    value: str
-    r"""JavaScript expression to compute the value (can be constant)"""
-
-    name: Optional[str] = None
-
-
-class FunctionMaskSchemaTypedDict(TypedDict):
-    rules: List[FunctionMaskRuleTypedDict]
-    fields: NotRequired[List[str]]
-    r"""Fields on which to apply the masking rules. Supports * wildcards, except when used on internal fields."""
-    depth: NotRequired[int]
-    r"""Depth to which the Mask Function will search for fields to mask"""
-    flags: NotRequired[List[FunctionMaskFlagTypedDict]]
-    r"""Fields to evaluate if one or more masking rules are matched"""
-
-
-class FunctionMaskSchema(BaseModel):
-    rules: List[FunctionMaskRule]
-
-    fields: Optional[List[str]] = None
-    r"""Fields on which to apply the masking rules. Supports * wildcards, except when used on internal fields."""
-
-    depth: Optional[int] = 5
-    r"""Depth to which the Mask Function will search for fields to mask"""
-
-    flags: Optional[List[FunctionMaskFlag]] = None
-    r"""Fields to evaluate if one or more masking rules are matched"""
-
-
 class FunctionMaskTypedDict(TypedDict):
     filename: str
     group: str
@@ -82,7 +30,7 @@ class FunctionMaskTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionMaskSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaMaskTypedDict]
 
 
 class FunctionMask(BaseModel):
@@ -116,6 +64,6 @@ class FunctionMask(BaseModel):
 
     sync: Optional[bool] = None
 
-    schema_: Annotated[Optional[FunctionMaskSchema], pydantic.Field(alias="schema")] = (
-        None
-    )
+    schema_: Annotated[
+        Optional[FunctionConfSchemaMask], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionmvexpand.py

@@ -1,14 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import models, utils
+from .functionconfschemamvexpand import (
+    FunctionConfSchemaMvExpand,
+    FunctionConfSchemaMvExpandTypedDict,
+)
 from cribl_control_plane.types import BaseModel
-from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
-from pydantic import field_serializer
-from pydantic.functional_validators import PlainValidator
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -16,65 +16,6 @@ class FunctionMvExpandID(str, Enum):
     MV_EXPAND = "mv_expand"
 
 
-class BagExpansionMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""decides if bag-values are expanded to bags or arrays"""
-
-    # Store as object
-    BAG = "bag"
-    # Store as array
-    ARRAY = "array"
-
-
-class FunctionMvExpandSchemaTypedDict(TypedDict):
-    source_fields: List[str]
-    r"""Array of property-/field-names to expand"""
-    target_names: NotRequired[List[str]]
-    r"""stores the value as new target field name"""
-    row_limit: NotRequired[float]
-    r"""max. number of rows generated out of every source events"""
-    item_index_name: NotRequired[str]
-    r"""name of an optional index property generated into the output"""
-    bag_expansion_mode: NotRequired[BagExpansionMode]
-    r"""decides if bag-values are expanded to bags or arrays"""
-
-
-class FunctionMvExpandSchema(BaseModel):
-    source_fields: Annotated[List[str], pydantic.Field(alias="sourceFields")]
-    r"""Array of property-/field-names to expand"""
-
-    target_names: Annotated[
-        Optional[List[str]], pydantic.Field(alias="targetNames")
-    ] = None
-    r"""stores the value as new target field name"""
-
-    row_limit: Annotated[Optional[float], pydantic.Field(alias="rowLimit")] = (
-        9007199254740991
-    )
-    r"""max. number of rows generated out of every source events"""
-
-    item_index_name: Annotated[Optional[str], pydantic.Field(alias="itemIndexName")] = (
-        None
-    )
-    r"""name of an optional index property generated into the output"""
-
-    bag_expansion_mode: Annotated[
-        Annotated[
-            Optional[BagExpansionMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="bagExpansionMode"),
-    ] = BagExpansionMode.BAG
-    r"""decides if bag-values are expanded to bags or arrays"""
-
-    @field_serializer("bag_expansion_mode")
-    def serialize_bag_expansion_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.BagExpansionMode(value)
-            except ValueError:
-                return value
-        return value
-
-
 class FunctionMvExpandTypedDict(TypedDict):
     filename: str
     group: str
@@ -89,7 +30,7 @@ class FunctionMvExpandTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionMvExpandSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaMvExpandTypedDict]
 
 
 class FunctionMvExpand(BaseModel):
@@ -124,5 +65,5 @@ class FunctionMvExpand(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionMvExpandSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaMvExpand], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionmvpull.py

@@ -1,6 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemamvpull import (
+    FunctionConfSchemaMvPull,
+    FunctionConfSchemaMvPullTypedDict,
+)
 from cribl_control_plane.types import BaseModel
 from enum import Enum
 import pydantic
@@ -12,40 +16,6 @@ class FunctionMvPullID(str, Enum):
     MV_PULL = "mv_pull"
 
 
-class FunctionMvPullSchemaTypedDict(TypedDict):
-    array_path: str
-    r"""Field name of the array within events that contains the data objects of interest. Can be a path."""
-    relative_key_path: str
-    r"""Extract the K-V pair's key from this field, relative to the data object."""
-    relative_value_path: str
-    r"""Extract the K-V pair's value from this field, relative to the data object."""
-    target_bag_path: NotRequired[str]
-    r"""Optionally, specify a bag as the target for K-V entries. If not specified, these entries are stored on each top-level event."""
-    delete_original: NotRequired[bool]
-    r"""Toggle this on to remove each original array of data objects after extraction. If toggled off, arrays are retained."""
-
-
-class FunctionMvPullSchema(BaseModel):
-    array_path: Annotated[str, pydantic.Field(alias="arrayPath")]
-    r"""Field name of the array within events that contains the data objects of interest. Can be a path."""
-
-    relative_key_path: Annotated[str, pydantic.Field(alias="relativeKeyPath")]
-    r"""Extract the K-V pair's key from this field, relative to the data object."""
-
-    relative_value_path: Annotated[str, pydantic.Field(alias="relativeValuePath")]
-    r"""Extract the K-V pair's value from this field, relative to the data object."""
-
-    target_bag_path: Annotated[Optional[str], pydantic.Field(alias="targetBagPath")] = (
-        None
-    )
-    r"""Optionally, specify a bag as the target for K-V entries. If not specified, these entries are stored on each top-level event."""
-
-    delete_original: Annotated[
-        Optional[bool], pydantic.Field(alias="deleteOriginal")
-    ] = False
-    r"""Toggle this on to remove each original array of data objects after extraction. If toggled off, arrays are retained."""
-
-
 class FunctionMvPullTypedDict(TypedDict):
     filename: str
     group: str
@@ -60,7 +30,7 @@ class FunctionMvPullTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionMvPullSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaMvPullTypedDict]
 
 
 class FunctionMvPull(BaseModel):
@@ -95,5 +65,5 @@ class FunctionMvPull(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionMvPullSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaMvPull], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionnotificationpolicies.py

@@ -1,138 +1,21 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import models, utils
+from .functionconfschemanotificationpolicies import (
+    FunctionConfSchemaNotificationPolicies,
+    FunctionConfSchemaNotificationPoliciesTypedDict,
+)
 from cribl_control_plane.types import BaseModel
-from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
-from pydantic import field_serializer
-from pydantic.functional_validators import PlainValidator
-from typing import Any, Dict, List, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing import Any, Dict, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class FunctionNotificationPoliciesID(str, Enum):
     NOTIFICATION_POLICIES = "notification_policies"
 
 
-class Operator(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Comparison operator"""
-
-    EQUAL = "="
-    NOT_EQUAL = "!="
-    REGEX_MATCH = "=~"
-    REGEX_NOT_MATCH = "!~"
-
-
-ValueTypedDict = TypeAliasType("ValueTypedDict", Union[str, float, bool])
-r"""Value to compare against (string, number, boolean)"""
-
-
-Value = TypeAliasType("Value", Union[str, float, bool])
-r"""Value to compare against (string, number, boolean)"""
-
-
-class ConditionTypedDict(TypedDict):
-    key: str
-    r"""Event field name to match against"""
-    operator: Operator
-    r"""Comparison operator"""
-    value: ValueTypedDict
-    r"""Value to compare against (string, number, boolean)"""
-
-
-class Condition(BaseModel):
-    key: str
-    r"""Event field name to match against"""
-
-    operator: Annotated[Operator, PlainValidator(validate_open_enum(False))]
-    r"""Comparison operator"""
-
-    value: Value
-    r"""Value to compare against (string, number, boolean)"""
-
-    @field_serializer("operator")
-    def serialize_operator(self, value):
-        if isinstance(value, str):
-            try:
-                return models.Operator(value)
-            except ValueError:
-                return value
-        return value
-
-
-class TemplateTargetPairTypedDict(TypedDict):
-    template_id: str
-    r"""ID of the notification template to use"""
-    target_id: str
-    r"""ID of the notification target (output)"""
-
-
-class TemplateTargetPair(BaseModel):
-    template_id: Annotated[str, pydantic.Field(alias="templateId")]
-    r"""ID of the notification template to use"""
-
-    target_id: Annotated[str, pydantic.Field(alias="targetId")]
-    r"""ID of the notification target (output)"""
-
-
-class PolicyTypedDict(TypedDict):
-    id: str
-    r"""Unique identifier for this policy"""
-    template_target_pairs: List[TemplateTargetPairTypedDict]
-    r"""List of targets to route to and the templates to use"""
-    disabled: NotRequired[bool]
-    r"""If true, this policy will be skipped during evaluation"""
-    wait_to_group: NotRequired[float]
-    r"""Time to wait (in minutes) to group similar alerts before sending"""
-    group_by_labels: NotRequired[List[str]]
-    r"""Event fields to use for grouping"""
-    conditions: NotRequired[List[List[ConditionTypedDict]]]
-    r"""List of conditions. If ANY condition matches (OR), the policy applies. Each condition is a list of tags that must ALL match (AND)."""
-    final: NotRequired[bool]
-    r"""If true, stop evaluating further policies after this one matches"""
-
-
-class Policy(BaseModel):
-    id: str
-    r"""Unique identifier for this policy"""
-
-    template_target_pairs: Annotated[
-        List[TemplateTargetPair], pydantic.Field(alias="templateTargetPairs")
-    ]
-    r"""List of targets to route to and the templates to use"""
-
-    disabled: Optional[bool] = False
-    r"""If true, this policy will be skipped during evaluation"""
-
-    wait_to_group: Annotated[Optional[float], pydantic.Field(alias="waitToGroup")] = (
-        None
-    )
-    r"""Time to wait (in minutes) to group similar alerts before sending"""
-
-    group_by_labels: Annotated[
-        Optional[List[str]], pydantic.Field(alias="groupByLabels")
-    ] = None
-    r"""Event fields to use for grouping"""
-
-    conditions: Optional[List[List[Condition]]] = None
-    r"""List of conditions. If ANY condition matches (OR), the policy applies. Each condition is a list of tags that must ALL match (AND)."""
-
-    final: Optional[bool] = False
-    r"""If true, stop evaluating further policies after this one matches"""
-
-
-class NotificationPoliciesConfigurationTypedDict(TypedDict):
-    policies: NotRequired[List[PolicyTypedDict]]
-    r"""List of notification routing policies evaluated in order"""
-
-
-class NotificationPoliciesConfiguration(BaseModel):
-    policies: Optional[List[Policy]] = None
-    r"""List of notification routing policies evaluated in order"""
-
-
 class FunctionNotificationPoliciesTypedDict(TypedDict):
     filename: str
     group: str
@@ -147,7 +30,7 @@ class FunctionNotificationPoliciesTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[NotificationPoliciesConfigurationTypedDict]
+    schema_: NotRequired[FunctionConfSchemaNotificationPoliciesTypedDict]
 
 
 class FunctionNotificationPolicies(BaseModel):
@@ -182,5 +65,5 @@ class FunctionNotificationPolicies(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[NotificationPoliciesConfiguration], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaNotificationPolicies], pydantic.Field(alias="schema")
     ] = None