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

cribl_control_plane/models/functionsend.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 .functionconfschemasend import (
+    FunctionConfSchemaSend,
+    FunctionConfSchemaSendTypedDict,
+)
 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,78 +16,6 @@ class FunctionSendID(str, Enum):
     SEND = "send"
 
 
-class FunctionSendMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""In Sender mode, forwards search results directly to the destination. In Metrics mode, accumulates metrics from federated send operators, and forwards the aggregate metrics."""
-
-    SENDER = "sender"
-    METRICS = "metrics"
-
-
-class SendConfigurationTypedDict(TypedDict):
-    search_id: str
-    r"""Id of the search this function is running on."""
-    url: NotRequired[str]
-    r"""Full URL to send search to."""
-    group: NotRequired[str]
-    r"""Group within the workspace we're sending to."""
-    workspace: NotRequired[str]
-    r"""Workspace within the deployment to send the search results to."""
-    send_url_template: NotRequired[str]
-    r"""Template to build the URL to send from."""
-    tee: NotRequired[str]
-    r"""Tee results to search. When set to true results will be shipped instead of stats"""
-    flush_ms: NotRequired[float]
-    r"""How often are stats flushed in ms"""
-    suppress_previews: NotRequired[bool]
-    r"""Disables generation of intermediate stats. When true stats will be emitted only on end"""
-    mode: NotRequired[FunctionSendMode]
-    r"""In Sender mode, forwards search results directly to the destination. In Metrics mode, accumulates metrics from federated send operators, and forwards the aggregate metrics."""
-
-
-class SendConfiguration(BaseModel):
-    search_id: Annotated[str, pydantic.Field(alias="searchId")]
-    r"""Id of the search this function is running on."""
-
-    url: Optional[str] = None
-    r"""Full URL to send search to."""
-
-    group: Optional[str] = "default"
-    r"""Group within the workspace we're sending to."""
-
-    workspace: Optional[str] = "main"
-    r"""Workspace within the deployment to send the search results to."""
-
-    send_url_template: Annotated[
-        Optional[str], pydantic.Field(alias="sendUrlTemplate")
-    ] = None
-    r"""Template to build the URL to send from."""
-
-    tee: Optional[str] = "false"
-    r"""Tee results to search. When set to true results will be shipped instead of stats"""
-
-    flush_ms: Annotated[Optional[float], pydantic.Field(alias="flushMs")] = 1000
-    r"""How often are stats flushed in ms"""
-
-    suppress_previews: Annotated[
-        Optional[bool], pydantic.Field(alias="suppressPreviews")
-    ] = None
-    r"""Disables generation of intermediate stats. When true stats will be emitted only on end"""
-
-    mode: Annotated[
-        Optional[FunctionSendMode], PlainValidator(validate_open_enum(False))
-    ] = None
-    r"""In Sender mode, forwards search results directly to the destination. In Metrics mode, accumulates metrics from federated send operators, and forwards the aggregate metrics."""
-
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.FunctionSendMode(value)
-            except ValueError:
-                return value
-        return value
-
-
 class FunctionSendTypedDict(TypedDict):
     filename: str
     group: str
@@ -102,7 +30,7 @@ class FunctionSendTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[SendConfigurationTypedDict]
+    schema_: NotRequired[FunctionConfSchemaSendTypedDict]
 
 
 class FunctionSend(BaseModel):
@@ -136,6 +64,6 @@ class FunctionSend(BaseModel):
 
     sync: Optional[bool] = None
 
