nominal-api 0.755.2__py3-none-any.whl → 0.756.0__py3-none-any.whl

nominal_api/_impl.py

@@ -14250,6 +14250,59 @@ module_CreateModuleRequest.__qualname__ = "CreateModuleRequest"
 module_CreateModuleRequest.__module__ = "nominal_api.module"
 
 
+class module_DerivedSeriesMetadata(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'function_name': ConjureFieldDefinition('functionName', str),
+            'function_description': ConjureFieldDefinition('functionDescription', str),
+            'module_name': ConjureFieldDefinition('moduleName', str),
+            'module_rid': ConjureFieldDefinition('moduleRid', modules_api_ModuleRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'data_type': ConjureFieldDefinition('dataType', module_ValueType)
+        }
+
+    __slots__: List[str] = ['_function_name', '_function_description', '_module_name', '_module_rid', '_asset_rid', '_data_type']
+
+    def __init__(self, asset_rid: str, data_type: "module_ValueType", function_description: str, function_name: str, module_name: str, module_rid: str) -> None:
+        self._function_name = function_name
+        self._function_description = function_description
+        self._module_name = module_name
+        self._module_rid = module_rid
+        self._asset_rid = asset_rid
+        self._data_type = data_type
+
+    @builtins.property
+    def function_name(self) -> str:
+        return self._function_name
+
+    @builtins.property
+    def function_description(self) -> str:
+        return self._function_description
+
+    @builtins.property
+    def module_name(self) -> str:
+        return self._module_name
+
+    @builtins.property
+    def module_rid(self) -> str:
+        return self._module_rid
+
+    @builtins.property
+    def asset_rid(self) -> str:
+        return self._asset_rid
+
+    @builtins.property
+    def data_type(self) -> "module_ValueType":
+        return self._data_type
+
+
+module_DerivedSeriesMetadata.__name__ = "DerivedSeriesMetadata"
+module_DerivedSeriesMetadata.__qualname__ = "DerivedSeriesMetadata"
+module_DerivedSeriesMetadata.__module__ = "nominal_api.module"
+
+
 class module_Function(ConjureBeanType):
 
     @builtins.classmethod
@@ -14435,6 +14488,86 @@ module_FunctionParameter.__qualname__ = "FunctionParameter"
 module_FunctionParameter.__module__ = "nominal_api.module"
 
 
+class module_GetDerivedSeriesRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'exact_match': ConjureFieldDefinition('exactMatch', OptionalTypeWrapper[str]),
+            'return_types': ConjureFieldDefinition('returnTypes', OptionalTypeWrapper[List[module_ValueType]]),
+            'page_size': ConjureFieldDefinition('pageSize', int),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_asset_rid', '_exact_match', '_return_types', '_page_size', '_next_page_token']
+
+    def __init__(self, asset_rid: str, page_size: int, exact_match: Optional[str] = None, next_page_token: Optional[str] = None, return_types: Optional[List["module_ValueType"]] = None) -> None:
+        self._asset_rid = asset_rid
+        self._exact_match = exact_match
+        self._return_types = return_types
+        self._page_size = page_size
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def asset_rid(self) -> str:
+        return self._asset_rid
+
+    @builtins.property
+    def exact_match(self) -> Optional[str]:
+        """Search text which will be checked for exact matches with the derived channel names.
+        """
+        return self._exact_match
+
+    @builtins.property
+    def return_types(self) -> Optional[List["module_ValueType"]]:
+        """Optional filter to limit the returned derived channels to those with specified return data type.
+        """
+        return self._return_types
+
+    @builtins.property
+    def page_size(self) -> int:
+        return self._page_size
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+module_GetDerivedSeriesRequest.__name__ = "GetDerivedSeriesRequest"
+module_GetDerivedSeriesRequest.__qualname__ = "GetDerivedSeriesRequest"
+module_GetDerivedSeriesRequest.__module__ = "nominal_api.module"
+
+
+class module_GetDerivedSeriesResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'results': ConjureFieldDefinition('results', List[module_DerivedSeriesMetadata]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_results', '_next_page_token']
+
+    def __init__(self, results: List["module_DerivedSeriesMetadata"], next_page_token: Optional[str] = None) -> None:
+        self._results = results
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def results(self) -> List["module_DerivedSeriesMetadata"]:
+        return self._results
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+module_GetDerivedSeriesResponse.__name__ = "GetDerivedSeriesResponse"
+module_GetDerivedSeriesResponse.__qualname__ = "GetDerivedSeriesResponse"
+module_GetDerivedSeriesResponse.__module__ = "nominal_api.module"
+
+
 class module_GetModuleRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -14931,6 +15064,38 @@ to assets. The Modules Service provides the api for managing these collections a
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), module_SearchModuleApplicationsResponse, self._return_none_for_unknown_union_types)
 
+    def get_derived_series(self, auth_header: str, request: "module_GetDerivedSeriesRequest") -> "module_GetDerivedSeriesResponse":
+        """Get the derived series from modules applied to an asset.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/scout/v2/module/derived-series/get'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), module_GetDerivedSeriesResponse, self._return_none_for_unknown_union_types)
+
 
 module_ModuleService.__name__ = "ModuleService"
 module_ModuleService.__qualname__ = "ModuleService"
@@ -31893,12 +32058,12 @@ class scout_checks_api_CheckContext(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_checks_api_VariableLocator]),
-            'sub_function_variables': ConjureFieldDefinition('subFunctionVariables', Dict[scout_compute_api_FunctionReference, scout_checks_api_CheckContext])
+            'sub_function_variables': ConjureFieldDefinition('subFunctionVariables', OptionalTypeWrapper[Dict[scout_compute_api_FunctionReference, scout_checks_api_CheckContext]])
         }
 
     __slots__: List[str] = ['_variables', '_sub_function_variables']
 
-    def __init__(self, sub_function_variables: Dict[str, "scout_checks_api_CheckContext"], variables: Dict[str, "scout_checks_api_VariableLocator"]) -> None:
+    def __init__(self, variables: Dict[str, "scout_checks_api_VariableLocator"], sub_function_variables: Optional[Dict[str, "scout_checks_api_CheckContext"]] = None) -> None:
         self._variables = variables
         self._sub_function_variables = sub_function_variables
 
@@ -31907,7 +32072,7 @@ class scout_checks_api_CheckContext(ConjureBeanType):
         return self._variables
 
     @builtins.property
-    def sub_function_variables(self) -> Dict[str, "scout_checks_api_CheckContext"]:
+    def sub_function_variables(self) -> Optional[Dict[str, "scout_checks_api_CheckContext"]]:
         return self._sub_function_variables
 
 
@@ -32443,11 +32608,11 @@ scout_checks_api_ChecklistSearchQueryVisitor.__module__ = "nominal_api.scout_che
 
 class scout_checks_api_ChecklistService(Service):
     """The Checklist Service is responsible for managing checklists and checks.
-A checklist is a collection of checks and functions that can be executed against a set of data sources.
+A checklist is a collection of checks that can be executed against a set of data sources.
     """
 
     def create(self, auth_header: str, request: "scout_checks_api_CreateChecklistRequest") -> "scout_checks_api_VersionedChecklist":
-        """Creates a new checklist with the provided checks and functions.
+        """Creates a new checklist with the provided checks.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -32996,17 +33161,15 @@ class scout_checks_api_CommitChecklistRequest(ConjureBeanType):
         return {
             'commit_message': ConjureFieldDefinition('commitMessage', str),
             'checks': ConjureFieldDefinition('checks', List[scout_checks_api_UpdateChecklistEntryRequest]),
-            'functions': ConjureFieldDefinition('functions', Dict[scout_compute_api_FunctionReference, scout_checks_api_UpdateFunctionEntryRequest]),
             'checklist_variables': ConjureFieldDefinition('checklistVariables', List[scout_checks_api_UnresolvedChecklistVariable]),
             'latest_commit': ConjureFieldDefinition('latestCommit', OptionalTypeWrapper[scout_versioning_api_CommitId])
         }
 
-    __slots__: List[str] = ['_commit_message', '_checks', '_functions', '_checklist_variables', '_latest_commit']
+    __slots__: List[str] = ['_commit_message', '_checks', '_checklist_variables', '_latest_commit']
 
-    def __init__(self, checklist_variables: List["scout_checks_api_UnresolvedChecklistVariable"], checks: List["scout_checks_api_UpdateChecklistEntryRequest"], commit_message: str, functions: Dict[str, "scout_checks_api_UpdateFunctionEntryRequest"], latest_commit: Optional[str] = None) -> None:
+    def __init__(self, checklist_variables: List["scout_checks_api_UnresolvedChecklistVariable"], checks: List["scout_checks_api_UpdateChecklistEntryRequest"], commit_message: str, latest_commit: Optional[str] = None) -> None:
         self._commit_message = commit_message
         self._checks = checks
-        self._functions = functions
         self._checklist_variables = checklist_variables
         self._latest_commit = latest_commit
 
@@ -33018,15 +33181,9 @@ class scout_checks_api_CommitChecklistRequest(ConjureBeanType):
     def checks(self) -> List["scout_checks_api_UpdateChecklistEntryRequest"]:
         return self._checks
 
-    @builtins.property
-    def functions(self) -> Dict[str, "scout_checks_api_UpdateFunctionEntryRequest"]:
-        """The keys of the map are references that can be used for checks to reference functions in the same request, before the function RIDs have been created.
-        """
-        return self._functions
-
     @builtins.property
     def checklist_variables(self) -> List["scout_checks_api_UnresolvedChecklistVariable"]:
-        """Variables that can be used in checks and functions. Variables are resolved in order of declaration.
+        """Variables that can be used in checks. Variables are resolved in order of declaration.
 If variable `a` depends on variable `b`, then `b` must be defined before `a` in the list.
         """
         return self._checklist_variables