-    schema_: Annotated[Optional[SendConfiguration], pydantic.Field(alias="schema")] = (
-        None
-    )
+    schema_: Annotated[
+        Optional[FunctionConfSchemaSend], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionsensitivedatascanner.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemasensitivedatascanner import (
+    FunctionConfSchemaSensitiveDataScanner,
+    FunctionConfSchemaSensitiveDataScannerTypedDict,
+)
 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,69 +16,6 @@ class FunctionSensitiveDataScannerID(str, Enum):
     SENSITIVE_DATA_SCANNER = "sensitive_data_scanner"
 
 
-class FunctionSensitiveDataScannerRuleTypedDict(TypedDict):
-    ruleset_id: str
-    r"""The ID of the ruleset to use for the scan"""
-    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]
-
-
-class FunctionSensitiveDataScannerRule(BaseModel):
-    ruleset_id: Annotated[str, pydantic.Field(alias="rulesetId")]
-    r"""The ID of the ruleset to use for the scan"""
-
-    replace_expr: Annotated[Optional[str], pydantic.Field(alias="replaceExpr")] = (
-        "'REDACTED'"
-    )
-    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
-
-
-class FunctionSensitiveDataScannerFlagTypedDict(TypedDict):
-    value: str
-    name: NotRequired[str]
-
-
-class FunctionSensitiveDataScannerFlag(BaseModel):
-    value: str
-
-    name: Optional[str] = None
-
-
-class FunctionSensitiveDataScannerSchemaTypedDict(TypedDict):
-    rules: List[FunctionSensitiveDataScannerRuleTypedDict]
-    fields: NotRequired[List[str]]
-    r"""Rulesets act on the events contained in these fields. Mitigation expressions apply to the scan results. Supports wildcards (*)."""
-    exclude_fields: NotRequired[List[str]]
-    r"""Fields that the mitigation expression will not be applied to. Supports wildcards (*)."""
-    flags: NotRequired[List[FunctionSensitiveDataScannerFlagTypedDict]]
-    r"""Fields to add when mitigation is applied to an event"""
-    include_detected_rules: NotRequired[bool]
-    r"""If enabled, Add matching ruleset IDs to a field called \"__detected\" """
-
-
-class FunctionSensitiveDataScannerSchema(BaseModel):
-    rules: List[FunctionSensitiveDataScannerRule]
-
-    fields: Optional[List[str]] = None
-    r"""Rulesets act on the events contained in these fields. Mitigation expressions apply to the scan results. Supports wildcards (*)."""
-
-    exclude_fields: Annotated[
-        Optional[List[str]], pydantic.Field(alias="excludeFields")
-    ] = None
-    r"""Fields that the mitigation expression will not be applied to. Supports wildcards (*)."""
-
-    flags: Optional[List[FunctionSensitiveDataScannerFlag]] = None
-    r"""Fields to add when mitigation is applied to an event"""
-
-    include_detected_rules: Annotated[
-        Optional[bool], pydantic.Field(alias="includeDetectedRules")
-    ] = True
-    r"""If enabled, Add matching ruleset IDs to a field called \"__detected\" """
-
-
 class FunctionSensitiveDataScannerTypedDict(TypedDict):
     filename: str
     group: str
@@ -89,7 +30,7 @@ class FunctionSensitiveDataScannerTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionSensitiveDataScannerSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaSensitiveDataScannerTypedDict]
 
 
 class FunctionSensitiveDataScanner(BaseModel):
@@ -124,5 +65,5 @@ class FunctionSensitiveDataScanner(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionSensitiveDataScannerSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaSensitiveDataScanner], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionserde.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 .functionconfschemaserde import (
+    FunctionConfSchemaSerde,
+    FunctionConfSchemaSerdeTypedDict,
+)
 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,98 +16,6 @@ class FunctionSerdeID(str, Enum):
     SERDE = "serde"
 
 