@@ -33120,13 +33277,12 @@ class scout_checks_api_CreateCheckRequest(ConjureBeanType):
             'auto_generated_description': ConjureFieldDefinition('autoGeneratedDescription', OptionalTypeWrapper[str]),
             'priority': ConjureFieldDefinition('priority', scout_api_Priority),
             'generated_event_type': ConjureFieldDefinition('generatedEventType', OptionalTypeWrapper[event_EventType]),
-            'chart': ConjureFieldDefinition('chart', OptionalTypeWrapper[scout_rids_api_VersionedVizId]),
             'condition': ConjureFieldDefinition('condition', OptionalTypeWrapper[scout_checks_api_UnresolvedCheckCondition])
         }
 
-    __slots__: List[str] = ['_check_lineage_rid', '_title', '_description', '_auto_generated_title', '_auto_generated_description', '_priority', '_generated_event_type', '_chart', '_condition']
+    __slots__: List[str] = ['_check_lineage_rid', '_title', '_description', '_auto_generated_title', '_auto_generated_description', '_priority', '_generated_event_type', '_condition']
 
-    def __init__(self, description: str, priority: "scout_api_Priority", title: str, auto_generated_description: Optional[str] = None, auto_generated_title: Optional[str] = None, chart: Optional["scout_rids_api_VersionedVizId"] = None, check_lineage_rid: Optional[str] = None, condition: Optional["scout_checks_api_UnresolvedCheckCondition"] = None, generated_event_type: Optional["event_EventType"] = None) -> None:
+    def __init__(self, description: str, priority: "scout_api_Priority", title: str, auto_generated_description: Optional[str] = None, auto_generated_title: Optional[str] = None, check_lineage_rid: Optional[str] = None, condition: Optional["scout_checks_api_UnresolvedCheckCondition"] = None, generated_event_type: Optional["event_EventType"] = None) -> None:
         self._check_lineage_rid = check_lineage_rid
         self._title = title
         self._description = description
@@ -33134,7 +33290,6 @@ class scout_checks_api_CreateCheckRequest(ConjureBeanType):
         self._auto_generated_description = auto_generated_description
         self._priority = priority
         self._generated_event_type = generated_event_type
-        self._chart = chart
         self._condition = condition
 
     @builtins.property
@@ -33168,13 +33323,9 @@ This is named checkLineageRid for historical reasons but is actually a UUID.
     def generated_event_type(self) -> Optional["event_EventType"]:
         return self._generated_event_type
 
-    @builtins.property
-    def chart(self) -> Optional["scout_rids_api_VersionedVizId"]:
-        return self._chart
-
     @builtins.property
     def condition(self) -> Optional["scout_checks_api_UnresolvedCheckCondition"]:
-        """If omitted, this check represents a manual check.
+        """This field should not be omitted.
         """
         return self._condition
 
@@ -33249,7 +33400,6 @@ class scout_checks_api_CreateChecklistRequest(ConjureBeanType):
             'assignee_rid': ConjureFieldDefinition('assigneeRid', scout_rids_api_UserRid),
             'title': ConjureFieldDefinition('title', str),
             'description': ConjureFieldDefinition('description', str),
-            'functions': ConjureFieldDefinition('functions', Dict[scout_compute_api_FunctionReference, scout_checks_api_CreateFunctionRequest]),
             'checks': ConjureFieldDefinition('checks', List[scout_checks_api_CreateChecklistEntryRequest]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
@@ -33258,14 +33408,13 @@ class scout_checks_api_CreateChecklistRequest(ConjureBeanType):
             'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_rids_WorkspaceRid])
         }
 
-    __slots__: List[str] = ['_commit_message', '_assignee_rid', '_title', '_description', '_functions', '_checks', '_properties', '_labels', '_checklist_variables', '_is_published', '_workspace']
+    __slots__: List[str] = ['_commit_message', '_assignee_rid', '_title', '_description', '_checks', '_properties', '_labels', '_checklist_variables', '_is_published', '_workspace']
 
-    def __init__(self, assignee_rid: str, checklist_variables: List["scout_checks_api_UnresolvedChecklistVariable"], checks: List["scout_checks_api_CreateChecklistEntryRequest"], commit_message: str, description: str, functions: Dict[str, "scout_checks_api_CreateFunctionRequest"], labels: List[str], properties: Dict[str, str], title: str, is_published: Optional[bool] = None, workspace: Optional[str] = None) -> None:
+    def __init__(self, assignee_rid: str, checklist_variables: List["scout_checks_api_UnresolvedChecklistVariable"], checks: List["scout_checks_api_CreateChecklistEntryRequest"], commit_message: str, description: str, labels: List[str], properties: Dict[str, str], title: str, is_published: Optional[bool] = None, workspace: Optional[str] = None) -> None:
         self._commit_message = commit_message
         self._assignee_rid = assignee_rid
         self._title = title
         self._description = description
-        self._functions = functions
         self._checks = checks
         self._properties = properties
         self._labels = labels
@@ -33289,12 +33438,6 @@ class scout_checks_api_CreateChecklistRequest(ConjureBeanType):
     def description(self) -> str:
         return self._description
 
-    @builtins.property
-    def functions(self) -> Dict[str, "scout_checks_api_CreateFunctionRequest"]:
-        """The keys of the map are references that can be used for checks to reference functions in the same request, before the function RIDs have been created.
-        """
-        return self._functions
-
     @builtins.property
     def checks(self) -> List["scout_checks_api_CreateChecklistEntryRequest"]:
         return self._checks
@@ -33309,7 +33452,7 @@ class scout_checks_api_CreateChecklistRequest(ConjureBeanType):
 
     @builtins.property
     def checklist_variables(self) -> List["scout_checks_api_UnresolvedChecklistVariable"]:
-        """Variables that can be used in checks and functions. Variables are resolved in order of declaration.
+        """Variables that can be used in checks. Variables are resolved in order of declaration.
 If variable `a` depends on variable `b`, then `b` must be defined before `a` in the list.
         """
         return self._checklist_variables
@@ -33333,61 +33476,6 @@ scout_checks_api_CreateChecklistRequest.__qualname__ = "CreateChecklistRequest"
 scout_checks_api_CreateChecklistRequest.__module__ = "nominal_api.scout_checks_api"
 
 
-class scout_checks_api_CreateFunctionRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'function_lineage_rid': ConjureFieldDefinition('functionLineageRid', OptionalTypeWrapper[scout_rids_api_FunctionLineageRid]),
-            'title': ConjureFieldDefinition('title', str),
-            'description': ConjureFieldDefinition('description', str),
-            'auto_generated_title': ConjureFieldDefinition('autoGeneratedTitle', OptionalTypeWrapper[str]),
-            'auto_generated_description': ConjureFieldDefinition('autoGeneratedDescription', OptionalTypeWrapper[str]),
-            'node': ConjureFieldDefinition('node', scout_checks_api_FunctionNode)
-        }
-
-    __slots__: List[str] = ['_function_lineage_rid', '_title', '_description', '_auto_generated_title', '_auto_generated_description', '_node']
-
-    def __init__(self, description: str, node: "scout_checks_api_FunctionNode", title: str, auto_generated_description: Optional[str] = None, auto_generated_title: Optional[str] = None, function_lineage_rid: Optional[str] = None) -> None:
-        self._function_lineage_rid = function_lineage_rid
-        self._title = title
-        self._description = description
-        self._auto_generated_title = auto_generated_title
-        self._auto_generated_description = auto_generated_description
-        self._node = node
-
-    @builtins.property
-    def function_lineage_rid(self) -> Optional[str]:
-        """Identifies the lineage of functions this function belongs to. If not specified, a new lineage will be created.
-        """
-        return self._function_lineage_rid
-
-    @builtins.property
-    def title(self) -> str:
-        return self._title
-
-    @builtins.property
-    def description(self) -> str:
-        return self._description
-
-    @builtins.property
-    def auto_generated_title(self) -> Optional[str]:
-        return self._auto_generated_title
-
-    @builtins.property
-    def auto_generated_description(self) -> Optional[str]:
-        return self._auto_generated_description
-
-    @builtins.property
-    def node(self) -> "scout_checks_api_FunctionNode":
-        return self._node
-
-
-scout_checks_api_CreateFunctionRequest.__name__ = "CreateFunctionRequest"
-scout_checks_api_CreateFunctionRequest.__qualname__ = "CreateFunctionRequest"
-scout_checks_api_CreateFunctionRequest.__module__ = "nominal_api.scout_checks_api"
-
-
 class scout_checks_api_DeprecatedCheckJobSpec(ConjureBeanType):
 
     @builtins.classmethod
@@ -33483,6 +33571,8 @@ scout_checks_api_Failed.__module__ = "nominal_api.scout_checks_api"
 
 
 class scout_checks_api_Function(ConjureBeanType):
+    """This function type is unsupported.
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -34094,12 +34184,12 @@ class scout_checks_api_NumRangesConditionV3(ConjureBeanType):
             'threshold': ConjureFieldDefinition('threshold', int),
             'operator': ConjureFieldDefinition('operator', scout_compute_api_ThresholdOperator),
             'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_checks_api_VariableLocator]),
-            'function_variables': ConjureFieldDefinition('functionVariables', Dict[scout_compute_api_FunctionReference, scout_checks_api_CheckContext])
+            'function_variables': ConjureFieldDefinition('functionVariables', OptionalTypeWrapper[Dict[scout_compute_api_FunctionReference, scout_checks_api_CheckContext]])
         }
 
     __slots__: List[str] = ['_ranges', '_function_spec', '_threshold', '_operator', '_variables', '_function_variables']
 
-    def __init__(self, function_spec: Any, function_variables: Dict[str, "scout_checks_api_CheckContext"], operator: "scout_compute_api_ThresholdOperator", ranges: "scout_compute_api_RangeSeries", threshold: int, variables: Dict[str, "scout_checks_api_VariableLocator"]) -> None:
+    def __init__(self, function_spec: Any, operator: "scout_compute_api_ThresholdOperator", ranges: "scout_compute_api_RangeSeries", threshold: int, variables: Dict[str, "scout_checks_api_VariableLocator"], function_variables: Optional[Dict[str, "scout_checks_api_CheckContext"]] = None) -> None:
         self._ranges = ranges
         self._function_spec = function_spec
         self._threshold = threshold
@@ -34128,10 +34218,7 @@ class scout_checks_api_NumRangesConditionV3(ConjureBeanType):
         return self._variables
 
     @builtins.property
-    def function_variables(self) -> Dict[str, "scout_checks_api_CheckContext"]:
-        """The variables to be passed into functions referenced by the check condition. The function reference key
-should match the FunctionReference in the function node definition.
-        """
+    def function_variables(self) -> Optional[Dict[str, "scout_checks_api_CheckContext"]]:
         return self._function_variables
 
 
@@ -34209,16 +34296,14 @@ class scout_checks_api_SaveChecklistRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'checks': ConjureFieldDefinition('checks', List[scout_checks_api_UpdateChecklistEntryRequest]),
-            'functions': ConjureFieldDefinition('functions', Dict[scout_compute_api_FunctionReference, scout_checks_api_UpdateFunctionEntryRequest]),
             'checklist_variables': ConjureFieldDefinition('checklistVariables', List[scout_checks_api_UnresolvedChecklistVariable]),
             'latest_commit': ConjureFieldDefinition('latestCommit', OptionalTypeWrapper[scout_versioning_api_CommitId])
         }
 
-    __slots__: List[str] = ['_checks', '_functions', '_checklist_variables', '_latest_commit']
+    __slots__: List[str] = ['_checks', '_checklist_variables', '_latest_commit']
 
-    def __init__(self, checklist_variables: List["scout_checks_api_UnresolvedChecklistVariable"], checks: List["scout_checks_api_UpdateChecklistEntryRequest"], functions: Dict[str, "scout_checks_api_UpdateFunctionEntryRequest"], latest_commit: Optional[str] = None) -> None:
+    def __init__(self, checklist_variables: List["scout_checks_api_UnresolvedChecklistVariable"], checks: List["scout_checks_api_UpdateChecklistEntryRequest"], latest_commit: Optional[str] = None) -> None:
         self._checks = checks
-        self._functions = functions
         self._checklist_variables = checklist_variables
         self._latest_commit = latest_commit
 
@@ -34226,15 +34311,9 @@ class scout_checks_api_SaveChecklistRequest(ConjureBeanType):
     def checks(self) -> List["scout_checks_api_UpdateChecklistEntryRequest"]:
         return self._checks
 
-    @builtins.property
-    def functions(self) -> Dict[str, "scout_checks_api_UpdateFunctionEntryRequest"]:
-        """The keys of the map are references that can be used for checks to reference functions in the same request, before the function RIDs have been created.
-        """
-        return self._functions
-
     @builtins.property
     def checklist_variables(self) -> List["scout_checks_api_UnresolvedChecklistVariable"]:
-        """Variables that can be used in checks and functions. Variables are resolved in order of declaration.
+        """Variables that can be used in checks. Variables are resolved in order of declaration.
 If variable `a` depends on variable `b`, then `b` must be defined before `a` in the list.
         """
         return self._checklist_variables
@@ -34686,19 +34765,17 @@ class scout_checks_api_UnresolvedNumRangesConditionV3(ConjureBeanType):
             'function_spec': ConjureFieldDefinition('functionSpec', object),
             'threshold': ConjureFieldDefinition('threshold', int),
             'operator': ConjureFieldDefinition('operator', scout_compute_api_ThresholdOperator),
-            'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_checks_api_UnresolvedVariableLocator]),
-            'function_variables': ConjureFieldDefinition('functionVariables', Dict[scout_compute_api_FunctionReference, scout_checks_api_UnresolvedVariables])
+            'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_checks_api_UnresolvedVariableLocator])
         }
 
-    __slots__: List[str] = ['_ranges', '_function_spec', '_threshold', '_operator', '_variables', '_function_variables']
+    __slots__: List[str] = ['_ranges', '_function_spec', '_threshold', '_operator', '_variables']
 
-    def __init__(self, function_spec: Any, function_variables: Dict[str, "scout_checks_api_UnresolvedVariables"], operator: "scout_compute_api_ThresholdOperator", ranges: "scout_compute_api_RangeSeries", threshold: int, variables: Dict[str, "scout_checks_api_UnresolvedVariableLocator"]) -> None:
+    def __init__(self, function_spec: Any, operator: "scout_compute_api_ThresholdOperator", ranges: "scout_compute_api_RangeSeries", threshold: int, variables: Dict[str, "scout_checks_api_UnresolvedVariableLocator"]) -> None:
         self._ranges = ranges
         self._function_spec = function_spec
         self._threshold = threshold
         self._operator = operator
         self._variables = variables
-        self._function_variables = function_variables
 
     @builtins.property
     def ranges(self) -> "scout_compute_api_RangeSeries":
@@ -34723,14 +34800,6 @@ at checklist execution time.
         """
         return self._variables
 
-    @builtins.property
-    def function_variables(self) -> Dict[str, "scout_checks_api_UnresolvedVariables"]:
-        """The variables to be passed into functions referenced by the check condition. The function reference key
-should match the FunctionReference in the function node definition. These variables can be overridden
-at checklist execution time.
-        """
-        return self._function_variables
-
 
 scout_checks_api_UnresolvedNumRangesConditionV3.__name__ = "UnresolvedNumRangesConditionV3"
 scout_checks_api_UnresolvedNumRangesConditionV3.__qualname__ = "UnresolvedNumRangesConditionV3"
@@ -34770,7 +34839,6 @@ scout_checks_api_UnresolvedParameterizedNumRangesConditionV1.__module__ = "nomin
 
 
 class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
-    _checklist_function: Optional[str] = None
     _checklist_variable: Optional[str] = None
     _compute_node: Optional["scout_checks_api_UnresolvedComputeNodeWithContext"] = None
     _series: Optional["scout_api_ChannelLocator"] = None
@@ -34779,7 +34847,6 @@ class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'checklist_function': ConjureFieldDefinition('checklistFunction', scout_compute_api_FunctionReference),
             'checklist_variable': ConjureFieldDefinition('checklistVariable', scout_compute_api_VariableName),
             'compute_node': ConjureFieldDefinition('computeNode', scout_checks_api_UnresolvedComputeNodeWithContext),
             'series': ConjureFieldDefinition('series', scout_api_ChannelLocator),
@@ -34788,7 +34855,6 @@ class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
 
     def __init__(
             self,
-            checklist_function: Optional[str] = None,
             checklist_variable: Optional[str] = None,
             compute_node: Optional["scout_checks_api_UnresolvedComputeNodeWithContext"] = None,
             series: Optional["scout_api_ChannelLocator"] = None,
@@ -34796,12 +34862,9 @@ class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (checklist_function is not None) + (checklist_variable is not None) + (compute_node is not None) + (series is not None) + (timestamp is not None) != 1:
+            if (checklist_variable is not None) + (compute_node is not None) + (series is not None) + (timestamp is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if checklist_function is not None:
-                self._checklist_function = checklist_function
-                self._type = 'checklistFunction'
             if checklist_variable is not None:
                 self._checklist_variable = checklist_variable
                 self._type = 'checklistVariable'
@@ -34815,11 +34878,6 @@ class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
                 self._timestamp = timestamp
                 self._type = 'timestamp'
 
-        elif type_of_union == 'checklistFunction':
-            if checklist_function is None:
-                raise ValueError('a union value must not be None')
-            self._checklist_function = checklist_function
-            self._type = 'checklistFunction'
         elif type_of_union == 'checklistVariable':
             if checklist_variable is None:
                 raise ValueError('a union value must not be None')
@@ -34841,10 +34899,6 @@ class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
             self._timestamp = timestamp
             self._type = 'timestamp'
 
-    @builtins.property
-    def checklist_function(self) -> Optional[str]:
-        return self._checklist_function
-
     @builtins.property
     def checklist_variable(self) -> Optional[str]:
         """A pointer to a variable in the checklist.