-class OperationMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Extract creates new fields. Reserialize extracts and filters fields, and then reserializes."""
-
-    # Extract
-    EXTRACT = "extract"
-    # Reserialize
-    RESERIALIZE = "reserialize"
-
-
-class FunctionSerdeType(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Parser or formatter type to use"""
-
-    # CSV
-    CSV = "csv"
-    # Extended Log File Format
-    ELFF = "elff"
-    # Common Log Format
-    CLF = "clf"
-    # Key=Value Pairs
-    KVP = "kvp"
-    # JSON Object
-    JSON = "json"
-    # Delimited values
-    DELIM = "delim"
-    # Regular Expression
-    REGEX = "regex"
-    # Grok
-    GROK = "grok"
-
-
-class FunctionSerdeSchemaTypedDict(TypedDict):
-    mode: NotRequired[OperationMode]
-    r"""Extract creates new fields. Reserialize extracts and filters fields, and then reserializes."""
-    type: NotRequired[FunctionSerdeType]
-    r"""Parser or formatter type to use"""
-    delim_char: NotRequired[Any]
-    quote_char: NotRequired[Any]
-    escape_char: NotRequired[Any]
-    null_value: NotRequired[Any]
-    src_field: NotRequired[str]
-    r"""Field containing text to be parsed"""
-    dst_field: NotRequired[str]
-    r"""Name of the field to add fields to. Extract mode only."""
-    clean_fields: NotRequired[Any]
-
-
-class FunctionSerdeSchema(BaseModel):
-    mode: Annotated[
-        Optional[OperationMode], PlainValidator(validate_open_enum(False))
-    ] = OperationMode.EXTRACT
-    r"""Extract creates new fields. Reserialize extracts and filters fields, and then reserializes."""
-
-    type: Annotated[
-        Optional[FunctionSerdeType], PlainValidator(validate_open_enum(False))
-    ] = FunctionSerdeType.CSV
-    r"""Parser or formatter type to use"""
-
-    delim_char: Annotated[Optional[Any], pydantic.Field(alias="delimChar")] = None
-
-    quote_char: Annotated[Optional[Any], pydantic.Field(alias="quoteChar")] = None
-
-    escape_char: Annotated[Optional[Any], pydantic.Field(alias="escapeChar")] = None
-
-    null_value: Annotated[Optional[Any], pydantic.Field(alias="nullValue")] = None
-
-    src_field: Annotated[Optional[str], pydantic.Field(alias="srcField")] = "_raw"
-    r"""Field containing text to be parsed"""
-
-    dst_field: Annotated[Optional[str], pydantic.Field(alias="dstField")] = None
-    r"""Name of the field to add fields to. Extract mode only."""
-
-    clean_fields: Annotated[Optional[Any], pydantic.Field(alias="cleanFields")] = None
-
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OperationMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("type")
-    def serialize_type(self, value):
-        if isinstance(value, str):
-            try:
-                return models.FunctionSerdeType(value)
-            except ValueError:
-                return value
-        return value
-
-
 class FunctionSerdeTypedDict(TypedDict):
     filename: str
     group: str
@@ -122,7 +30,7 @@ class FunctionSerdeTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionSerdeSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaSerdeTypedDict]
 
 
 class FunctionSerde(BaseModel):
@@ -157,5 +65,5 @@ class FunctionSerde(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionSerdeSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaSerde], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionserialize.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 .functionconfschemaserialize import (
+    FunctionConfSchemaSerialize,
+    FunctionConfSchemaSerializeTypedDict,
+)
 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,71 +16,6 @@ class FunctionSerializeID(str, Enum):
     SERIALIZE = "serialize"
 
 