@@ -34866,8 +34920,6 @@ class scout_checks_api_UnresolvedVariableLocator(ConjureUnionType):
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_checks_api_UnresolvedVariableLocatorVisitor):
             raise ValueError('{} is not an instance of scout_checks_api_UnresolvedVariableLocatorVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'checklistFunction' and self.checklist_function is not None:
-            return visitor._checklist_function(self.checklist_function)
         if self._type == 'checklistVariable' and self.checklist_variable is not None:
             return visitor._checklist_variable(self.checklist_variable)
         if self._type == 'computeNode' and self.compute_node is not None:
@@ -34885,10 +34937,6 @@ scout_checks_api_UnresolvedVariableLocator.__module__ = "nominal_api.scout_check
 
 class scout_checks_api_UnresolvedVariableLocatorVisitor:
 
-    @abstractmethod
-    def _checklist_function(self, checklist_function: str) -> Any:
-        pass
-
     @abstractmethod
     def _checklist_variable(self, checklist_variable: str) -> Any:
         pass
@@ -34916,24 +34964,18 @@ class scout_checks_api_UnresolvedVariables(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_checks_api_UnresolvedVariableLocator]),
-            'sub_function_variables': ConjureFieldDefinition('subFunctionVariables', Dict[scout_compute_api_FunctionReference, scout_checks_api_UnresolvedVariables])
+            'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_checks_api_UnresolvedVariableLocator])
         }
 
-    __slots__: List[str] = ['_variables', '_sub_function_variables']
+    __slots__: List[str] = ['_variables']
 
-    def __init__(self, sub_function_variables: Dict[str, "scout_checks_api_UnresolvedVariables"], variables: Dict[str, "scout_checks_api_UnresolvedVariableLocator"]) -> None:
+    def __init__(self, variables: Dict[str, "scout_checks_api_UnresolvedVariableLocator"]) -> None:
         self._variables = variables
-        self._sub_function_variables = sub_function_variables
 
     @builtins.property
     def variables(self) -> Dict[str, "scout_checks_api_UnresolvedVariableLocator"]:
         return self._variables
 
-    @builtins.property
-    def sub_function_variables(self) -> Dict[str, "scout_checks_api_UnresolvedVariables"]:
-        return self._sub_function_variables
-
 
 scout_checks_api_UnresolvedVariables.__name__ = "UnresolvedVariables"
 scout_checks_api_UnresolvedVariables.__qualname__ = "UnresolvedVariables"
@@ -35070,87 +35112,9 @@ scout_checks_api_UpdateChecklistMetadataRequest.__qualname__ = "UpdateChecklistM
 scout_checks_api_UpdateChecklistMetadataRequest.__module__ = "nominal_api.scout_checks_api"
 
 
-class scout_checks_api_UpdateFunctionEntryRequest(ConjureUnionType):
-    _create_function: Optional["scout_checks_api_CreateFunctionRequest"] = None
-    _function: Optional[str] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'create_function': ConjureFieldDefinition('createFunction', scout_checks_api_CreateFunctionRequest),
-            'function': ConjureFieldDefinition('function', scout_rids_api_FunctionRid)
-        }
-
-    def __init__(
-            self,
-            create_function: Optional["scout_checks_api_CreateFunctionRequest"] = None,
-            function: Optional[str] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (create_function is not None) + (function is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if create_function is not None:
-                self._create_function = create_function
-                self._type = 'createFunction'
-            if function is not None:
-                self._function = function
-                self._type = 'function'
-
-        elif type_of_union == 'createFunction':
-            if create_function is None:
-                raise ValueError('a union value must not be None')
-            self._create_function = create_function
-            self._type = 'createFunction'
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
-
-    @builtins.property
-    def create_function(self) -> Optional["scout_checks_api_CreateFunctionRequest"]:
-        return self._create_function
-
-    @builtins.property
-    def function(self) -> Optional[str]:
-        return self._function
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_checks_api_UpdateFunctionEntryRequestVisitor):
-            raise ValueError('{} is not an instance of scout_checks_api_UpdateFunctionEntryRequestVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'createFunction' and self.create_function is not None:
-            return visitor._create_function(self.create_function)
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
-
-
-scout_checks_api_UpdateFunctionEntryRequest.__name__ = "UpdateFunctionEntryRequest"
-scout_checks_api_UpdateFunctionEntryRequest.__qualname__ = "UpdateFunctionEntryRequest"
-scout_checks_api_UpdateFunctionEntryRequest.__module__ = "nominal_api.scout_checks_api"
-
-
-class scout_checks_api_UpdateFunctionEntryRequestVisitor:
-
-    @abstractmethod
-    def _create_function(self, create_function: "scout_checks_api_CreateFunctionRequest") -> Any:
-        pass
-
-    @abstractmethod
-    def _function(self, function: str) -> Any:
-        pass
-
-
-scout_checks_api_UpdateFunctionEntryRequestVisitor.__name__ = "UpdateFunctionEntryRequestVisitor"
-scout_checks_api_UpdateFunctionEntryRequestVisitor.__qualname__ = "UpdateFunctionEntryRequestVisitor"
-scout_checks_api_UpdateFunctionEntryRequestVisitor.__module__ = "nominal_api.scout_checks_api"
-
-
 class scout_checks_api_VariableLocator(ConjureUnionType):
     _checklist_variable: Optional[str] = None
     _compute_node: Optional["scout_checks_api_ComputeNodeWithContext"] = None
-    _function_rid: Optional[str] = None
     _series: Optional["scout_api_ChannelLocator"] = None
     _timestamp: Optional["scout_checks_api_TimestampLocator"] = None
 
@@ -35159,7 +35123,6 @@ class scout_checks_api_VariableLocator(ConjureUnionType):
         return {
             'checklist_variable': ConjureFieldDefinition('checklistVariable', scout_compute_api_VariableName),
             'compute_node': ConjureFieldDefinition('computeNode', scout_checks_api_ComputeNodeWithContext),
-            'function_rid': ConjureFieldDefinition('functionRid', scout_rids_api_FunctionRid),
             'series': ConjureFieldDefinition('series', scout_api_ChannelLocator),
             'timestamp': ConjureFieldDefinition('timestamp', scout_checks_api_TimestampLocator)
         }
@@ -35168,13 +35131,12 @@ class scout_checks_api_VariableLocator(ConjureUnionType):
             self,
             checklist_variable: Optional[str] = None,
             compute_node: Optional["scout_checks_api_ComputeNodeWithContext"] = None,
-            function_rid: Optional[str] = None,
             series: Optional["scout_api_ChannelLocator"] = None,
             timestamp: Optional["scout_checks_api_TimestampLocator"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (checklist_variable is not None) + (compute_node is not None) + (function_rid is not None) + (series is not None) + (timestamp is not None) != 1:
+            if (checklist_variable is not None) + (compute_node is not None) + (series is not None) + (timestamp is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if checklist_variable is not None:
@@ -35183,9 +35145,6 @@ class scout_checks_api_VariableLocator(ConjureUnionType):
             if compute_node is not None:
                 self._compute_node = compute_node
                 self._type = 'computeNode'
-            if function_rid is not None:
-                self._function_rid = function_rid
-                self._type = 'functionRid'
             if series is not None:
                 self._series = series
                 self._type = 'series'
@@ -35203,11 +35162,6 @@ class scout_checks_api_VariableLocator(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._compute_node = compute_node
             self._type = 'computeNode'
-        elif type_of_union == 'functionRid':
-            if function_rid is None:
-                raise ValueError('a union value must not be None')
-            self._function_rid = function_rid
-            self._type = 'functionRid'
         elif type_of_union == 'series':
             if series is None:
                 raise ValueError('a union value must not be None')
@@ -35229,10 +35183,6 @@ class scout_checks_api_VariableLocator(ConjureUnionType):
     def compute_node(self) -> Optional["scout_checks_api_ComputeNodeWithContext"]:
         return self._compute_node
 
-    @builtins.property
-    def function_rid(self) -> Optional[str]:
-        return self._function_rid
-
     @builtins.property
     def series(self) -> Optional["scout_api_ChannelLocator"]:
         return self._series
@@ -35248,8 +35198,6 @@ class scout_checks_api_VariableLocator(ConjureUnionType):
             return visitor._checklist_variable(self.checklist_variable)
         if self._type == 'computeNode' and self.compute_node is not None:
             return visitor._compute_node(self.compute_node)
-        if self._type == 'functionRid' and self.function_rid is not None:
-            return visitor._function_rid(self.function_rid)
         if self._type == 'series' and self.series is not None:
             return visitor._series(self.series)
         if self._type == 'timestamp' and self.timestamp is not None:
@@ -35271,10 +35219,6 @@ class scout_checks_api_VariableLocatorVisitor:
     def _compute_node(self, compute_node: "scout_checks_api_ComputeNodeWithContext") -> Any:
         pass
 
-    @abstractmethod
-    def _function_rid(self, function_rid: str) -> Any:
-        pass
-
     @abstractmethod
     def _series(self, series: "scout_api_ChannelLocator") -> Any:
         pass
@@ -35297,14 +35241,14 @@ class scout_checks_api_VersionedChecklist(ConjureBeanType):
             'rid': ConjureFieldDefinition('rid', scout_rids_api_ChecklistRid),
             'metadata': ConjureFieldDefinition('metadata', scout_checks_api_ChecklistMetadata),
             'commit': ConjureFieldDefinition('commit', scout_versioning_api_Commit),
-            'functions': ConjureFieldDefinition('functions', List[scout_checks_api_Function]),
+            'functions': ConjureFieldDefinition('functions', OptionalTypeWrapper[List[scout_checks_api_Function]]),
             'checks': ConjureFieldDefinition('checks', List[scout_checks_api_ChecklistEntry]),
             'checklist_variables': ConjureFieldDefinition('checklistVariables', List[scout_checks_api_ChecklistVariable])
         }
 
     __slots__: List[str] = ['_rid', '_metadata', '_commit', '_functions', '_checks', '_checklist_variables']
 
-    def __init__(self, checklist_variables: List["scout_checks_api_ChecklistVariable"], checks: List["scout_checks_api_ChecklistEntry"], commit: "scout_versioning_api_Commit", functions: List["scout_checks_api_Function"], metadata: "scout_checks_api_ChecklistMetadata", rid: str) -> None:
+    def __init__(self, checklist_variables: List["scout_checks_api_ChecklistVariable"], checks: List["scout_checks_api_ChecklistEntry"], commit: "scout_versioning_api_Commit", metadata: "scout_checks_api_ChecklistMetadata", rid: str, functions: Optional[List["scout_checks_api_Function"]] = None) -> None:
         self._rid = rid
         self._metadata = metadata
         self._commit = commit
@@ -35325,9 +35269,7 @@ class scout_checks_api_VersionedChecklist(ConjureBeanType):
         return self._commit
 
     @builtins.property
-    def functions(self) -> List["scout_checks_api_Function"]:
-        """A list of functions that are available to be used by checks in this checklist.
-        """
+    def functions(self) -> Optional[List["scout_checks_api_Function"]]:
         return self._functions
 
     @builtins.property
@@ -35336,7 +35278,7 @@ class scout_checks_api_VersionedChecklist(ConjureBeanType):
 
     @builtins.property
     def checklist_variables(self) -> List["scout_checks_api_ChecklistVariable"]:
-        """Variables that can be used in checks and functions. Variables are resolved in order of declaration.
+        """Variables that can be used in checks. Variables are resolved in order of declaration.
 If variable `a` depends on variable `b`, then `b` must be defined before `a` in the list.
         """
         return self._checklist_variables
@@ -40505,12 +40447,12 @@ class scout_compute_api_Context(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_compute_api_VariableValue]),
-            'function_variables': ConjureFieldDefinition('functionVariables', Dict[scout_compute_api_FunctionReference, scout_compute_api_FunctionVariables])
+            'function_variables': ConjureFieldDefinition('functionVariables', OptionalTypeWrapper[Dict[scout_compute_api_FunctionReference, scout_compute_api_FunctionVariables]])
         }
 
     __slots__: List[str] = ['_variables', '_function_variables']
 
-    def __init__(self, function_variables: Dict[str, "scout_compute_api_FunctionVariables"], variables: Dict[str, "scout_compute_api_VariableValue"]) -> None:
+    def __init__(self, variables: Dict[str, "scout_compute_api_VariableValue"], function_variables: Optional[Dict[str, "scout_compute_api_FunctionVariables"]] = None) -> None:
         self._variables = variables
         self._function_variables = function_variables
 
@@ -40519,11 +40461,7 @@ class scout_compute_api_Context(ConjureBeanType):
         return self._variables
 
     @builtins.property
-    def function_variables(self) -> Dict[str, "scout_compute_api_FunctionVariables"]:
-        """Map of function references to their variables. The function reference is defined in the FunctionNode definition.
-If a function references another function, the variables for the referenced function should be in the
-subFunctionVariables field of the FunctionVariables.
-        """
+    def function_variables(self) -> Optional[Dict[str, "scout_compute_api_FunctionVariables"]]:
         return self._function_variables
 
 
@@ -41894,7 +41832,6 @@ scout_compute_api_EnumResampleSeries.__module__ = "nominal_api.scout_compute_api
 
 class scout_compute_api_EnumSeries(ConjureUnionType):
     _aggregate: Optional["scout_compute_api_AggregateEnumSeries"] = None
-    _function: Optional["scout_compute_api_EnumSeriesFunction"] = None
     _raw: Optional["scout_compute_api_Reference"] = None
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
     _resample: Optional["scout_compute_api_EnumResampleSeries"] = None
@@ -41909,7 +41846,6 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'aggregate': ConjureFieldDefinition('aggregate', scout_compute_api_AggregateEnumSeries),
-            'function': ConjureFieldDefinition('function', scout_compute_api_EnumSeriesFunction),
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
             'resample': ConjureFieldDefinition('resample', scout_compute_api_EnumResampleSeries),
@@ -41924,7 +41860,6 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     def __init__(
             self,
             aggregate: Optional["scout_compute_api_AggregateEnumSeries"] = None,
-            function: Optional["scout_compute_api_EnumSeriesFunction"] = None,
             raw: Optional["scout_compute_api_Reference"] = None,
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
             resample: Optional["scout_compute_api_EnumResampleSeries"] = None,
@@ -41937,15 +41872,12 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (function is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (filter_transformation is not None) + (value_map is not None) + (select1d_array_index is not None) != 1:
+            if (aggregate is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (filter_transformation is not None) + (value_map is not None) + (select1d_array_index is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
                 self._aggregate = aggregate
                 self._type = 'aggregate'
-            if function is not None:
-                self._function = function
-                self._type = 'function'
             if raw is not None:
                 self._raw = raw
                 self._type = 'raw'
@@ -41979,11 +41911,6 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._aggregate = aggregate
             self._type = 'aggregate'
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
         elif type_of_union == 'raw':
             if raw is None:
                 raise ValueError('a union value must not be None')
@@ -42034,10 +41961,6 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     def aggregate(self) -> Optional["scout_compute_api_AggregateEnumSeries"]:
         return self._aggregate
 
-    @builtins.property
-    def function(self) -> Optional["scout_compute_api_EnumSeriesFunction"]:
-        return self._function
-
     @builtins.property
     def raw(self) -> Optional["scout_compute_api_Reference"]:
         return self._raw
@@ -42079,8 +42002,6 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             raise ValueError('{} is not an instance of scout_compute_api_EnumSeriesVisitor'.format(visitor.__class__.__name__))
         if self._type == 'aggregate' and self.aggregate is not None:
             return visitor._aggregate(self.aggregate)
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
         if self._type == 'raw' and self.raw is not None:
             return visitor._raw(self.raw)
         if self._type == 'channel' and self.channel is not None:
@@ -42112,10 +42033,6 @@ class scout_compute_api_EnumSeriesVisitor:
     def _aggregate(self, aggregate: "scout_compute_api_AggregateEnumSeries") -> Any:
         pass
 
-    @abstractmethod
-    def _function(self, function: "scout_compute_api_EnumSeriesFunction") -> Any:
-        pass
-
     @abstractmethod
     def _raw(self, raw: "scout_compute_api_Reference") -> Any:
         pass
@@ -42203,41 +42120,6 @@ scout_compute_api_EnumSeriesEqualityRanges.__qualname__ = "EnumSeriesEqualityRan
 scout_compute_api_EnumSeriesEqualityRanges.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_EnumSeriesFunction(ConjureBeanType):
-    """A function reference that outputs an enum series.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'function_reference': ConjureFieldDefinition('functionReference', scout_compute_api_FunctionReference),
-            'function_identifier': ConjureFieldDefinition('functionIdentifier', scout_compute_api_FunctionVariable)
-        }
-
-    __slots__: List[str] = ['_function_reference', '_function_identifier']
-
-    def __init__(self, function_identifier: "scout_compute_api_FunctionVariable", function_reference: str) -> None:
-        self._function_reference = function_reference
-        self._function_identifier = function_identifier
-
-    @builtins.property
-    def function_reference(self) -> str:
-        """A reference to identify the function node for substituting variables used within the function.
-        """
-        return self._function_reference
-
-    @builtins.property
-    def function_identifier(self) -> "scout_compute_api_FunctionVariable":
-        """The variable that needs to be substituted with the function RID.
-        """
-        return self._function_identifier
-
-
-scout_compute_api_EnumSeriesFunction.__name__ = "EnumSeriesFunction"
-scout_compute_api_EnumSeriesFunction.__qualname__ = "EnumSeriesFunction"
-scout_compute_api_EnumSeriesFunction.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_EnumTimeRangeFilterSeries(ConjureBeanType):
     """Filters the series to points within the specified time range.
     """
@@ -42669,62 +42551,6 @@ scout_compute_api_FrequencyDomainPlot.__qualname__ = "FrequencyDomainPlot"
 scout_compute_api_FrequencyDomainPlot.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_FunctionVariable(ConjureUnionType):
-    _variable: Optional[str] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'variable': ConjureFieldDefinition('variable', scout_compute_api_VariableName)
-        }
-
-    def __init__(
-            self,
-            variable: Optional[str] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (variable is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if variable is not None:
-                self._variable = variable
-                self._type = 'variable'
-
-        elif type_of_union == 'variable':
-            if variable is None:
-                raise ValueError('a union value must not be None')
-            self._variable = variable
-            self._type = 'variable'
-
-    @builtins.property
-    def variable(self) -> Optional[str]:
-        return self._variable
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_FunctionVariableVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_FunctionVariableVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'variable' and self.variable is not None:
-            return visitor._variable(self.variable)
-
-
-scout_compute_api_FunctionVariable.__name__ = "FunctionVariable"
-scout_compute_api_FunctionVariable.__qualname__ = "FunctionVariable"
-scout_compute_api_FunctionVariable.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_FunctionVariableVisitor:
-
-    @abstractmethod
-    def _variable(self, variable: str) -> Any:
-        pass
-
-
-scout_compute_api_FunctionVariableVisitor.__name__ = "FunctionVariableVisitor"
-scout_compute_api_FunctionVariableVisitor.__qualname__ = "FunctionVariableVisitor"
-scout_compute_api_FunctionVariableVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_FunctionVariables(ConjureBeanType):
 
     @builtins.classmethod
@@ -45063,7 +44889,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     _count_duplicate: Optional["scout_compute_api_EnumCountDuplicateSeries"] = None
     _cumulative_sum: Optional["scout_compute_api_CumulativeSumSeries"] = None
     _derivative: Optional["scout_compute_api_DerivativeSeries"] = None
-    _function: Optional["scout_compute_api_NumericSeriesFunction"] = None
     _integral: Optional["scout_compute_api_IntegralSeries"] = None
     _max: Optional["scout_compute_api_MaxSeries"] = None
     _mean: Optional["scout_compute_api_MeanSeries"] = None
@@ -45100,7 +44925,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             'count_duplicate': ConjureFieldDefinition('countDuplicate', scout_compute_api_EnumCountDuplicateSeries),
             'cumulative_sum': ConjureFieldDefinition('cumulativeSum', scout_compute_api_CumulativeSumSeries),
             'derivative': ConjureFieldDefinition('derivative', scout_compute_api_DerivativeSeries),
-            'function': ConjureFieldDefinition('function', scout_compute_api_NumericSeriesFunction),
             'integral': ConjureFieldDefinition('integral', scout_compute_api_IntegralSeries),
             'max': ConjureFieldDefinition('max', scout_compute_api_MaxSeries),
             'mean': ConjureFieldDefinition('mean', scout_compute_api_MeanSeries),
@@ -45137,7 +44961,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             count_duplicate: Optional["scout_compute_api_EnumCountDuplicateSeries"] = None,
             cumulative_sum: Optional["scout_compute_api_CumulativeSumSeries"] = None,
             derivative: Optional["scout_compute_api_DerivativeSeries"] = None,
-            function: Optional["scout_compute_api_NumericSeriesFunction"] = None,
             integral: Optional["scout_compute_api_IntegralSeries"] = None,
             max: Optional["scout_compute_api_MaxSeries"] = None,
             mean: Optional["scout_compute_api_MeanSeries"] = None,
@@ -45167,7 +44990,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (count_duplicate is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (absolute_timestamp is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) + (approximate_filter is not None) + (select1d_array_index is not None) != 1:
+            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (count_duplicate is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (absolute_timestamp is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) + (approximate_filter is not None) + (select1d_array_index is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -45188,9 +45011,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             if derivative is not None:
                 self._derivative = derivative
                 self._type = 'derivative'
-            if function is not None:
-                self._function = function
-                self._type = 'function'
             if integral is not None:
                 self._integral = integral
                 self._type = 'integral'
@@ -45300,11 +45120,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._derivative = derivative
             self._type = 'derivative'
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
         elif type_of_union == 'integral':
             if integral is None:
                 raise ValueError('a union value must not be None')
@@ -45460,10 +45275,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     def derivative(self) -> Optional["scout_compute_api_DerivativeSeries"]:
         return self._derivative
 
-    @builtins.property
-    def function(self) -> Optional["scout_compute_api_NumericSeriesFunction"]:
-        return self._function
-
     @builtins.property
     def integral(self) -> Optional["scout_compute_api_IntegralSeries"]:
         return self._integral
@@ -45583,8 +45394,6 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             return visitor._cumulative_sum(self.cumulative_sum)
         if self._type == 'derivative' and self.derivative is not None:
             return visitor._derivative(self.derivative)
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
         if self._type == 'integral' and self.integral is not None:
             return visitor._integral(self.integral)
         if self._type == 'max' and self.max is not None:
@@ -45670,10 +45479,6 @@ class scout_compute_api_NumericSeriesVisitor:
     def _derivative(self, derivative: "scout_compute_api_DerivativeSeries") -> Any:
         pass
 
-    @abstractmethod
-    def _function(self, function: "scout_compute_api_NumericSeriesFunction") -> Any:
-        pass
-
     @abstractmethod
     def _integral(self, integral: "scout_compute_api_IntegralSeries") -> Any:
         pass
@@ -45784,41 +45589,6 @@ scout_compute_api_NumericSeriesVisitor.__qualname__ = "NumericSeriesVisitor"
 scout_compute_api_NumericSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_NumericSeriesFunction(ConjureBeanType):
-    """A function reference that outputs a numeric series.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'function_reference': ConjureFieldDefinition('functionReference', scout_compute_api_FunctionReference),
-            'function_identifier': ConjureFieldDefinition('functionIdentifier', scout_compute_api_FunctionVariable)
-        }
-
-    __slots__: List[str] = ['_function_reference', '_function_identifier']
-
-    def __init__(self, function_identifier: "scout_compute_api_FunctionVariable", function_reference: str) -> None:
-        self._function_reference = function_reference
-        self._function_identifier = function_identifier
-
-    @builtins.property
-    def function_reference(self) -> str:
-        """A reference to identify the function node for substituting variables used within the function.
-        """
-        return self._function_reference
-
-    @builtins.property
-    def function_identifier(self) -> "scout_compute_api_FunctionVariable":
-        """The variable that needs to be substituted with the function RID.
-        """
-        return self._function_identifier
-
-
-scout_compute_api_NumericSeriesFunction.__name__ = "NumericSeriesFunction"
-scout_compute_api_NumericSeriesFunction.__qualname__ = "NumericSeriesFunction"
-scout_compute_api_NumericSeriesFunction.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_NumericThresholdFilterSeries(ConjureBeanType):
     """Outputs only the values of the numeric plot value that satisfy the threshold condition.
     """
@@ -46335,29 +46105,19 @@ class scout_compute_api_ParameterInput(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'variables': ConjureFieldDefinition('variables', Dict[scout_compute_api_VariableName, scout_compute_api_VariableValue]),
-            'function_variables': ConjureFieldDefinition('functionVariables', Dict[scout_compute_api_FunctionReference, scout_compute_api_FunctionVariables]),
             'time_range': ConjureFieldDefinition('timeRange', OptionalTypeWrapper[scout_compute_api_Range])
         }
 
-    __slots__: List[str] = ['_variables', '_function_variables', '_time_range']
+    __slots__: List[str] = ['_variables', '_time_range']
 
-    def __init__(self, function_variables: Dict[str, "scout_compute_api_FunctionVariables"], variables: Dict[str, "scout_compute_api_VariableValue"], time_range: Optional["scout_compute_api_Range"] = None) -> None:
+    def __init__(self, variables: Dict[str, "scout_compute_api_VariableValue"], time_range: Optional["scout_compute_api_Range"] = None) -> None:
         self._variables = variables
-        self._function_variables = function_variables
         self._time_range = time_range
 
     @builtins.property
     def variables(self) -> Dict[str, "scout_compute_api_VariableValue"]:
         return self._variables
 
-    @builtins.property
-    def function_variables(self) -> Dict[str, "scout_compute_api_FunctionVariables"]:
-        """Map of function references to their variables. The function reference is defined in the FunctionNode definition.
-If a function references another function, the variables for the referenced function should be in the
-subFunctionVariables field of the FunctionVariables.
-        """
-        return self._function_variables
-
     @builtins.property
     def time_range(self) -> Optional["scout_compute_api_Range"]:
         """Overrides the start and end time of the compute request. If either the start or end are not present, we
@@ -47060,7 +46820,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     _enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None
     _enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None
     _events_search: Optional["scout_compute_api_EventsSearchRanges"] = None
-    _function: Optional["scout_compute_api_RangesFunction"] = None
     _intersect_range: Optional["scout_compute_api_IntersectRanges"] = None
     _literal_ranges: Optional["scout_compute_api_LiteralRanges"] = None
     _min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None
@@ -47084,7 +46843,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_api_EnumFilterRanges),
             'enum_series_equality_ranges_node': ConjureFieldDefinition('enumSeriesEqualityRangesNode', scout_compute_api_EnumSeriesEqualityRanges),
             'events_search': ConjureFieldDefinition('eventsSearch', scout_compute_api_EventsSearchRanges),
-            'function': ConjureFieldDefinition('function', scout_compute_api_RangesFunction),
             'intersect_range': ConjureFieldDefinition('intersectRange', scout_compute_api_IntersectRanges),
             'literal_ranges': ConjureFieldDefinition('literalRanges', scout_compute_api_LiteralRanges),
             'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_api_MinMaxThresholdRanges),
@@ -47108,7 +46866,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None,
             enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None,
             events_search: Optional["scout_compute_api_EventsSearchRanges"] = None,
-            function: Optional["scout_compute_api_RangesFunction"] = None,
             intersect_range: Optional["scout_compute_api_IntersectRanges"] = None,
             literal_ranges: Optional["scout_compute_api_LiteralRanges"] = None,
             min_max_threshold: Optional["scout_compute_api_MinMaxThresholdRanges"] = None,
@@ -47126,7 +46883,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (approximate_threshold is not None) + (duration_filter is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (events_search is not None) + (function is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (approximate_threshold is not None) + (duration_filter is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (events_search is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if approximate_threshold is not None:
@@ -47144,9 +46901,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             if events_search is not None:
                 self._events_search = events_search
                 self._type = 'eventsSearch'
-            if function is not None:
-                self._function = function
-                self._type = 'function'
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
@@ -47215,11 +46969,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._events_search = events_search
             self._type = 'eventsSearch'
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
         elif type_of_union == 'intersectRange':
             if intersect_range is None:
                 raise ValueError('a union value must not be None')
@@ -47311,10 +47060,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def events_search(self) -> Optional["scout_compute_api_EventsSearchRanges"]:
         return self._events_search
 
-    @builtins.property
-    def function(self) -> Optional["scout_compute_api_RangesFunction"]:
-        return self._function
-
     @builtins.property
     def intersect_range(self) -> Optional["scout_compute_api_IntersectRanges"]:
         return self._intersect_range
@@ -47388,8 +47133,6 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             return visitor._enum_series_equality_ranges_node(self.enum_series_equality_ranges_node)
         if self._type == 'eventsSearch' and self.events_search is not None:
             return visitor._events_search(self.events_search)
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
         if self._type == 'intersectRange' and self.intersect_range is not None:
             return visitor._intersect_range(self.intersect_range)
         if self._type == 'literalRanges' and self.literal_ranges is not None:
@@ -47447,10 +47190,6 @@ class scout_compute_api_RangeSeriesVisitor:
     def _events_search(self, events_search: "scout_compute_api_EventsSearchRanges") -> Any:
         pass
 
-    @abstractmethod
-    def _function(self, function: "scout_compute_api_RangesFunction") -> Any:
-        pass
-
     @abstractmethod
     def _intersect_range(self, intersect_range: "scout_compute_api_IntersectRanges") -> Any:
         pass
@@ -47646,41 +47385,6 @@ scout_compute_api_RangeValueVisitor.__qualname__ = "RangeValueVisitor"
 scout_compute_api_RangeValueVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_RangesFunction(ConjureBeanType):
-    """A function reference that outputs a ranges series.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'function_reference': ConjureFieldDefinition('functionReference', scout_compute_api_FunctionReference),
-            'function_identifier': ConjureFieldDefinition('functionIdentifier', scout_compute_api_FunctionVariable)
-        }
-
-    __slots__: List[str] = ['_function_reference', '_function_identifier']
-
-    def __init__(self, function_identifier: "scout_compute_api_FunctionVariable", function_reference: str) -> None:
-        self._function_reference = function_reference
-        self._function_identifier = function_identifier
-
-    @builtins.property
-    def function_reference(self) -> str:
-        """A reference to identify the function node for substituting variables used within the function.
-        """
-        return self._function_reference
-
-    @builtins.property
-    def function_identifier(self) -> "scout_compute_api_FunctionVariable":
-        """The variable that needs to be substituted with the function RID.
-        """
-        return self._function_identifier
-
-
-scout_compute_api_RangesFunction.__name__ = "RangesFunction"
-scout_compute_api_RangesFunction.__qualname__ = "RangesFunction"
-scout_compute_api_RangesFunction.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_RangesNumericAggregation(ConjureBeanType):
     """Aggregates the values of a numeric series at each range specified by the input ranges.
     """
@@ -50612,7 +50316,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
     _double: Optional[float] = None
     _compute_node: Optional["scout_compute_api_ComputeNodeWithContext"] = None
     _duration: Optional["scout_run_api_Duration"] = None
-    _function_rid: Optional[str] = None
     _integer: Optional[int] = None
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
     _series: Optional["scout_compute_api_SeriesSpec"] = None
@@ -50626,7 +50329,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             'double': ConjureFieldDefinition('double', float),
             'compute_node': ConjureFieldDefinition('computeNode', scout_compute_api_ComputeNodeWithContext),
             'duration': ConjureFieldDefinition('duration', scout_run_api_Duration),
-            'function_rid': ConjureFieldDefinition('functionRid', scout_rids_api_FunctionRid),
             'integer': ConjureFieldDefinition('integer', int),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
             'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec),
@@ -50640,7 +50342,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             double: Optional[float] = None,
             compute_node: Optional["scout_compute_api_ComputeNodeWithContext"] = None,
             duration: Optional["scout_run_api_Duration"] = None,
-            function_rid: Optional[str] = None,
             integer: Optional[int] = None,
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
             series: Optional["scout_compute_api_SeriesSpec"] = None,
@@ -50650,7 +50351,7 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (double is not None) + (compute_node is not None) + (duration is not None) + (function_rid is not None) + (integer is not None) + (channel is not None) + (series is not None) + (string is not None) + (string_set is not None) + (timestamp is not None) != 1:
+            if (double is not None) + (compute_node is not None) + (duration is not None) + (integer is not None) + (channel is not None) + (series is not None) + (string is not None) + (string_set is not None) + (timestamp is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if double is not None:
@@ -50662,9 +50363,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             if duration is not None:
                 self._duration = duration
                 self._type = 'duration'
-            if function_rid is not None:
-                self._function_rid = function_rid
-                self._type = 'functionRid'
             if integer is not None:
                 self._integer = integer
                 self._type = 'integer'
@@ -50699,11 +50397,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._duration = duration
             self._type = 'duration'
-        elif type_of_union == 'functionRid':
-            if function_rid is None:
-                raise ValueError('a union value must not be None')
-            self._function_rid = function_rid
-            self._type = 'functionRid'
         elif type_of_union == 'integer':
             if integer is None:
                 raise ValueError('a union value must not be None')
@@ -50747,10 +50440,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
     def duration(self) -> Optional["scout_run_api_Duration"]:
         return self._duration
 
-    @builtins.property
-    def function_rid(self) -> Optional[str]:
-        return self._function_rid
-
     @builtins.property
     def integer(self) -> Optional[int]:
         return self._integer
@@ -50784,8 +50473,6 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             return visitor._compute_node(self.compute_node)
         if self._type == 'duration' and self.duration is not None:
             return visitor._duration(self.duration)
-        if self._type == 'functionRid' and self.function_rid is not None:
-            return visitor._function_rid(self.function_rid)
         if self._type == 'integer' and self.integer is not None:
             return visitor._integer(self.integer)
         if self._type == 'channel' and self.channel is not None:
@@ -50819,10 +50506,6 @@ class scout_compute_api_VariableValueVisitor:
     def _duration(self, duration: "scout_run_api_Duration") -> Any:
         pass
 
-    @abstractmethod
-    def _function_rid(self, function_rid: str) -> Any:
-        pass
-
     @abstractmethod
     def _integer(self, integer: int) -> Any:
         pass
@@ -51399,7 +51082,6 @@ scout_compute_api_deprecated_EnumFilterRangesNode.__module__ = "nominal_api.scou
 
 class scout_compute_api_deprecated_EnumSeriesNode(ConjureUnionType):
     _raw: Optional["scout_compute_api_Reference"] = None
-    _function: Optional["scout_compute_api_EnumSeriesFunction"] = None
     _time_range_filter: Optional["scout_compute_api_deprecated_EnumTimeRangeFilterSeriesNode"] = None
     _time_shift: Optional["scout_compute_api_deprecated_EnumTimeShiftSeriesNode"] = None
     _union: Optional["scout_compute_api_deprecated_EnumUnionSeriesNode"] = None
@@ -51408,7 +51090,6 @@ class scout_compute_api_deprecated_EnumSeriesNode(ConjureUnionType):
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
-            'function': ConjureFieldDefinition('function', scout_compute_api_EnumSeriesFunction),
             'time_range_filter': ConjureFieldDefinition('timeRangeFilter', scout_compute_api_deprecated_EnumTimeRangeFilterSeriesNode),
             'time_shift': ConjureFieldDefinition('timeShift', scout_compute_api_deprecated_EnumTimeShiftSeriesNode),
             'union': ConjureFieldDefinition('union', scout_compute_api_deprecated_EnumUnionSeriesNode)
@@ -51417,22 +51098,18 @@ class scout_compute_api_deprecated_EnumSeriesNode(ConjureUnionType):
     def __init__(
             self,
             raw: Optional["scout_compute_api_Reference"] = None,
-            function: Optional["scout_compute_api_EnumSeriesFunction"] = None,
             time_range_filter: Optional["scout_compute_api_deprecated_EnumTimeRangeFilterSeriesNode"] = None,
             time_shift: Optional["scout_compute_api_deprecated_EnumTimeShiftSeriesNode"] = None,
             union: Optional["scout_compute_api_deprecated_EnumUnionSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (function is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) != 1:
+            if (raw is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
                 self._raw = raw
                 self._type = 'raw'
-            if function is not None:
-                self._function = function
-                self._type = 'function'
             if time_range_filter is not None:
                 self._time_range_filter = time_range_filter
                 self._type = 'timeRangeFilter'
@@ -51448,11 +51125,6 @@ class scout_compute_api_deprecated_EnumSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._raw = raw
             self._type = 'raw'
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
         elif type_of_union == 'timeRangeFilter':
             if time_range_filter is None:
                 raise ValueError('a union value must not be None')
@@ -51473,10 +51145,6 @@ class scout_compute_api_deprecated_EnumSeriesNode(ConjureUnionType):
     def raw(self) -> Optional["scout_compute_api_Reference"]:
         return self._raw
 
-    @builtins.property
-    def function(self) -> Optional["scout_compute_api_EnumSeriesFunction"]:
-        return self._function
-
     @builtins.property
     def time_range_filter(self) -> Optional["scout_compute_api_deprecated_EnumTimeRangeFilterSeriesNode"]:
         return self._time_range_filter
@@ -51494,8 +51162,6 @@ class scout_compute_api_deprecated_EnumSeriesNode(ConjureUnionType):
             raise ValueError('{} is not an instance of scout_compute_api_deprecated_EnumSeriesNodeVisitor'.format(visitor.__class__.__name__))
         if self._type == 'raw' and self.raw is not None:
             return visitor._raw(self.raw)
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
         if self._type == 'timeRangeFilter' and self.time_range_filter is not None:
             return visitor._time_range_filter(self.time_range_filter)
         if self._type == 'timeShift' and self.time_shift is not None:
@@ -51515,10 +51181,6 @@ class scout_compute_api_deprecated_EnumSeriesNodeVisitor:
     def _raw(self, raw: "scout_compute_api_Reference") -> Any:
         pass
 
-    @abstractmethod
-    def _function(self, function: "scout_compute_api_EnumSeriesFunction") -> Any:
-        pass
-
     @abstractmethod
     def _time_range_filter(self, time_range_filter: "scout_compute_api_deprecated_EnumTimeRangeFilterSeriesNode") -> Any:
         pass
@@ -51737,7 +51399,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
     _arithmetic: Optional["scout_compute_api_deprecated_ArithmeticSeriesNode"] = None
     _bit_operation: Optional["scout_compute_api_deprecated_BitOperationSeriesNode"] = None
     _cumulative_sum: Optional["scout_compute_api_deprecated_CumulativeSumSeriesNode"] = None
-    _function: Optional["scout_compute_api_NumericSeriesFunction"] = None
     _derivative: Optional["scout_compute_api_deprecated_DerivativeSeriesNode"] = None
     _rolling_operation: Optional["scout_compute_api_deprecated_RollingOperationSeriesNode"] = None
     _unary_arithmetic: Optional["scout_compute_api_deprecated_UnaryArithmeticSeriesNode"] = None
@@ -51754,7 +51415,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
             'arithmetic': ConjureFieldDefinition('arithmetic', scout_compute_api_deprecated_ArithmeticSeriesNode),
             'bit_operation': ConjureFieldDefinition('bitOperation', scout_compute_api_deprecated_BitOperationSeriesNode),
             'cumulative_sum': ConjureFieldDefinition('cumulativeSum', scout_compute_api_deprecated_CumulativeSumSeriesNode),
-            'function': ConjureFieldDefinition('function', scout_compute_api_NumericSeriesFunction),
             'derivative': ConjureFieldDefinition('derivative', scout_compute_api_deprecated_DerivativeSeriesNode),
             'rolling_operation': ConjureFieldDefinition('rollingOperation', scout_compute_api_deprecated_RollingOperationSeriesNode),
             'unary_arithmetic': ConjureFieldDefinition('unaryArithmetic', scout_compute_api_deprecated_UnaryArithmeticSeriesNode),
@@ -51771,7 +51431,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
             arithmetic: Optional["scout_compute_api_deprecated_ArithmeticSeriesNode"] = None,
             bit_operation: Optional["scout_compute_api_deprecated_BitOperationSeriesNode"] = None,
             cumulative_sum: Optional["scout_compute_api_deprecated_CumulativeSumSeriesNode"] = None,
-            function: Optional["scout_compute_api_NumericSeriesFunction"] = None,
             derivative: Optional["scout_compute_api_deprecated_DerivativeSeriesNode"] = None,
             rolling_operation: Optional["scout_compute_api_deprecated_RollingOperationSeriesNode"] = None,
             unary_arithmetic: Optional["scout_compute_api_deprecated_UnaryArithmeticSeriesNode"] = None,
@@ -51783,7 +51442,7 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (function is not None) + (derivative is not None) + (rolling_operation is not None) + (unary_arithmetic is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (value_difference is not None) != 1:
+            if (raw is not None) + (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (rolling_operation is not None) + (unary_arithmetic is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (value_difference is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -51798,9 +51457,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
             if cumulative_sum is not None:
                 self._cumulative_sum = cumulative_sum
                 self._type = 'cumulativeSum'
-            if function is not None:
-                self._function = function
-                self._type = 'function'
             if derivative is not None:
                 self._derivative = derivative
                 self._type = 'derivative'
@@ -51846,11 +51502,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._cumulative_sum = cumulative_sum
             self._type = 'cumulativeSum'
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
         elif type_of_union == 'derivative':
             if derivative is None:
                 raise ValueError('a union value must not be None')
@@ -51908,10 +51559,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
     def cumulative_sum(self) -> Optional["scout_compute_api_deprecated_CumulativeSumSeriesNode"]:
         return self._cumulative_sum
 
-    @builtins.property
-    def function(self) -> Optional["scout_compute_api_NumericSeriesFunction"]:
-        return self._function
-
     @builtins.property
     def derivative(self) -> Optional["scout_compute_api_deprecated_DerivativeSeriesNode"]:
         return self._derivative
@@ -51955,8 +51602,6 @@ class scout_compute_api_deprecated_NumericSeriesNode(ConjureUnionType):
             return visitor._bit_operation(self.bit_operation)
         if self._type == 'cumulativeSum' and self.cumulative_sum is not None:
             return visitor._cumulative_sum(self.cumulative_sum)
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
         if self._type == 'derivative' and self.derivative is not None:
             return visitor._derivative(self.derivative)
         if self._type == 'rollingOperation' and self.rolling_operation is not None:
@@ -51998,10 +51643,6 @@ class scout_compute_api_deprecated_NumericSeriesNodeVisitor:
     def _cumulative_sum(self, cumulative_sum: "scout_compute_api_deprecated_CumulativeSumSeriesNode") -> Any:
         pass
 
-    @abstractmethod
-    def _function(self, function: "scout_compute_api_NumericSeriesFunction") -> Any:
-        pass
-
     @abstractmethod
     def _derivative(self, derivative: "scout_compute_api_deprecated_DerivativeSeriesNode") -> Any:
         pass
@@ -52192,7 +51833,6 @@ scout_compute_api_deprecated_PersistenceWindowConfiguration.__module__ = "nomina
 
 
 class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
-    _function: Optional["scout_compute_api_RangesFunction"] = None
     _on_change: Optional["scout_compute_api_deprecated_OnChangeRangesNode"] = None
     _enum_filter: Optional["scout_compute_api_deprecated_EnumFilterRangesNode"] = None
     _threshold: Optional["scout_compute_api_deprecated_ThresholdingRangesNode"] = None
@@ -52202,7 +51842,6 @@ class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'function': ConjureFieldDefinition('function', scout_compute_api_RangesFunction),
             'on_change': ConjureFieldDefinition('onChange', scout_compute_api_deprecated_OnChangeRangesNode),
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_api_deprecated_EnumFilterRangesNode),
             'threshold': ConjureFieldDefinition('threshold', scout_compute_api_deprecated_ThresholdingRangesNode),
@@ -52212,7 +51851,6 @@ class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
 
     def __init__(
             self,
-            function: Optional["scout_compute_api_RangesFunction"] = None,
             on_change: Optional["scout_compute_api_deprecated_OnChangeRangesNode"] = None,
             enum_filter: Optional["scout_compute_api_deprecated_EnumFilterRangesNode"] = None,
             threshold: Optional["scout_compute_api_deprecated_ThresholdingRangesNode"] = None,
@@ -52221,12 +51859,9 @@ class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (function is not None) + (on_change is not None) + (enum_filter is not None) + (threshold is not None) + (union_range is not None) + (intersect_range is not None) != 1:
+            if (on_change is not None) + (enum_filter is not None) + (threshold is not None) + (union_range is not None) + (intersect_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if function is not None:
-                self._function = function
-                self._type = 'function'
             if on_change is not None:
                 self._on_change = on_change
                 self._type = 'onChange'
@@ -52243,11 +51878,6 @@ class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
 
-        elif type_of_union == 'function':
-            if function is None:
-                raise ValueError('a union value must not be None')
-            self._function = function
-            self._type = 'function'
         elif type_of_union == 'onChange':
             if on_change is None:
                 raise ValueError('a union value must not be None')
@@ -52274,10 +51904,6 @@ class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
             self._intersect_range = intersect_range
             self._type = 'intersectRange'
 
-    @builtins.property
-    def function(self) -> Optional["scout_compute_api_RangesFunction"]:
-        return self._function
-
     @builtins.property
     def on_change(self) -> Optional["scout_compute_api_deprecated_OnChangeRangesNode"]:
         return self._on_change
@@ -52301,8 +51927,6 @@ class scout_compute_api_deprecated_RangesNode(ConjureUnionType):
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_deprecated_RangesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_deprecated_RangesNodeVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'function' and self.function is not None:
-            return visitor._function(self.function)
         if self._type == 'onChange' and self.on_change is not None:
             return visitor._on_change(self.on_change)
         if self._type == 'enumFilter' and self.enum_filter is not None:
@@ -52322,10 +51946,6 @@ scout_compute_api_deprecated_RangesNode.__module__ = "nominal_api.scout_compute_
 
 class scout_compute_api_deprecated_RangesNodeVisitor:
 
-    @abstractmethod
-    def _function(self, function: "scout_compute_api_RangesFunction") -> Any:
-        pass
-
     @abstractmethod
     def _on_change(self, on_change: "scout_compute_api_deprecated_OnChangeRangesNode") -> Any:
         pass
@@ -86581,6 +86201,8 @@ scout_channelvariables_api_WorkbookChannelVariableMap = Dict[scout_channelvariab
 
 scout_rids_api_TypeRid = str
 
+scout_compute_api_FunctionReference = str
+
 api_rids_AutomaticCheckEvaluationRid = str
 
 scout_rids_api_TemplateRid = str
@@ -86595,8 +86217,6 @@ api_ErrorType = str
 
 scout_compute_api_ComputeWithUnitsRequest = scout_compute_api_ComputeNodeRequest
 
-scout_compute_api_FunctionReference = str
-
 scout_rids_api_Version = int
 
 scout_versioning_api_BranchName = str