-class FunctionSerializeType(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Data output format"""
-
-    # CSV
-    CSV = "csv"
-    # Extended Log File Format
-    ELFF = "elff"
-    # Common Log Format
-    CLF = "clf"
-    # Key=Value Pairs
-    KVP = "kvp"
-    # JSON Object
-    JSON = "json"
-    # Delimited values
-    DELIM = "delim"
-
-
-class FunctionSerializeSchemaTypedDict(TypedDict):
-    type: NotRequired[FunctionSerializeType]
-    r"""Data output format"""
-    delim_char: NotRequired[Any]
-    quote_char: NotRequired[Any]
-    escape_char: NotRequired[Any]
-    null_value: NotRequired[Any]
-    fields: NotRequired[List[str]]
-    r"""Required for CSV, ELFF, CLF, and Delimited values. All other formats support wildcard field lists. Examples: host, array*, !host *"""
-    src_field: NotRequired[str]
-    r"""Field containing object to serialize. Leave blank to serialize top-level event fields."""
-    dst_field: NotRequired[str]
-    r"""Field to serialize data to"""
-
-
-class FunctionSerializeSchema(BaseModel):
-    type: Annotated[
-        Optional[FunctionSerializeType], PlainValidator(validate_open_enum(False))
-    ] = FunctionSerializeType.CSV
-    r"""Data output format"""
-
-    delim_char: Annotated[Optional[Any], pydantic.Field(alias="delimChar")] = None
-
-    quote_char: Annotated[Optional[Any], pydantic.Field(alias="quoteChar")] = None
-
-    escape_char: Annotated[Optional[Any], pydantic.Field(alias="escapeChar")] = None
-
-    null_value: Annotated[Optional[Any], pydantic.Field(alias="nullValue")] = None
-
-    fields: Optional[List[str]] = None
-    r"""Required for CSV, ELFF, CLF, and Delimited values. All other formats support wildcard field lists. Examples: host, array*, !host *"""
-
-    src_field: Annotated[Optional[str], pydantic.Field(alias="srcField")] = None
-    r"""Field containing object to serialize. Leave blank to serialize top-level event fields."""
-
-    dst_field: Annotated[Optional[str], pydantic.Field(alias="dstField")] = "_raw"
-    r"""Field to serialize data to"""
-
-    @field_serializer("type")
-    def serialize_type(self, value):
-        if isinstance(value, str):
-            try:
-                return models.FunctionSerializeType(value)
-            except ValueError:
-                return value
-        return value
-
-
 class FunctionSerializeTypedDict(TypedDict):
     filename: str
     group: str
@@ -95,7 +30,7 @@ class FunctionSerializeTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionSerializeSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaSerializeTypedDict]
 
 
 class FunctionSerialize(BaseModel):
@@ -130,5 +65,5 @@ class FunctionSerialize(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionSerializeSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaSerialize], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionsidlookup.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemasidlookup import (
+    FunctionConfSchemaSidlookup,
+    FunctionConfSchemaSidlookupTypedDict,
+)
 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,34 +16,6 @@ class FunctionSidlookupID(str, Enum):
     SIDLOOKUP = "sidlookup"
 
 
-class FunctionSidlookupFieldTypedDict(TypedDict):
-    expr: str
-    r"""JavaScript expression to compute the value (can be constant)"""
-    name: NotRequired[str]
-    disabled: NotRequired[bool]
-    r"""Set to No to disable the evaluation of an individual expression"""
-
-
-class FunctionSidlookupField(BaseModel):
-    expr: str
-    r"""JavaScript expression to compute the value (can be constant)"""
-
-    name: Optional[str] = None
-
-    disabled: Optional[bool] = False
-    r"""Set to No to disable the evaluation of an individual expression"""
-
-
-class FunctionSidlookupSchemaTypedDict(TypedDict):
-    fields: NotRequired[List[FunctionSidlookupFieldTypedDict]]
-    r"""Set of expressions matched to lookup responses"""
-
-
-class FunctionSidlookupSchema(BaseModel):
-    fields: Optional[List[FunctionSidlookupField]] = None
-    r"""Set of expressions matched to lookup responses"""
-
-
 class FunctionSidlookupTypedDict(TypedDict):
     filename: str
     group: str
@@ -54,7 +30,7 @@ class FunctionSidlookupTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionSidlookupSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaSidlookupTypedDict]
 
 
 class FunctionSidlookup(BaseModel):
@@ -89,5 +65,5 @@ class FunctionSidlookup(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionSidlookupSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaSidlookup], pydantic.Field(alias="schema")
     ] = None

cribl_control_plane/models/functionsnmptrapserialize.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 .functionconfschemasnmptrapserialize import (
+    FunctionConfSchemaSnmpTrapSerialize,
+    FunctionConfSchemaSnmpTrapSerializeTypedDict,
+)
 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,81 +16,6 @@ class FunctionSnmpTrapSerializeID(str, Enum):
     SNMP_TRAP_SERIALIZE = "snmp_trap_serialize"
 
 
-class FunctionSnmpTrapSerializeAuthenticationProtocol(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
-    # None
-    NONE = "none"
-    # MD5
-    MD5 = "md5"
-    # SHA1
-    SHA = "sha"
-    # SHA224
-    SHA224 = "sha224"
-    # SHA256
-    SHA256 = "sha256"
-    # SHA384
-    SHA384 = "sha384"
-    # SHA512
-    SHA512 = "sha512"
-
-
-class FunctionSnmpTrapSerializeV3UserTypedDict(TypedDict):
-    name: NotRequired[str]
-    auth_protocol: NotRequired[FunctionSnmpTrapSerializeAuthenticationProtocol]
-    auth_key: NotRequired[Any]
-    priv_protocol: NotRequired[str]
-
-
-class FunctionSnmpTrapSerializeV3User(BaseModel):
-    name: Optional[str] = None
-
-    auth_protocol: Annotated[
-        Annotated[
-            Optional[FunctionSnmpTrapSerializeAuthenticationProtocol],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="authProtocol"),
-    ] = FunctionSnmpTrapSerializeAuthenticationProtocol.NONE
-
-    auth_key: Annotated[Optional[Any], pydantic.Field(alias="authKey")] = None
-
-    priv_protocol: Annotated[Optional[str], pydantic.Field(alias="privProtocol")] = (
-        "none"
-    )
-
-    @field_serializer("auth_protocol")
-    def serialize_auth_protocol(self, value):
-        if isinstance(value, str):
-            try:
-                return models.FunctionSnmpTrapSerializeAuthenticationProtocol(value)
-            except ValueError:
-                return value
-        return value
-
-
-class FunctionSnmpTrapSerializeSchemaTypedDict(TypedDict):
-    strict: NotRequired[bool]
-    r"""Prevent event serialization if any required fields are missing. When disabled, @{product} will attempt to serialize the event even if required fields are missing, which could cause unexpected behavior at the downstream receiver."""
-    drop_failed_events: NotRequired[bool]
-    r"""When disabled, `snmpSerializeErrors` will be set on the event, and the `__snmpRaw` field will be removed to prevent @{product} from sending the event from the SNMP Trap Destination"""
-    v3_user: NotRequired[FunctionSnmpTrapSerializeV3UserTypedDict]
-
-
-class FunctionSnmpTrapSerializeSchema(BaseModel):
-    strict: Optional[bool] = True
-    r"""Prevent event serialization if any required fields are missing. When disabled, @{product} will attempt to serialize the event even if required fields are missing, which could cause unexpected behavior at the downstream receiver."""
-
-    drop_failed_events: Annotated[
-        Optional[bool], pydantic.Field(alias="dropFailedEvents")
-    ] = True
-    r"""When disabled, `snmpSerializeErrors` will be set on the event, and the `__snmpRaw` field will be removed to prevent @{product} from sending the event from the SNMP Trap Destination"""
-
-    v3_user: Annotated[
-        Optional[FunctionSnmpTrapSerializeV3User], pydantic.Field(alias="v3User")
-    ] = None
-
-
 class FunctionSnmpTrapSerializeTypedDict(TypedDict):
     filename: str
     group: str
@@ -105,7 +30,7 @@ class FunctionSnmpTrapSerializeTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[FunctionSnmpTrapSerializeSchemaTypedDict]
+    schema_: NotRequired[FunctionConfSchemaSnmpTrapSerializeTypedDict]
 
 
 class FunctionSnmpTrapSerialize(BaseModel):
@@ -140,5 +65,5 @@ class FunctionSnmpTrapSerialize(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[FunctionSnmpTrapSerializeSchema], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaSnmpTrapSerialize], pydantic.Field(alias="schema")
     ] = None