nominal-api 0.941.0__py3-none-any.whl → 0.943.0__py3-none-any.whl

nominal_api/_impl.py

@@ -3897,12 +3897,12 @@ class datasource_api_ChannelMetadata(ConjureBeanType):
             'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[scout_run_api_Unit]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'data_type': ConjureFieldDefinition('dataType', OptionalTypeWrapper[api_SeriesDataType]),
-            'series_rid': ConjureFieldDefinition('seriesRid', datasource_api_SeriesArchetypeRidOrLogicalSeriesRid)
+            'series_rid': ConjureFieldDefinition('seriesRid', datasource_api_SeriesMetadataRidOrLogicalSeriesRid)
         }
 
     __slots__: List[str] = ['_name', '_data_source', '_unit', '_description', '_data_type', '_series_rid']
 
-    def __init__(self, data_source: str, name: str, series_rid: "datasource_api_SeriesArchetypeRidOrLogicalSeriesRid", data_type: Optional["api_SeriesDataType"] = None, description: Optional[str] = None, unit: Optional["scout_run_api_Unit"] = None) -> None:
+    def __init__(self, data_source: str, name: str, series_rid: "datasource_api_SeriesMetadataRidOrLogicalSeriesRid", data_type: Optional["api_SeriesDataType"] = None, description: Optional[str] = None, unit: Optional["scout_run_api_Unit"] = None) -> None:
         self._name = name
         self._data_source = data_source
         self._unit = unit
@@ -3931,7 +3931,7 @@ class datasource_api_ChannelMetadata(ConjureBeanType):
         return self._data_type
 
     @builtins.property
-    def series_rid(self) -> "datasource_api_SeriesArchetypeRidOrLogicalSeriesRid":
+    def series_rid(self) -> "datasource_api_SeriesMetadataRidOrLogicalSeriesRid":
         return self._series_rid
 
 
@@ -4672,14 +4672,14 @@ datasource_api_SearchHierarchicalChannelsResponse.__qualname__ = "SearchHierarch
 datasource_api_SearchHierarchicalChannelsResponse.__module__ = "nominal_api.datasource_api"
 
 
-class datasource_api_SeriesArchetypeRidOrLogicalSeriesRid(ConjureUnionType):
+class datasource_api_SeriesMetadataRidOrLogicalSeriesRid(ConjureUnionType):
     _series_archetype: Optional[str] = None
     _logical_series: Optional[str] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'series_archetype': ConjureFieldDefinition('seriesArchetype', api_SeriesArchetypeRid),
+            'series_archetype': ConjureFieldDefinition('seriesArchetype', api_SeriesMetadataRid),
             'logical_series': ConjureFieldDefinition('logicalSeries', api_LogicalSeriesRid)
         }
 
@@ -4720,20 +4720,20 @@ class datasource_api_SeriesArchetypeRidOrLogicalSeriesRid(ConjureUnionType):
         return self._logical_series
 
     def accept(self, visitor) -> Any:
-        if not isinstance(visitor, datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor):
-            raise ValueError('{} is not an instance of datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor'.format(visitor.__class__.__name__))
+        if not isinstance(visitor, datasource_api_SeriesMetadataRidOrLogicalSeriesRidVisitor):
+            raise ValueError('{} is not an instance of datasource_api_SeriesMetadataRidOrLogicalSeriesRidVisitor'.format(visitor.__class__.__name__))
         if self._type == 'seriesArchetype' and self.series_archetype is not None:
             return visitor._series_archetype(self.series_archetype)
         if self._type == 'logicalSeries' and self.logical_series is not None:
             return visitor._logical_series(self.logical_series)
 
 
-datasource_api_SeriesArchetypeRidOrLogicalSeriesRid.__name__ = "SeriesArchetypeRidOrLogicalSeriesRid"
-datasource_api_SeriesArchetypeRidOrLogicalSeriesRid.__qualname__ = "SeriesArchetypeRidOrLogicalSeriesRid"
-datasource_api_SeriesArchetypeRidOrLogicalSeriesRid.__module__ = "nominal_api.datasource_api"
+datasource_api_SeriesMetadataRidOrLogicalSeriesRid.__name__ = "SeriesMetadataRidOrLogicalSeriesRid"
+datasource_api_SeriesMetadataRidOrLogicalSeriesRid.__qualname__ = "SeriesMetadataRidOrLogicalSeriesRid"
+datasource_api_SeriesMetadataRidOrLogicalSeriesRid.__module__ = "nominal_api.datasource_api"
 
 
-class datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor:
+class datasource_api_SeriesMetadataRidOrLogicalSeriesRidVisitor:
 
     @abstractmethod
     def _series_archetype(self, series_archetype: str) -> Any:
@@ -4744,9 +4744,9 @@ class datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor:
         pass
 
 
-datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor.__name__ = "SeriesArchetypeRidOrLogicalSeriesRidVisitor"
-datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor.__qualname__ = "SeriesArchetypeRidOrLogicalSeriesRidVisitor"
-datasource_api_SeriesArchetypeRidOrLogicalSeriesRidVisitor.__module__ = "nominal_api.datasource_api"
+datasource_api_SeriesMetadataRidOrLogicalSeriesRidVisitor.__name__ = "SeriesMetadataRidOrLogicalSeriesRidVisitor"
+datasource_api_SeriesMetadataRidOrLogicalSeriesRidVisitor.__qualname__ = "SeriesMetadataRidOrLogicalSeriesRidVisitor"
+datasource_api_SeriesMetadataRidOrLogicalSeriesRidVisitor.__module__ = "nominal_api.datasource_api"
 
 
 class datasource_logset_LogSetService(Service):
@@ -13517,6 +13517,35 @@ ingest_api_VideoTimestampManifestVisitor.__qualname__ = "VideoTimestampManifestV
 ingest_api_VideoTimestampManifestVisitor.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_workflow_api_CreateIngestJobRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'ingest_job_request': ConjureFieldDefinition('ingestJobRequest', ingest_api_IngestJobRequest)
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_ingest_job_request']
+
+    def __init__(self, ingest_job_request: "ingest_api_IngestJobRequest", workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._ingest_job_request = ingest_job_request
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def ingest_job_request(self) -> "ingest_api_IngestJobRequest":
+        return self._ingest_job_request
+
+
+ingest_workflow_api_CreateIngestJobRequest.__name__ = "CreateIngestJobRequest"
+ingest_workflow_api_CreateIngestJobRequest.__qualname__ = "CreateIngestJobRequest"
+ingest_workflow_api_CreateIngestJobRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
 class ingest_workflow_api_Empty(ConjureBeanType):
 
     @builtins.classmethod
@@ -14001,6 +14030,38 @@ ingest_workflow_api_IngestDataflashResponse.__module__ = "nominal_api.ingest_wor
 
 class ingest_workflow_api_IngestInternalService(Service):
 
+    def create_ingest_job(self, auth_header: str, create_ingest_job_request: "ingest_workflow_api_CreateIngestJobRequest") -> str:
+        """Creates an ingest job, returning a RID for the job.
+        """
+        _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(create_ingest_job_request)
+
+        _path = '/internal/ingest/v1/ingest-job'
+        _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(), ingest_api_IngestJobRid, self._return_none_for_unknown_union_types)
+
     def get_ingest_job(self, auth_header: str, ingest_job_rid: str) -> "ingest_api_IngestJob":
         """Returns a single ingest job by RID.
         """
@@ -17030,6 +17091,32 @@ persistent_compute_api_ClientMessageVisitor.__qualname__ = "ClientMessageVisitor
 persistent_compute_api_ClientMessageVisitor.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_ClientMessageError(ConjureBeanType):
+    """This will be sent if there is an error processing a `ClientMessage`. Note: This won't automatically close 
+the connection. The client can continue sending `ClientMessage`s after receiving this error.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'error': ConjureFieldDefinition('error', api_SerializableError)
+        }
+
+    __slots__: List[str] = ['_error']
+
+    def __init__(self, error: "api_SerializableError") -> None:
+        self._error = error
+
+    @builtins.property
+    def error(self) -> "api_SerializableError":
+        return self._error
+
+
+persistent_compute_api_ClientMessageError.__name__ = "ClientMessageError"
+persistent_compute_api_ClientMessageError.__qualname__ = "ClientMessageError"
+persistent_compute_api_ClientMessageError.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_ComputeNodeAppendResponse(ConjureUnionType):
     """These cover the subset of the union type in `ComputeNodeResponse` for which we support append results.
 Append results will have the same subtype as the previous full result for the same `SubscriptionId`. 
@@ -17509,13 +17596,15 @@ class persistent_compute_api_HealthMessage(ConjureUnionType):
     _ping: Optional["persistent_compute_api_Ping"] = None
     _pong: Optional["persistent_compute_api_Pong"] = None
     _shutdown_notice: Optional["persistent_compute_api_ShutdownNotice"] = None
+    _client_message_error: Optional["persistent_compute_api_ClientMessageError"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'ping': ConjureFieldDefinition('ping', persistent_compute_api_Ping),
             'pong': ConjureFieldDefinition('pong', persistent_compute_api_Pong),
-            'shutdown_notice': ConjureFieldDefinition('shutdownNotice', persistent_compute_api_ShutdownNotice)
+            'shutdown_notice': ConjureFieldDefinition('shutdownNotice', persistent_compute_api_ShutdownNotice),
+            'client_message_error': ConjureFieldDefinition('clientMessageError', persistent_compute_api_ClientMessageError)
         }
 
     def __init__(
@@ -17523,10 +17612,11 @@ class persistent_compute_api_HealthMessage(ConjureUnionType):
             ping: Optional["persistent_compute_api_Ping"] = None,
             pong: Optional["persistent_compute_api_Pong"] = None,
             shutdown_notice: Optional["persistent_compute_api_ShutdownNotice"] = None,
+            client_message_error: Optional["persistent_compute_api_ClientMessageError"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (ping is not None) + (pong is not None) + (shutdown_notice is not None) != 1:
+            if (ping is not None) + (pong is not None) + (shutdown_notice is not None) + (client_message_error is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if ping is not None:
@@ -17538,6 +17628,9 @@ class persistent_compute_api_HealthMessage(ConjureUnionType):
             if shutdown_notice is not None:
                 self._shutdown_notice = shutdown_notice
                 self._type = 'shutdownNotice'
+            if client_message_error is not None:
+                self._client_message_error = client_message_error
+                self._type = 'clientMessageError'
 
         elif type_of_union == 'ping':
             if ping is None:
@@ -17554,6 +17647,11 @@ class persistent_compute_api_HealthMessage(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._shutdown_notice = shutdown_notice
             self._type = 'shutdownNotice'
+        elif type_of_union == 'clientMessageError':
+            if client_message_error is None:
+                raise ValueError('a union value must not be None')
+            self._client_message_error = client_message_error
+            self._type = 'clientMessageError'
 
     @builtins.property
     def ping(self) -> Optional["persistent_compute_api_Ping"]:
@@ -17567,6 +17665,10 @@ class persistent_compute_api_HealthMessage(ConjureUnionType):
     def shutdown_notice(self) -> Optional["persistent_compute_api_ShutdownNotice"]:
         return self._shutdown_notice
 
+    @builtins.property
+    def client_message_error(self) -> Optional["persistent_compute_api_ClientMessageError"]:
+        return self._client_message_error
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_HealthMessageVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_HealthMessageVisitor'.format(visitor.__class__.__name__))
@@ -17576,6 +17678,8 @@ class persistent_compute_api_HealthMessage(ConjureUnionType):
             return visitor._pong(self.pong)
         if self._type == 'shutdownNotice' and self.shutdown_notice is not None:
             return visitor._shutdown_notice(self.shutdown_notice)
+        if self._type == 'clientMessageError' and self.client_message_error is not None:
+            return visitor._client_message_error(self.client_message_error)
 
 
 persistent_compute_api_HealthMessage.__name__ = "HealthMessage"
@@ -17597,6 +17701,10 @@ class persistent_compute_api_HealthMessageVisitor:
     def _shutdown_notice(self, shutdown_notice: "persistent_compute_api_ShutdownNotice") -> Any:
         pass
 
+    @abstractmethod
+    def _client_message_error(self, client_message_error: "persistent_compute_api_ClientMessageError") -> Any:
+        pass
+
 
 persistent_compute_api_HealthMessageVisitor.__name__ = "HealthMessageVisitor"
 persistent_compute_api_HealthMessageVisitor.__qualname__ = "HealthMessageVisitor"
@@ -50951,8 +51059,6 @@ scout_compute_api_OnChangeRanges.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_OutputFormat(ConjureEnumType):
 
-    ARROW_V2 = 'ARROW_V2'
-    '''ARROW_V2'''
     ARROW_V3 = 'ARROW_V3'
     '''ARROW_V3'''
     LEGACY = 'LEGACY'
@@ -92415,15 +92521,12 @@ themes_api_UpdateChartThemeRequest.__qualname__ = "UpdateChartThemeRequest"
 themes_api_UpdateChartThemeRequest.__module__ = "nominal_api.themes_api"
 
 
-class timeseries_archetype_SeriesArchetypeService(Service):
-    """[INTERNAL]
-A series archetype represents the constant information about data in a series - specifically, the name, units, a
-description, and the tags. Series archetypes can be used to query points from specific series depending on the tag
-value selections.
+class timeseries_channelmetadata_ChannelMetadataService(Service):
+    """Endpoints for retrieving and updating channel metadata.
     """
 
-    def batch_get(self, auth_header: str, request: "timeseries_archetype_api_BatchGetSeriesArchetypeRequest") -> "timeseries_archetype_api_BatchGetSeriesArchetypeResponse":
-        """Batch get series archetypes by DataSourceRid.
+    def get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_GetChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
+        """Get the metadata for a channel.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -92441,7 +92544,7 @@ value selections.
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/archetype/v1/series-archetype/batch-get'
+        _path = '/timeseries/channel-metadata/v1/channel-metadata/get'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -92452,10 +92555,11 @@ value selections.
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_archetype_api_BatchGetSeriesArchetypeResponse, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
 
-    def create(self, auth_header: str, request: "timeseries_archetype_api_CreateSeriesArchetypeRequest") -> None:
-        """Create a new series archetype.
+    def batch_get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchGetChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchGetChannelMetadataResponse":
+        """Batch get the metadata for multiple channels. If some channels cannot be found or authorized, 
+they will be omitted from the response.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -92473,7 +92577,7 @@ value selections.
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/archetype/v1/series-archetype'
+        _path = '/timeseries/channel-metadata/v1/channel-metadata/batch-get'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -92483,10 +92587,11 @@ value selections.
             headers=_headers,
             json=_json)
 
-        return
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_BatchGetChannelMetadataResponse, self._return_none_for_unknown_union_types)
 
-    def batch_create(self, auth_header: str, request: "timeseries_archetype_api_BatchCreateSeriesArchetypeRequest") -> None:
-        """Idempotently creates series archetypes.
+    def update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_UpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
+        """Update the metadata for a channel.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -92504,7 +92609,7 @@ value selections.
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/archetype/v1/series-archetype/batch-create'
+        _path = '/timeseries/channel-metadata/v1/channel-metadata/update'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -92514,43 +92619,12 @@ value selections.
             headers=_headers,
             json=_json)
 
-        return
-
-    def get(self, auth_header: str, rid: str) -> "timeseries_archetype_api_SeriesArchetype":
-        """Get a series archetype from its series archetype rid.
-        """
-        _conjure_encoder = ConjureEncoder()
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, str] = {
-            'rid': quote(str(_conjure_encoder.default(rid)), safe=''),
-        }
-
-        _json: Any = None
-
-        _path = '/timeseries/archetype/v1/series-archetype/{rid}'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_archetype_api_SeriesArchetype, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
 
-    def update_metadata(self, auth_header: str, request: "timeseries_archetype_api_UpdateSeriesArchetypeMetadataRequest", rid: str) -> "timeseries_archetype_api_SeriesArchetype":
-        """Update the metadata on an existing series archetype. 
-Throws SeriesArchetypeNotFound if the series archetype does not exist.
+    def batch_update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse":
+        """Batch update the metadata for multiple channels. If some channels cannot be found or authorized,
+no metadata will be updated for any of the channels in the request.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -92564,12 +92638,11 @@ Throws SeriesArchetypeNotFound if the series archetype does not exist.
         }
 
         _path_params: Dict[str, str] = {
-            'rid': quote(str(_conjure_encoder.default(rid)), safe=''),
         }
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/archetype/v1/series-archetype/{rid}/metadata'
+        _path = '/timeseries/channel-metadata/v1/channel-metadata/batch-update'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -92580,1039 +92653,1635 @@ Throws SeriesArchetypeNotFound if the series archetype does not exist.
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_archetype_api_SeriesArchetype, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse, self._return_none_for_unknown_union_types)
 
 
-timeseries_archetype_SeriesArchetypeService.__name__ = "SeriesArchetypeService"
-timeseries_archetype_SeriesArchetypeService.__qualname__ = "SeriesArchetypeService"
-timeseries_archetype_SeriesArchetypeService.__module__ = "nominal_api.timeseries_archetype"
+timeseries_channelmetadata_ChannelMetadataService.__name__ = "ChannelMetadataService"
+timeseries_channelmetadata_ChannelMetadataService.__qualname__ = "ChannelMetadataService"
+timeseries_channelmetadata_ChannelMetadataService.__module__ = "nominal_api.timeseries_channelmetadata"
 
 
-class timeseries_archetype_api_ApiLocatorTemplate(ConjureBeanType):
+class timeseries_channelmetadata_api_BatchGetChannelMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_ApiType)
+            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_GetChannelMetadataRequest])
         }
 
-    __slots__: List[str] = ['_channel', '_type']
-
-    def __init__(self, channel: str, type: "timeseries_logicalseries_api_ApiType") -> None:
-        self._channel = channel
-        self._type = type
+    __slots__: List[str] = ['_requests']
 
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
+    def __init__(self, requests: List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]) -> None:
+        self._requests = requests
 
     @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_ApiType":
-        return self._type
+    def requests(self) -> List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]:
+        return self._requests
 
 
-timeseries_archetype_api_ApiLocatorTemplate.__name__ = "ApiLocatorTemplate"
-timeseries_archetype_api_ApiLocatorTemplate.__qualname__ = "ApiLocatorTemplate"
-timeseries_archetype_api_ApiLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__name__ = "BatchGetChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__qualname__ = "BatchGetChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_BatchCreateSeriesArchetypeRequest(ConjureBeanType):
+class timeseries_channelmetadata_api_BatchGetChannelMetadataResponse(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[timeseries_archetype_api_CreateSeriesArchetypeRequest])
+            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
         }
 
-    __slots__: List[str] = ['_requests']
+    __slots__: List[str] = ['_responses']
 
-    def __init__(self, requests: List["timeseries_archetype_api_CreateSeriesArchetypeRequest"]) -> None:
-        self._requests = requests
+    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
+        self._responses = responses
 
     @builtins.property
-    def requests(self) -> List["timeseries_archetype_api_CreateSeriesArchetypeRequest"]:
-        return self._requests
+    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
+        return self._responses
 
 
-timeseries_archetype_api_BatchCreateSeriesArchetypeRequest.__name__ = "BatchCreateSeriesArchetypeRequest"
-timeseries_archetype_api_BatchCreateSeriesArchetypeRequest.__qualname__ = "BatchCreateSeriesArchetypeRequest"
-timeseries_archetype_api_BatchCreateSeriesArchetypeRequest.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__name__ = "BatchGetChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__qualname__ = "BatchGetChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_BatchGetSeriesArchetypeRequest(ConjureBeanType):
+class timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'datasources': ConjureFieldDefinition('datasources', List[api_rids_DataSourceRid])
+            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_UpdateChannelMetadataRequest])
         }
 
-    __slots__: List[str] = ['_datasources']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, datasources: List[str]) -> None:
-        self._datasources = datasources
+    def __init__(self, requests: List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]) -> None:
+        self._requests = requests
 
     @builtins.property
-    def datasources(self) -> List[str]:
-        return self._datasources
+    def requests(self) -> List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]:
+        return self._requests
 
 
-timeseries_archetype_api_BatchGetSeriesArchetypeRequest.__name__ = "BatchGetSeriesArchetypeRequest"
-timeseries_archetype_api_BatchGetSeriesArchetypeRequest.__qualname__ = "BatchGetSeriesArchetypeRequest"
-timeseries_archetype_api_BatchGetSeriesArchetypeRequest.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__name__ = "BatchUpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__qualname__ = "BatchUpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_BatchGetSeriesArchetypeResponse(ConjureBeanType):
+class timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'responses': ConjureFieldDefinition('responses', Dict[api_rids_DataSourceRid, List[timeseries_archetype_api_SeriesArchetype]])
+            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
         }
 
     __slots__: List[str] = ['_responses']
 
-    def __init__(self, responses: Dict[str, List["timeseries_archetype_api_SeriesArchetype"]]) -> None:
+    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
         self._responses = responses
 
     @builtins.property
-    def responses(self) -> Dict[str, List["timeseries_archetype_api_SeriesArchetype"]]:
+    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
         return self._responses
 
 
-timeseries_archetype_api_BatchGetSeriesArchetypeResponse.__name__ = "BatchGetSeriesArchetypeResponse"
-timeseries_archetype_api_BatchGetSeriesArchetypeResponse.__qualname__ = "BatchGetSeriesArchetypeResponse"
-timeseries_archetype_api_BatchGetSeriesArchetypeResponse.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__name__ = "BatchUpdateChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__qualname__ = "BatchUpdateChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_BigQueryLocatorTemplate(ConjureBeanType):
+class timeseries_channelmetadata_api_ChannelIdentifier(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'value_column': ConjureFieldDefinition('valueColumn', timeseries_logicalseries_api_ColumnName),
-            'time_column': ConjureFieldDefinition('timeColumn', timeseries_logicalseries_api_ColumnName),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_BigQueryType)
+            'channel_name': ConjureFieldDefinition('channelName', api_Channel),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid)
         }
 
-    __slots__: List[str] = ['_value_column', '_time_column', '_type']
-
-    def __init__(self, time_column: str, type: "timeseries_logicalseries_api_BigQueryType", value_column: str) -> None:
-        self._value_column = value_column
-        self._time_column = time_column
-        self._type = type
+    __slots__: List[str] = ['_channel_name', '_data_source_rid']
 
-    @builtins.property
-    def value_column(self) -> str:
-        return self._value_column
+    def __init__(self, channel_name: str, data_source_rid: str) -> None:
+        self._channel_name = channel_name
+        self._data_source_rid = data_source_rid
 
     @builtins.property
-    def time_column(self) -> str:
-        return self._time_column
+    def channel_name(self) -> str:
+        return self._channel_name
 
     @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_BigQueryType":
-        return self._type
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
 
 
-timeseries_archetype_api_BigQueryLocatorTemplate.__name__ = "BigQueryLocatorTemplate"
-timeseries_archetype_api_BigQueryLocatorTemplate.__qualname__ = "BigQueryLocatorTemplate"
-timeseries_archetype_api_BigQueryLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_ChannelIdentifier.__name__ = "ChannelIdentifier"
+timeseries_channelmetadata_api_ChannelIdentifier.__qualname__ = "ChannelIdentifier"
+timeseries_channelmetadata_api_ChannelIdentifier.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_CreateSeriesArchetypeRequest(ConjureBeanType):
+class timeseries_channelmetadata_api_ChannelMetadata(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
-            'locator': ConjureFieldDefinition('locator', timeseries_archetype_api_LocatorTemplate),
-            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
+            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'data_type': ConjureFieldDefinition('dataType', OptionalTypeWrapper[api_SeriesDataType])
         }
 
-    __slots__: List[str] = ['_channel', '_data_source_rid', '_locator', '_unit', '_description', '_tags']
+    __slots__: List[str] = ['_channel_identifier', '_description', '_unit', '_data_type']
 
-    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_archetype_api_LocatorTemplate", tags: Dict[str, str], description: Optional[str] = None, unit: Optional[str] = None) -> None:
-        self._channel = channel
-        self._data_source_rid = data_source_rid
-        self._locator = locator
-        self._unit = unit
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", data_type: Optional["api_SeriesDataType"] = None, description: Optional[str] = None, unit: Optional[str] = None) -> None:
+        self._channel_identifier = channel_identifier
         self._description = description
-        self._tags = tags
-
-    @builtins.property
-    def channel(self) -> str:
-        """This name should be unique amongst SeriesArchetypes within the data source. All series created from this
-archetype will share this name.
-        """
-        return self._channel
+        self._unit = unit
+        self._data_type = data_type
 
     @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
 
     @builtins.property
-    def locator(self) -> "timeseries_archetype_api_LocatorTemplate":
-        return self._locator
+    def description(self) -> Optional[str]:
+        return self._description
 
     @builtins.property
     def unit(self) -> Optional[str]:
         return self._unit
 
     @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        """Tags specified here will take precedence over tags specified in the RunDatasource, in the case that both specify the same TagName.
-        """
-        return self._tags
+    def data_type(self) -> Optional["api_SeriesDataType"]:
+        return self._data_type
 
 
-timeseries_archetype_api_CreateSeriesArchetypeRequest.__name__ = "CreateSeriesArchetypeRequest"
-timeseries_archetype_api_CreateSeriesArchetypeRequest.__qualname__ = "CreateSeriesArchetypeRequest"
-timeseries_archetype_api_CreateSeriesArchetypeRequest.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_ChannelMetadata.__name__ = "ChannelMetadata"
+timeseries_channelmetadata_api_ChannelMetadata.__qualname__ = "ChannelMetadata"
+timeseries_channelmetadata_api_ChannelMetadata.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_Influx1LocatorTemplate(ConjureBeanType):
+class timeseries_channelmetadata_api_GetChannelMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'database': ConjureFieldDefinition('database', timeseries_logicalseries_api_DatabaseName),
-            'measurement': ConjureFieldDefinition('measurement', timeseries_logicalseries_api_MeasurementName),
-            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_InfluxType)
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier)
         }
 
-    __slots__: List[str] = ['_database', '_measurement', '_field', '_type']
-
-    def __init__(self, database: str, field: str, measurement: str, type: "timeseries_logicalseries_api_InfluxType") -> None:
-        self._database = database
-        self._measurement = measurement
-        self._field = field
-        self._type = type
-
-    @builtins.property
-    def database(self) -> str:
-        return self._database
-
-    @builtins.property
-    def measurement(self) -> str:
-        return self._measurement
+    __slots__: List[str] = ['_channel_identifier']
 
-    @builtins.property
-    def field(self) -> str:
-        return self._field
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier") -> None:
+        self._channel_identifier = channel_identifier
 
     @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_InfluxType":
-        return self._type
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
 
 
-timeseries_archetype_api_Influx1LocatorTemplate.__name__ = "Influx1LocatorTemplate"
-timeseries_archetype_api_Influx1LocatorTemplate.__qualname__ = "Influx1LocatorTemplate"
-timeseries_archetype_api_Influx1LocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__name__ = "GetChannelMetadataRequest"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__qualname__ = "GetChannelMetadataRequest"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-class timeseries_archetype_api_Influx2LocatorTemplate(ConjureBeanType):
+class timeseries_channelmetadata_api_UpdateChannelMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'bucket': ConjureFieldDefinition('bucket', timeseries_logicalseries_api_BucketName),
-            'measurement': ConjureFieldDefinition('measurement', timeseries_logicalseries_api_MeasurementName),
-            'value_column': ConjureFieldDefinition('valueColumn', OptionalTypeWrapper[str]),
-            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_InfluxType)
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate])
         }
 
-    __slots__: List[str] = ['_bucket', '_measurement', '_value_column', '_field', '_type']
+    __slots__: List[str] = ['_channel_identifier', '_description', '_unit_update']
 
-    def __init__(self, bucket: str, field: str, measurement: str, type: "timeseries_logicalseries_api_InfluxType", value_column: Optional[str] = None) -> None:
-        self._bucket = bucket
-        self._measurement = measurement
-        self._value_column = value_column
-        self._field = field
-        self._type = type
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", description: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
+        self._channel_identifier = channel_identifier
+        self._description = description
+        self._unit_update = unit_update
 
     @builtins.property
-    def bucket(self) -> str:
-        return self._bucket
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
 
     @builtins.property
-    def measurement(self) -> str:
-        return self._measurement
+    def description(self) -> Optional[str]:
+        return self._description
 
     @builtins.property
-    def value_column(self) -> Optional[str]:
-        """If omitted, defaults to `_value`. Can be used to extract tag values.
-        """
-        return self._value_column
+    def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
+        return self._unit_update
 
-    @builtins.property
-    def field(self) -> str:
-        return self._field
 
-    @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_InfluxType":
-        return self._type
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__name__ = "UpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__qualname__ = "UpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
 
 
-timeseries_archetype_api_Influx2LocatorTemplate.__name__ = "Influx2LocatorTemplate"
-timeseries_archetype_api_Influx2LocatorTemplate.__qualname__ = "Influx2LocatorTemplate"
-timeseries_archetype_api_Influx2LocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+class timeseries_logicalseries_LogicalSeriesService(Service):
+    """A logical series is a timeseries, represented by a channel name and a tag set.
+    """
 
+    def create_logical_series(self, auth_header: str, create_logical_series: "timeseries_logicalseries_api_CreateLogicalSeries") -> "timeseries_logicalseries_api_LogicalSeries":
+        """Create a new logical series.
+        """
+        _conjure_encoder = ConjureEncoder()
 
-class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
-    _timescale_db: Optional["timeseries_archetype_api_TimescaleDbLocatorTemplate"] = None
-    _influx: Optional["timeseries_archetype_api_Influx2LocatorTemplate"] = None
-    _influx1: Optional["timeseries_archetype_api_Influx1LocatorTemplate"] = None
-    _nominal: Optional["timeseries_archetype_api_NominalLocatorTemplate"] = None
-    _timestream: Optional["timeseries_archetype_api_TimestreamLocatorTemplate"] = None
-    _visual_crossing: Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"] = None
-    _big_query: Optional["timeseries_archetype_api_BigQueryLocatorTemplate"] = None
-    _api: Optional["timeseries_archetype_api_ApiLocatorTemplate"] = None
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
 
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'timescale_db': ConjureFieldDefinition('timescaleDb', timeseries_archetype_api_TimescaleDbLocatorTemplate),
-            'influx': ConjureFieldDefinition('influx', timeseries_archetype_api_Influx2LocatorTemplate),
-            'influx1': ConjureFieldDefinition('influx1', timeseries_archetype_api_Influx1LocatorTemplate),
-            'nominal': ConjureFieldDefinition('nominal', timeseries_archetype_api_NominalLocatorTemplate),
-            'timestream': ConjureFieldDefinition('timestream', timeseries_archetype_api_TimestreamLocatorTemplate),
-            'visual_crossing': ConjureFieldDefinition('visualCrossing', timeseries_archetype_api_VisualCrossingLocatorTemplate),
-            'big_query': ConjureFieldDefinition('bigQuery', timeseries_archetype_api_BigQueryLocatorTemplate),
-            'api': ConjureFieldDefinition('api', timeseries_archetype_api_ApiLocatorTemplate)
+        _params: Dict[str, Any] = {
         }
 
-    def __init__(
-            self,
-            timescale_db: Optional["timeseries_archetype_api_TimescaleDbLocatorTemplate"] = None,
-            influx: Optional["timeseries_archetype_api_Influx2LocatorTemplate"] = None,
-            influx1: Optional["timeseries_archetype_api_Influx1LocatorTemplate"] = None,
-            nominal: Optional["timeseries_archetype_api_NominalLocatorTemplate"] = None,
-            timestream: Optional["timeseries_archetype_api_TimestreamLocatorTemplate"] = None,
-            visual_crossing: Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"] = None,
-            big_query: Optional["timeseries_archetype_api_BigQueryLocatorTemplate"] = None,
-            api: Optional["timeseries_archetype_api_ApiLocatorTemplate"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (timescale_db is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) + (api is not None) != 1:
-                raise ValueError('a union must contain a single member')
+        _path_params: Dict[str, str] = {
+        }
 
-            if timescale_db is not None:
-                self._timescale_db = timescale_db
-                self._type = 'timescaleDb'
-            if influx is not None:
-                self._influx = influx
-                self._type = 'influx'
-            if influx1 is not None:
-                self._influx1 = influx1
-                self._type = 'influx1'
-            if nominal is not None:
-                self._nominal = nominal
-                self._type = 'nominal'
-            if timestream is not None:
-                self._timestream = timestream
-                self._type = 'timestream'
-            if visual_crossing is not None:
-                self._visual_crossing = visual_crossing
-                self._type = 'visualCrossing'
-            if big_query is not None:
-                self._big_query = big_query
-                self._type = 'bigQuery'
-            if api is not None:
-                self._api = api
-                self._type = 'api'
+        _json: Any = _conjure_encoder.default(create_logical_series)
 
-        elif type_of_union == 'timescaleDb':
-            if timescale_db is None:
-                raise ValueError('a union value must not be None')
-            self._timescale_db = timescale_db
-            self._type = 'timescaleDb'
-        elif type_of_union == 'influx':
-            if influx is None:
-                raise ValueError('a union value must not be None')
-            self._influx = influx
-            self._type = 'influx'
-        elif type_of_union == 'influx1':
-            if influx1 is None:
-                raise ValueError('a union value must not be None')
-            self._influx1 = influx1
-            self._type = 'influx1'
-        elif type_of_union == 'nominal':
-            if nominal is None:
-                raise ValueError('a union value must not be None')
-            self._nominal = nominal
-            self._type = 'nominal'
-        elif type_of_union == 'timestream':
-            if timestream is None:
-                raise ValueError('a union value must not be None')
-            self._timestream = timestream
-            self._type = 'timestream'
-        elif type_of_union == 'visualCrossing':
-            if visual_crossing is None:
-                raise ValueError('a union value must not be None')
-            self._visual_crossing = visual_crossing
-            self._type = 'visualCrossing'
-        elif type_of_union == 'bigQuery':
-            if big_query is None:
-                raise ValueError('a union value must not be None')
-            self._big_query = big_query
-            self._type = 'bigQuery'
-        elif type_of_union == 'api':
-            if api is None:
-                raise ValueError('a union value must not be None')
-            self._api = api
-            self._type = 'api'
+        _path = '/timeseries/logical-series/v1/logical-series'
+        _path = _path.format(**_path_params)
 
-    @builtins.property
-    def timescale_db(self) -> Optional["timeseries_archetype_api_TimescaleDbLocatorTemplate"]:
-        return self._timescale_db
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
 
-    @builtins.property
-    def influx(self) -> Optional["timeseries_archetype_api_Influx2LocatorTemplate"]:
-        return self._influx
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_logicalseries_api_LogicalSeries, self._return_none_for_unknown_union_types)
 
-    @builtins.property
-    def influx1(self) -> Optional["timeseries_archetype_api_Influx1LocatorTemplate"]:
-        return self._influx1
+    def batch_create_logical_series(self, auth_header: str, request: "timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest") -> "timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse":
+        """Batch create new logical series.
+        """
+        _conjure_encoder = ConjureEncoder()
 
-    @builtins.property
-    def nominal(self) -> Optional["timeseries_archetype_api_NominalLocatorTemplate"]:
-        return self._nominal
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
 
-    @builtins.property
-    def timestream(self) -> Optional["timeseries_archetype_api_TimestreamLocatorTemplate"]:
-        return self._timestream
+        _params: Dict[str, Any] = {
+        }
 
-    @builtins.property
-    def visual_crossing(self) -> Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"]:
-        return self._visual_crossing
+        _path_params: Dict[str, str] = {
+        }
 
-    @builtins.property
-    def big_query(self) -> Optional["timeseries_archetype_api_BigQueryLocatorTemplate"]:
-        return self._big_query
+        _json: Any = _conjure_encoder.default(request)
 
-    @builtins.property
-    def api(self) -> Optional["timeseries_archetype_api_ApiLocatorTemplate"]:
-        return self._api
+        _path = '/timeseries/logical-series/v1/logical-series/batch-create'
+        _path = _path.format(**_path_params)
 
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, timeseries_archetype_api_LocatorTemplateVisitor):
-            raise ValueError('{} is not an instance of timeseries_archetype_api_LocatorTemplateVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'timescaleDb' and self.timescale_db is not None:
-            return visitor._timescale_db(self.timescale_db)
-        if self._type == 'influx' and self.influx is not None:
-            return visitor._influx(self.influx)
-        if self._type == 'influx1' and self.influx1 is not None:
-            return visitor._influx1(self.influx1)
-        if self._type == 'nominal' and self.nominal is not None:
-            return visitor._nominal(self.nominal)
-        if self._type == 'timestream' and self.timestream is not None:
-            return visitor._timestream(self.timestream)
-        if self._type == 'visualCrossing' and self.visual_crossing is not None:
-            return visitor._visual_crossing(self.visual_crossing)
-        if self._type == 'bigQuery' and self.big_query is not None:
-            return visitor._big_query(self.big_query)
-        if self._type == 'api' and self.api is not None:
-            return visitor._api(self.api)
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
 
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse, self._return_none_for_unknown_union_types)
 
-timeseries_archetype_api_LocatorTemplate.__name__ = "LocatorTemplate"
-timeseries_archetype_api_LocatorTemplate.__qualname__ = "LocatorTemplate"
-timeseries_archetype_api_LocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+    def batch_update_logical_series(self, auth_header: str, request: "timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest") -> "timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse":
+        """Batch update logical series descriptions and units.
+        """
+        _conjure_encoder = ConjureEncoder()
 
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
 
-class timeseries_archetype_api_LocatorTemplateVisitor:
+        _params: Dict[str, Any] = {
+        }
 
-    @abstractmethod
-    def _timescale_db(self, timescale_db: "timeseries_archetype_api_TimescaleDbLocatorTemplate") -> Any:
-        pass
+        _path_params: Dict[str, str] = {
+        }
 
-    @abstractmethod
-    def _influx(self, influx: "timeseries_archetype_api_Influx2LocatorTemplate") -> Any:
-        pass
+        _json: Any = _conjure_encoder.default(request)
 
-    @abstractmethod
-    def _influx1(self, influx1: "timeseries_archetype_api_Influx1LocatorTemplate") -> Any:
-        pass
+        _path = '/timeseries/logical-series/v1/logical-series/batch-update'
+        _path = _path.format(**_path_params)
 
-    @abstractmethod
-    def _nominal(self, nominal: "timeseries_archetype_api_NominalLocatorTemplate") -> Any:
-        pass
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
 
-    @abstractmethod
-    def _timestream(self, timestream: "timeseries_archetype_api_TimestreamLocatorTemplate") -> Any:
-        pass
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse, self._return_none_for_unknown_union_types)
 
-    @abstractmethod
-    def _visual_crossing(self, visual_crossing: "timeseries_archetype_api_VisualCrossingLocatorTemplate") -> Any:
-        pass
+    def get_logical_series(self, auth_header: str, rid: str) -> "timeseries_logicalseries_api_LogicalSeries":
+        """Get a logical series by logical series rid.
+        """
+        _conjure_encoder = ConjureEncoder()
 
-    @abstractmethod
-    def _big_query(self, big_query: "timeseries_archetype_api_BigQueryLocatorTemplate") -> Any:
-        pass
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
 
-    @abstractmethod
-    def _api(self, api: "timeseries_archetype_api_ApiLocatorTemplate") -> Any:
-        pass
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'rid': quote(str(_conjure_encoder.default(rid)), safe=''),
+        }
+
+        _json: Any = None
 
+        _path = '/timeseries/logical-series/v1/logical-series/{rid}'
+        _path = _path.format(**_path_params)
 
-timeseries_archetype_api_LocatorTemplateVisitor.__name__ = "LocatorTemplateVisitor"
-timeseries_archetype_api_LocatorTemplateVisitor.__qualname__ = "LocatorTemplateVisitor"
-timeseries_archetype_api_LocatorTemplateVisitor.__module__ = "nominal_api.timeseries_archetype_api"
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
 
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_logicalseries_api_LogicalSeries, self._return_none_for_unknown_union_types)
 
-class timeseries_archetype_api_NominalLocatorTemplate(ConjureBeanType):
+    def resolve_batch(self, auth_header: str, request: "timeseries_logicalseries_api_BatchResolveSeriesRequest") -> "timeseries_logicalseries_api_BatchResolveSeriesResponse":
+        """Resolves groups of channels, datasources and tags into logical series rids. An error response is provided
+if the channel + datasource + tag cannot be resolved into a logical series rid.
+        """
+        _conjure_encoder = ConjureEncoder()
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType)
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
         }
 
-    __slots__: List[str] = ['_channel', '_type']
+        _params: Dict[str, Any] = {
+        }
 
-    def __init__(self, channel: str, type: "storage_series_api_NominalDataType") -> None:
-        self._channel = channel
-        self._type = type
+        _path_params: Dict[str, str] = {
+        }
 
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
+        _json: Any = _conjure_encoder.default(request)
 
-    @builtins.property
-    def type(self) -> "storage_series_api_NominalDataType":
-        return self._type
+        _path = '/timeseries/logical-series/v1/resolve'
+        _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(), timeseries_logicalseries_api_BatchResolveSeriesResponse, self._return_none_for_unknown_union_types)
 
 
-timeseries_archetype_api_NominalLocatorTemplate.__name__ = "NominalLocatorTemplate"
-timeseries_archetype_api_NominalLocatorTemplate.__qualname__ = "NominalLocatorTemplate"
-timeseries_archetype_api_NominalLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_logicalseries_LogicalSeriesService.__name__ = "LogicalSeriesService"
+timeseries_logicalseries_LogicalSeriesService.__qualname__ = "LogicalSeriesService"
+timeseries_logicalseries_LogicalSeriesService.__module__ = "nominal_api.timeseries_logicalseries"
 
 
-class timeseries_archetype_api_SeriesArchetype(ConjureBeanType):
+class timeseries_logicalseries_api_ApiLocator(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rid': ConjureFieldDefinition('rid', api_SeriesArchetypeRid),
             'channel': ConjureFieldDefinition('channel', api_Channel),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
-            'locator': ConjureFieldDefinition('locator', timeseries_archetype_api_LocatorTemplate),
-            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
-            'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType])
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_ApiType)
         }
 
-    __slots__: List[str] = ['_rid', '_channel', '_data_source_rid', '_locator', '_unit', '_description', '_tags', '_series_data_type']
+    __slots__: List[str] = ['_channel', '_tags', '_type']
 
-    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_archetype_api_LocatorTemplate", rid: str, tags: Dict[str, str], description: Optional[str] = None, series_data_type: Optional["api_SeriesDataType"] = None, unit: Optional[str] = None) -> None:
-        self._rid = rid
+    def __init__(self, channel: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_ApiType") -> None:
         self._channel = channel
-        self._data_source_rid = data_source_rid
-        self._locator = locator
-        self._unit = unit
-        self._description = description
         self._tags = tags
-        self._series_data_type = series_data_type
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
+        self._type = type
 
     @builtins.property
     def channel(self) -> str:
         return self._channel
 
     @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
+    def tags(self) -> Dict[str, str]:
+        return self._tags
 
     @builtins.property
-    def locator(self) -> "timeseries_archetype_api_LocatorTemplate":
-        return self._locator
+    def type(self) -> "timeseries_logicalseries_api_ApiType":
+        return self._type
 
-    @builtins.property
-    def unit(self) -> Optional[str]:
-        return self._unit
 
-    @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
+timeseries_logicalseries_api_ApiLocator.__name__ = "ApiLocator"
+timeseries_logicalseries_api_ApiLocator.__qualname__ = "ApiLocator"
+timeseries_logicalseries_api_ApiLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        """Tags specified here will take precedence over tags specified in the RunDatasource, in the case that both specify the same TagName.
-        """
-        return self._tags
 
-    @builtins.property
-    def series_data_type(self) -> Optional["api_SeriesDataType"]:
-        return self._series_data_type
+class timeseries_logicalseries_api_ApiType(ConjureEnumType):
+
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    INT64 = 'INT64'
+    '''INT64'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
 
-timeseries_archetype_api_SeriesArchetype.__name__ = "SeriesArchetype"
-timeseries_archetype_api_SeriesArchetype.__qualname__ = "SeriesArchetype"
-timeseries_archetype_api_SeriesArchetype.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_logicalseries_api_ApiType.__name__ = "ApiType"
+timeseries_logicalseries_api_ApiType.__qualname__ = "ApiType"
+timeseries_logicalseries_api_ApiType.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_archetype_api_TimescaleDbLocatorTemplate(ConjureBeanType):
+class timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'table': ConjureFieldDefinition('table', timeseries_logicalseries_api_TableName),
-            'schema': ConjureFieldDefinition('schema', timeseries_logicalseries_api_SchemaName),
-            'column': ConjureFieldDefinition('column', timeseries_logicalseries_api_ColumnName),
-            'time_column': ConjureFieldDefinition('timeColumn', timeseries_logicalseries_api_ColumnName),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_TimescaleType)
+            'requests': ConjureFieldDefinition('requests', List[timeseries_logicalseries_api_CreateLogicalSeries])
         }
 
-    __slots__: List[str] = ['_table', '_schema', '_column', '_time_column', '_type']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, column: str, schema: str, table: str, time_column: str, type: "timeseries_logicalseries_api_TimescaleType") -> None:
-        self._table = table
-        self._schema = schema
-        self._column = column
-        self._time_column = time_column
-        self._type = type
+    def __init__(self, requests: List["timeseries_logicalseries_api_CreateLogicalSeries"]) -> None:
+        self._requests = requests
 
     @builtins.property
-    def table(self) -> str:
-        return self._table
+    def requests(self) -> List["timeseries_logicalseries_api_CreateLogicalSeries"]:
+        return self._requests
 
-    @builtins.property
-    def schema(self) -> str:
-        return self._schema
 
-    @builtins.property
-    def column(self) -> str:
-        return self._column
+timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest.__name__ = "BatchCreateLogicalSeriesRequest"
+timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest.__qualname__ = "BatchCreateLogicalSeriesRequest"
+timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-    @builtins.property
-    def time_column(self) -> str:
-        return self._time_column
+
+class timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[timeseries_logicalseries_api_LogicalSeries])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["timeseries_logicalseries_api_LogicalSeries"]) -> None:
+        self._responses = responses
 
     @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_TimescaleType":
-        return self._type
+    def responses(self) -> List["timeseries_logicalseries_api_LogicalSeries"]:
+        return self._responses
 
 
-timeseries_archetype_api_TimescaleDbLocatorTemplate.__name__ = "TimescaleDbLocatorTemplate"
-timeseries_archetype_api_TimescaleDbLocatorTemplate.__qualname__ = "TimescaleDbLocatorTemplate"
-timeseries_archetype_api_TimescaleDbLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse.__name__ = "BatchCreateLogicalSeriesResponse"
+timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse.__qualname__ = "BatchCreateLogicalSeriesResponse"
+timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_archetype_api_TimestreamLocatorTemplate(ConjureBeanType):
+class timeseries_logicalseries_api_BatchResolveSeriesRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'table': ConjureFieldDefinition('table', timeseries_logicalseries_api_TableName),
-            'measure': ConjureFieldDefinition('measure', timeseries_logicalseries_api_MeasureName),
-            'attribute': ConjureFieldDefinition('attribute', OptionalTypeWrapper[timeseries_logicalseries_api_AttributeName]),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_TimestreamType)
+            'requests': ConjureFieldDefinition('requests', List[timeseries_logicalseries_api_ResolveSeriesRequest])
         }
 
-    __slots__: List[str] = ['_table', '_measure', '_attribute', '_type']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, measure: str, table: str, type: "timeseries_logicalseries_api_TimestreamType", attribute: Optional[str] = None) -> None:
-        self._table = table
-        self._measure = measure
-        self._attribute = attribute
-        self._type = type
+    def __init__(self, requests: List["timeseries_logicalseries_api_ResolveSeriesRequest"]) -> None:
+        self._requests = requests
 
     @builtins.property
-    def table(self) -> str:
-        return self._table
+    def requests(self) -> List["timeseries_logicalseries_api_ResolveSeriesRequest"]:
+        return self._requests
 
-    @builtins.property
-    def measure(self) -> str:
-        return self._measure
 
-    @builtins.property
-    def attribute(self) -> Optional[str]:
-        return self._attribute
+timeseries_logicalseries_api_BatchResolveSeriesRequest.__name__ = "BatchResolveSeriesRequest"
+timeseries_logicalseries_api_BatchResolveSeriesRequest.__qualname__ = "BatchResolveSeriesRequest"
+timeseries_logicalseries_api_BatchResolveSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_BatchResolveSeriesResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'series': ConjureFieldDefinition('series', List[timeseries_logicalseries_api_ResolveSeriesResponse])
+        }
+
+    __slots__: List[str] = ['_series']
+
+    def __init__(self, series: List["timeseries_logicalseries_api_ResolveSeriesResponse"]) -> None:
+        self._series = series
 
     @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_TimestreamType":
-        return self._type
+    def series(self) -> List["timeseries_logicalseries_api_ResolveSeriesResponse"]:
+        return self._series
 
 
-timeseries_archetype_api_TimestreamLocatorTemplate.__name__ = "TimestreamLocatorTemplate"
-timeseries_archetype_api_TimestreamLocatorTemplate.__qualname__ = "TimestreamLocatorTemplate"
-timeseries_archetype_api_TimestreamLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_logicalseries_api_BatchResolveSeriesResponse.__name__ = "BatchResolveSeriesResponse"
+timeseries_logicalseries_api_BatchResolveSeriesResponse.__qualname__ = "BatchResolveSeriesResponse"
+timeseries_logicalseries_api_BatchResolveSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_archetype_api_UpdateSeriesArchetypeMetadataRequest(ConjureBeanType):
-    """If fields are present, will override existing values.
-    """
+class timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
-            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate]),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str])
+            'requests': ConjureFieldDefinition('requests', List[timeseries_logicalseries_api_UpdateLogicalSeries])
         }
 
-    __slots__: List[str] = ['_unit', '_unit_update', '_description']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, description: Optional[str] = None, unit: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
-        self._unit = unit
-        self._unit_update = unit_update
-        self._description = description
+    def __init__(self, requests: List["timeseries_logicalseries_api_UpdateLogicalSeries"]) -> None:
+        self._requests = requests
 
     @builtins.property
-    def unit(self) -> Optional[str]:
-        return self._unit
+    def requests(self) -> List["timeseries_logicalseries_api_UpdateLogicalSeries"]:
+        return self._requests
 
-    @builtins.property
-    def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
-        return self._unit_update
+
+timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest.__name__ = "BatchUpdateLogicalSeriesRequest"
+timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest.__qualname__ = "BatchUpdateLogicalSeriesRequest"
+timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[timeseries_logicalseries_api_LogicalSeries])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["timeseries_logicalseries_api_LogicalSeries"]) -> None:
+        self._responses = responses
 
     @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
+    def responses(self) -> List["timeseries_logicalseries_api_LogicalSeries"]:
+        return self._responses
 
 
-timeseries_archetype_api_UpdateSeriesArchetypeMetadataRequest.__name__ = "UpdateSeriesArchetypeMetadataRequest"
-timeseries_archetype_api_UpdateSeriesArchetypeMetadataRequest.__qualname__ = "UpdateSeriesArchetypeMetadataRequest"
-timeseries_archetype_api_UpdateSeriesArchetypeMetadataRequest.__module__ = "nominal_api.timeseries_archetype_api"
+timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse.__name__ = "BatchUpdateLogicalSeriesResponse"
+timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse.__qualname__ = "BatchUpdateLogicalSeriesResponse"
+timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_archetype_api_VisualCrossingLocatorTemplate(ConjureBeanType):
+class timeseries_logicalseries_api_BigQueryLocator(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
-            'endpoint': ConjureFieldDefinition('endpoint', OptionalTypeWrapper[timeseries_logicalseries_api_VisualCrossingEndpointUri]),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_VisualCrossingType)
+            'value_column': ConjureFieldDefinition('valueColumn', timeseries_logicalseries_api_ColumnName),
+            'time_column': ConjureFieldDefinition('timeColumn', timeseries_logicalseries_api_ColumnName),
+            'tag_values': ConjureFieldDefinition('tagValues', Dict[api_TagName, api_TagValue]),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_BigQueryType)
         }
 
-    __slots__: List[str] = ['_field', '_endpoint', '_type']
+    __slots__: List[str] = ['_value_column', '_time_column', '_tag_values', '_type']
 
-    def __init__(self, field: str, type: "timeseries_logicalseries_api_VisualCrossingType", endpoint: Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"] = None) -> None:
-        self._field = field
-        self._endpoint = endpoint
+    def __init__(self, tag_values: Dict[str, str], time_column: str, type: "timeseries_logicalseries_api_BigQueryType", value_column: str) -> None:
+        self._value_column = value_column
+        self._time_column = time_column
+        self._tag_values = tag_values
         self._type = type
 
     @builtins.property
-    def field(self) -> str:
-        return self._field
+    def value_column(self) -> str:
+        """The name of the column which has the values for this series
+        """
+        return self._value_column
 
     @builtins.property
-    def endpoint(self) -> Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"]:
-        """Defaults to HISTORY.
+    def time_column(self) -> str:
+        """The name of the column which has the timestamps for this series
         """
-        return self._endpoint
+        return self._time_column
 
     @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_VisualCrossingType":
-        return self._type
-
-
-timeseries_archetype_api_VisualCrossingLocatorTemplate.__name__ = "VisualCrossingLocatorTemplate"
-timeseries_archetype_api_VisualCrossingLocatorTemplate.__qualname__ = "VisualCrossingLocatorTemplate"
-timeseries_archetype_api_VisualCrossingLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+    def tag_values(self) -> Dict[str, str]:
+        """The mapping of columns to column values to filter on
+        """
+        return self._tag_values
 
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_BigQueryType":
+        return self._type
 
-class timeseries_channelmetadata_ChannelMetadataService(Service):
-    """Endpoints for retrieving and updating channel metadata.
-    """
 
-    def get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_GetChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
-        """Get the metadata for a channel.
-        """
-        _conjure_encoder = ConjureEncoder()
+timeseries_logicalseries_api_BigQueryLocator.__name__ = "BigQueryLocator"
+timeseries_logicalseries_api_BigQueryLocator.__qualname__ = "BigQueryLocator"
+timeseries_logicalseries_api_BigQueryLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
 
-        _params: Dict[str, Any] = {
-        }
+class timeseries_logicalseries_api_BigQueryType(ConjureEnumType):
 
-        _path_params: Dict[str, str] = {
-        }
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
 
-        _json: Any = _conjure_encoder.default(request)
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
-        _path = '/timeseries/channel-metadata/v1/channel-metadata/get'
-        _path = _path.format(**_path_params)
 
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
+timeseries_logicalseries_api_BigQueryType.__name__ = "BigQueryType"
+timeseries_logicalseries_api_BigQueryType.__qualname__ = "BigQueryType"
+timeseries_logicalseries_api_BigQueryType.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
 
-    def batch_get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchGetChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchGetChannelMetadataResponse":
-        """Batch get the metadata for multiple channels. If some channels cannot be found or authorized, 
-they will be omitted from the response.
-        """
-        _conjure_encoder = ConjureEncoder()
+class timeseries_logicalseries_api_Context(ConjureBeanType):
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'properties': ConjureFieldDefinition('properties', Dict[str, timeseries_logicalseries_api_ContextProperty])
         }
 
-        _params: Dict[str, Any] = {
-        }
+    __slots__: List[str] = ['_properties']
 
-        _path_params: Dict[str, str] = {
-        }
+    def __init__(self, properties: Dict[str, "timeseries_logicalseries_api_ContextProperty"]) -> None:
+        self._properties = properties
 
-        _json: Any = _conjure_encoder.default(request)
+    @builtins.property
+    def properties(self) -> Dict[str, "timeseries_logicalseries_api_ContextProperty"]:
+        return self._properties
 
-        _path = '/timeseries/channel-metadata/v1/channel-metadata/batch-get'
-        _path = _path.format(**_path_params)
 
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
+timeseries_logicalseries_api_Context.__name__ = "Context"
+timeseries_logicalseries_api_Context.__qualname__ = "Context"
+timeseries_logicalseries_api_Context.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_BatchGetChannelMetadataResponse, self._return_none_for_unknown_union_types)
 
-    def update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_UpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
-        """Update the metadata for a channel.
-        """
-        _conjure_encoder = ConjureEncoder()
+class timeseries_logicalseries_api_ContextProperty(ConjureUnionType):
+    _value: Optional[str] = None
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'value': ConjureFieldDefinition('value', str)
         }
 
-        _params: Dict[str, Any] = {
-        }
+    def __init__(
+            self,
+            value: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (value is not None) != 1:
+                raise ValueError('a union must contain a single member')
 
-        _path_params: Dict[str, str] = {
-        }
+            if value is not None:
+                self._value = value
+                self._type = 'value'
 
-        _json: Any = _conjure_encoder.default(request)
+        elif type_of_union == 'value':
+            if value is None:
+                raise ValueError('a union value must not be None')
+            self._value = value
+            self._type = 'value'
 
-        _path = '/timeseries/channel-metadata/v1/channel-metadata/update'
-        _path = _path.format(**_path_params)
+    @builtins.property
+    def value(self) -> Optional[str]:
+        return self._value
 
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, timeseries_logicalseries_api_ContextPropertyVisitor):
+            raise ValueError('{} is not an instance of timeseries_logicalseries_api_ContextPropertyVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'value' and self.value is not None:
+            return visitor._value(self.value)
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
 
-    def batch_update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse":
-        """Batch update the metadata for multiple channels. If some channels cannot be found or authorized,
-no metadata will be updated for any of the channels in the request.
-        """
-        _conjure_encoder = ConjureEncoder()
+timeseries_logicalseries_api_ContextProperty.__name__ = "ContextProperty"
+timeseries_logicalseries_api_ContextProperty.__qualname__ = "ContextProperty"
+timeseries_logicalseries_api_ContextProperty.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
 
-        _params: Dict[str, Any] = {
-        }
+class timeseries_logicalseries_api_ContextPropertyVisitor:
 
-        _path_params: Dict[str, str] = {
-        }
+    @abstractmethod
+    def _value(self, value: str) -> Any:
+        pass
 
-        _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/channel-metadata/v1/channel-metadata/batch-update'
-        _path = _path.format(**_path_params)
+timeseries_logicalseries_api_ContextPropertyVisitor.__name__ = "ContextPropertyVisitor"
+timeseries_logicalseries_api_ContextPropertyVisitor.__qualname__ = "ContextPropertyVisitor"
+timeseries_logicalseries_api_ContextPropertyVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_CreateLogicalSeries(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'locator': ConjureFieldDefinition('locator', timeseries_logicalseries_api_Locator),
+            'id_locator': ConjureFieldDefinition('idLocator', OptionalTypeWrapper[str]),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType]),
+            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity]),
+            'series_archetype_rid': ConjureFieldDefinition('seriesArchetypeRid', OptionalTypeWrapper[api_SeriesArchetypeRid])
+        }
+
+    __slots__: List[str] = ['_channel', '_locator', '_id_locator', '_data_source_rid', '_description', '_unit', '_series_data_type', '_granularity', '_series_archetype_rid']
+
+    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_logicalseries_api_Locator", description: Optional[str] = None, granularity: Optional["api_Granularity"] = None, id_locator: Optional[str] = None, series_archetype_rid: Optional[str] = None, series_data_type: Optional["api_SeriesDataType"] = None, unit: Optional[str] = None) -> None:
+        self._channel = channel
+        self._locator = locator
+        self._id_locator = id_locator
+        self._data_source_rid = data_source_rid
+        self._description = description
+        self._unit = unit
+        self._series_data_type = series_data_type
+        self._granularity = granularity
+        self._series_archetype_rid = series_archetype_rid
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def locator(self) -> "timeseries_logicalseries_api_Locator":
+        return self._locator
+
+    @builtins.property
+    def id_locator(self) -> Optional[str]:
+        """If present, will be used as the locator of the LogicalSeriesRid. If a logical series already exists
+with this id, will throw a CONFLICT.
+        """
+        return self._id_locator
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def unit(self) -> Optional[str]:
+        return self._unit
+
+    @builtins.property
+    def series_data_type(self) -> Optional["api_SeriesDataType"]:
+        return self._series_data_type
+
+    @builtins.property
+    def granularity(self) -> Optional["api_Granularity"]:
+        return self._granularity
+
+    @builtins.property
+    def series_archetype_rid(self) -> Optional[str]:
+        """Deprecated. Do not use.
+        """
+        return self._series_archetype_rid
+
+
+timeseries_logicalseries_api_CreateLogicalSeries.__name__ = "CreateLogicalSeries"
+timeseries_logicalseries_api_CreateLogicalSeries.__qualname__ = "CreateLogicalSeries"
+timeseries_logicalseries_api_CreateLogicalSeries.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_Influx1Locator(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'database': ConjureFieldDefinition('database', timeseries_logicalseries_api_DatabaseName),
+            'measurement': ConjureFieldDefinition('measurement', timeseries_logicalseries_api_MeasurementName),
+            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_InfluxType)
+        }
+
+    __slots__: List[str] = ['_database', '_measurement', '_field', '_tags', '_type']
+
+    def __init__(self, database: str, field: str, measurement: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_InfluxType") -> None:
+        self._database = database
+        self._measurement = measurement
+        self._field = field
+        self._tags = tags
+        self._type = type
+
+    @builtins.property
+    def database(self) -> str:
+        return self._database
+
+    @builtins.property
+    def measurement(self) -> str:
+        return self._measurement
+
+    @builtins.property
+    def field(self) -> str:
+        return self._field
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_InfluxType":
+        return self._type
+
+
+timeseries_logicalseries_api_Influx1Locator.__name__ = "Influx1Locator"
+timeseries_logicalseries_api_Influx1Locator.__qualname__ = "Influx1Locator"
+timeseries_logicalseries_api_Influx1Locator.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_Influx2Locator(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'bucket': ConjureFieldDefinition('bucket', timeseries_logicalseries_api_BucketName),
+            'measurement': ConjureFieldDefinition('measurement', timeseries_logicalseries_api_MeasurementName),
+            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
+            'value_column': ConjureFieldDefinition('valueColumn', OptionalTypeWrapper[str]),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_InfluxType)
+        }
+
+    __slots__: List[str] = ['_bucket', '_measurement', '_field', '_value_column', '_tags', '_type']
+
+    def __init__(self, bucket: str, field: str, measurement: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_InfluxType", value_column: Optional[str] = None) -> None:
+        self._bucket = bucket
+        self._measurement = measurement
+        self._field = field
+        self._value_column = value_column
+        self._tags = tags
+        self._type = type
+
+    @builtins.property
+    def bucket(self) -> str:
+        return self._bucket
+
+    @builtins.property
+    def measurement(self) -> str:
+        return self._measurement
+
+    @builtins.property
+    def field(self) -> str:
+        return self._field
+
+    @builtins.property
+    def value_column(self) -> Optional[str]:
+        """If omitted, defaults to `_value`. Can be used to extract tag values.
+        """
+        return self._value_column
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_InfluxType":
+        return self._type
+
+
+timeseries_logicalseries_api_Influx2Locator.__name__ = "Influx2Locator"
+timeseries_logicalseries_api_Influx2Locator.__qualname__ = "Influx2Locator"
+timeseries_logicalseries_api_Influx2Locator.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_InfluxType(ConjureEnumType):
+
+    BOOLEAN = 'BOOLEAN'
+    '''BOOLEAN'''
+    NUMERIC = 'NUMERIC'
+    '''NUMERIC'''
+    STRING = 'STRING'
+    '''STRING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+timeseries_logicalseries_api_InfluxType.__name__ = "InfluxType"
+timeseries_logicalseries_api_InfluxType.__qualname__ = "InfluxType"
+timeseries_logicalseries_api_InfluxType.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_Locator(ConjureUnionType):
+    _timescale_db_locator: Optional["timeseries_logicalseries_api_TimescaleDbLocator"] = None
+    _influx_locator: Optional["timeseries_logicalseries_api_Influx2Locator"] = None
+    _influx1_locator: Optional["timeseries_logicalseries_api_Influx1Locator"] = None
+    _nominal_locator: Optional["timeseries_logicalseries_api_NominalLocator"] = None
+    _timestream_locator: Optional["timeseries_logicalseries_api_TimestreamLocator"] = None
+    _visual_crossing_locator: Optional["timeseries_logicalseries_api_VisualCrossingLocator"] = None
+    _big_query_locator: Optional["timeseries_logicalseries_api_BigQueryLocator"] = None
+    _api_locator: Optional["timeseries_logicalseries_api_ApiLocator"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timescale_db_locator': ConjureFieldDefinition('timescaleDbLocator', timeseries_logicalseries_api_TimescaleDbLocator),
+            'influx_locator': ConjureFieldDefinition('influxLocator', timeseries_logicalseries_api_Influx2Locator),
+            'influx1_locator': ConjureFieldDefinition('influx1Locator', timeseries_logicalseries_api_Influx1Locator),
+            'nominal_locator': ConjureFieldDefinition('nominalLocator', timeseries_logicalseries_api_NominalLocator),
+            'timestream_locator': ConjureFieldDefinition('timestreamLocator', timeseries_logicalseries_api_TimestreamLocator),
+            'visual_crossing_locator': ConjureFieldDefinition('visualCrossingLocator', timeseries_logicalseries_api_VisualCrossingLocator),
+            'big_query_locator': ConjureFieldDefinition('bigQueryLocator', timeseries_logicalseries_api_BigQueryLocator),
+            'api_locator': ConjureFieldDefinition('apiLocator', timeseries_logicalseries_api_ApiLocator)
+        }
+
+    def __init__(
+            self,
+            timescale_db_locator: Optional["timeseries_logicalseries_api_TimescaleDbLocator"] = None,
+            influx_locator: Optional["timeseries_logicalseries_api_Influx2Locator"] = None,
+            influx1_locator: Optional["timeseries_logicalseries_api_Influx1Locator"] = None,
+            nominal_locator: Optional["timeseries_logicalseries_api_NominalLocator"] = None,
+            timestream_locator: Optional["timeseries_logicalseries_api_TimestreamLocator"] = None,
+            visual_crossing_locator: Optional["timeseries_logicalseries_api_VisualCrossingLocator"] = None,
+            big_query_locator: Optional["timeseries_logicalseries_api_BigQueryLocator"] = None,
+            api_locator: Optional["timeseries_logicalseries_api_ApiLocator"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (timescale_db_locator is not None) + (influx_locator is not None) + (influx1_locator is not None) + (nominal_locator is not None) + (timestream_locator is not None) + (visual_crossing_locator is not None) + (big_query_locator is not None) + (api_locator is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if timescale_db_locator is not None:
+                self._timescale_db_locator = timescale_db_locator
+                self._type = 'timescaleDbLocator'
+            if influx_locator is not None:
+                self._influx_locator = influx_locator
+                self._type = 'influxLocator'
+            if influx1_locator is not None:
+                self._influx1_locator = influx1_locator
+                self._type = 'influx1Locator'
+            if nominal_locator is not None:
+                self._nominal_locator = nominal_locator
+                self._type = 'nominalLocator'
+            if timestream_locator is not None:
+                self._timestream_locator = timestream_locator
+                self._type = 'timestreamLocator'
+            if visual_crossing_locator is not None:
+                self._visual_crossing_locator = visual_crossing_locator
+                self._type = 'visualCrossingLocator'
+            if big_query_locator is not None:
+                self._big_query_locator = big_query_locator
+                self._type = 'bigQueryLocator'
+            if api_locator is not None:
+                self._api_locator = api_locator
+                self._type = 'apiLocator'
+
+        elif type_of_union == 'timescaleDbLocator':
+            if timescale_db_locator is None:
+                raise ValueError('a union value must not be None')
+            self._timescale_db_locator = timescale_db_locator
+            self._type = 'timescaleDbLocator'
+        elif type_of_union == 'influxLocator':
+            if influx_locator is None:
+                raise ValueError('a union value must not be None')
+            self._influx_locator = influx_locator
+            self._type = 'influxLocator'
+        elif type_of_union == 'influx1Locator':
+            if influx1_locator is None:
+                raise ValueError('a union value must not be None')
+            self._influx1_locator = influx1_locator
+            self._type = 'influx1Locator'
+        elif type_of_union == 'nominalLocator':
+            if nominal_locator is None:
+                raise ValueError('a union value must not be None')
+            self._nominal_locator = nominal_locator
+            self._type = 'nominalLocator'
+        elif type_of_union == 'timestreamLocator':
+            if timestream_locator is None:
+                raise ValueError('a union value must not be None')
+            self._timestream_locator = timestream_locator
+            self._type = 'timestreamLocator'
+        elif type_of_union == 'visualCrossingLocator':
+            if visual_crossing_locator is None:
+                raise ValueError('a union value must not be None')
+            self._visual_crossing_locator = visual_crossing_locator
+            self._type = 'visualCrossingLocator'
+        elif type_of_union == 'bigQueryLocator':
+            if big_query_locator is None:
+                raise ValueError('a union value must not be None')
+            self._big_query_locator = big_query_locator
+            self._type = 'bigQueryLocator'
+        elif type_of_union == 'apiLocator':
+            if api_locator is None:
+                raise ValueError('a union value must not be None')
+            self._api_locator = api_locator
+            self._type = 'apiLocator'
+
+    @builtins.property
+    def timescale_db_locator(self) -> Optional["timeseries_logicalseries_api_TimescaleDbLocator"]:
+        return self._timescale_db_locator
+
+    @builtins.property
+    def influx_locator(self) -> Optional["timeseries_logicalseries_api_Influx2Locator"]:
+        return self._influx_locator
+
+    @builtins.property
+    def influx1_locator(self) -> Optional["timeseries_logicalseries_api_Influx1Locator"]:
+        return self._influx1_locator
+
+    @builtins.property
+    def nominal_locator(self) -> Optional["timeseries_logicalseries_api_NominalLocator"]:
+        return self._nominal_locator
+
+    @builtins.property
+    def timestream_locator(self) -> Optional["timeseries_logicalseries_api_TimestreamLocator"]:
+        return self._timestream_locator
+
+    @builtins.property
+    def visual_crossing_locator(self) -> Optional["timeseries_logicalseries_api_VisualCrossingLocator"]:
+        return self._visual_crossing_locator
+
+    @builtins.property
+    def big_query_locator(self) -> Optional["timeseries_logicalseries_api_BigQueryLocator"]:
+        return self._big_query_locator
+
+    @builtins.property
+    def api_locator(self) -> Optional["timeseries_logicalseries_api_ApiLocator"]:
+        return self._api_locator
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, timeseries_logicalseries_api_LocatorVisitor):
+            raise ValueError('{} is not an instance of timeseries_logicalseries_api_LocatorVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'timescaleDbLocator' and self.timescale_db_locator is not None:
+            return visitor._timescale_db_locator(self.timescale_db_locator)
+        if self._type == 'influxLocator' and self.influx_locator is not None:
+            return visitor._influx_locator(self.influx_locator)
+        if self._type == 'influx1Locator' and self.influx1_locator is not None:
+            return visitor._influx1_locator(self.influx1_locator)
+        if self._type == 'nominalLocator' and self.nominal_locator is not None:
+            return visitor._nominal_locator(self.nominal_locator)
+        if self._type == 'timestreamLocator' and self.timestream_locator is not None:
+            return visitor._timestream_locator(self.timestream_locator)
+        if self._type == 'visualCrossingLocator' and self.visual_crossing_locator is not None:
+            return visitor._visual_crossing_locator(self.visual_crossing_locator)
+        if self._type == 'bigQueryLocator' and self.big_query_locator is not None:
+            return visitor._big_query_locator(self.big_query_locator)
+        if self._type == 'apiLocator' and self.api_locator is not None:
+            return visitor._api_locator(self.api_locator)
+
+
+timeseries_logicalseries_api_Locator.__name__ = "Locator"
+timeseries_logicalseries_api_Locator.__qualname__ = "Locator"
+timeseries_logicalseries_api_Locator.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_LocatorVisitor:
+
+    @abstractmethod
+    def _timescale_db_locator(self, timescale_db_locator: "timeseries_logicalseries_api_TimescaleDbLocator") -> Any:
+        pass
+
+    @abstractmethod
+    def _influx_locator(self, influx_locator: "timeseries_logicalseries_api_Influx2Locator") -> Any:
+        pass
+
+    @abstractmethod
+    def _influx1_locator(self, influx1_locator: "timeseries_logicalseries_api_Influx1Locator") -> Any:
+        pass
+
+    @abstractmethod
+    def _nominal_locator(self, nominal_locator: "timeseries_logicalseries_api_NominalLocator") -> Any:
+        pass
+
+    @abstractmethod
+    def _timestream_locator(self, timestream_locator: "timeseries_logicalseries_api_TimestreamLocator") -> Any:
+        pass
+
+    @abstractmethod
+    def _visual_crossing_locator(self, visual_crossing_locator: "timeseries_logicalseries_api_VisualCrossingLocator") -> Any:
+        pass
+
+    @abstractmethod
+    def _big_query_locator(self, big_query_locator: "timeseries_logicalseries_api_BigQueryLocator") -> Any:
+        pass
+
+    @abstractmethod
+    def _api_locator(self, api_locator: "timeseries_logicalseries_api_ApiLocator") -> Any:
+        pass
+
+
+timeseries_logicalseries_api_LocatorVisitor.__name__ = "LocatorVisitor"
+timeseries_logicalseries_api_LocatorVisitor.__qualname__ = "LocatorVisitor"
+timeseries_logicalseries_api_LocatorVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_LogicalSeries(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', api_LogicalSeriesRid),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
+            'locator': ConjureFieldDefinition('locator', timeseries_logicalseries_api_Locator),
+            'time_locator': ConjureFieldDefinition('timeLocator', OptionalTypeWrapper[timeseries_logicalseries_api_Locator]),
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType]),
+            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity])
+        }
+
+    __slots__: List[str] = ['_rid', '_data_source_rid', '_locator', '_time_locator', '_channel', '_description', '_unit', '_series_data_type', '_granularity']
+
+    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_logicalseries_api_Locator", rid: str, description: Optional[str] = None, granularity: Optional["api_Granularity"] = None, series_data_type: Optional["api_SeriesDataType"] = None, time_locator: Optional["timeseries_logicalseries_api_Locator"] = None, unit: Optional[str] = None) -> None:
+        self._rid = rid
+        self._data_source_rid = data_source_rid
+        self._locator = locator
+        self._time_locator = time_locator
+        self._channel = channel
+        self._description = description
+        self._unit = unit
+        self._series_data_type = series_data_type
+        self._granularity = granularity
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+    @builtins.property
+    def locator(self) -> "timeseries_logicalseries_api_Locator":
+        return self._locator
+
+    @builtins.property
+    def time_locator(self) -> Optional["timeseries_logicalseries_api_Locator"]:
+        """Only required to be present for legacy CSVs.
+        """
+        return self._time_locator
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def unit(self) -> Optional[str]:
+        return self._unit
+
+    @builtins.property
+    def series_data_type(self) -> Optional["api_SeriesDataType"]:
+        return self._series_data_type
+
+    @builtins.property
+    def granularity(self) -> Optional["api_Granularity"]:
+        """Time granularity of the series. If omitted, defaults to nanoseconds.
+        """
+        return self._granularity
+
+
+timeseries_logicalseries_api_LogicalSeries.__name__ = "LogicalSeries"
+timeseries_logicalseries_api_LogicalSeries.__qualname__ = "LogicalSeries"
+timeseries_logicalseries_api_LogicalSeries.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_NominalLocator(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType)
+        }
+
+    __slots__: List[str] = ['_channel', '_tags', '_type']
+
+    def __init__(self, channel: str, tags: Dict[str, str], type: "storage_series_api_NominalDataType") -> None:
+        self._channel = channel
+        self._tags = tags
+        self._type = type
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+    @builtins.property
+    def type(self) -> "storage_series_api_NominalDataType":
+        return self._type
+
+
+timeseries_logicalseries_api_NominalLocator.__name__ = "NominalLocator"
+timeseries_logicalseries_api_NominalLocator.__qualname__ = "NominalLocator"
+timeseries_logicalseries_api_NominalLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_ResolveSeriesError(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'message': ConjureFieldDefinition('message', str),
+            'args': ConjureFieldDefinition('args', Dict[str, str])
+        }
+
+    __slots__: List[str] = ['_message', '_args']
+
+    def __init__(self, args: Dict[str, str], message: str) -> None:
+        self._message = message
+        self._args = args
+
+    @builtins.property
+    def message(self) -> str:
+        return self._message
+
+    @builtins.property
+    def args(self) -> Dict[str, str]:
+        return self._args
+
+
+timeseries_logicalseries_api_ResolveSeriesError.__name__ = "ResolveSeriesError"
+timeseries_logicalseries_api_ResolveSeriesError.__qualname__ = "ResolveSeriesError"
+timeseries_logicalseries_api_ResolveSeriesError.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_ResolveSeriesRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'name': ConjureFieldDefinition('name', api_Channel),
+            'datasource': ConjureFieldDefinition('datasource', api_rids_DataSourceRid),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
+        }
+
+    __slots__: List[str] = ['_name', '_datasource', '_tags']
+
+    def __init__(self, datasource: str, name: str, tags: Dict[str, str]) -> None:
+        self._name = name
+        self._datasource = datasource
+        self._tags = tags
+
+    @builtins.property
+    def name(self) -> str:
+        return self._name
+
+    @builtins.property
+    def datasource(self) -> str:
+        return self._datasource
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+
+timeseries_logicalseries_api_ResolveSeriesRequest.__name__ = "ResolveSeriesRequest"
+timeseries_logicalseries_api_ResolveSeriesRequest.__qualname__ = "ResolveSeriesRequest"
+timeseries_logicalseries_api_ResolveSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_ResolveSeriesResponse(ConjureUnionType):
+    _rid: Optional[str] = None
+    _error: Optional["timeseries_logicalseries_api_ResolveSeriesError"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', api_LogicalSeriesRid),
+            'error': ConjureFieldDefinition('error', timeseries_logicalseries_api_ResolveSeriesError)
+        }
+
+    def __init__(
+            self,
+            rid: Optional[str] = None,
+            error: Optional["timeseries_logicalseries_api_ResolveSeriesError"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (rid is not None) + (error is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if rid is not None:
+                self._rid = rid
+                self._type = 'rid'
+            if error is not None:
+                self._error = error
+                self._type = 'error'
+
+        elif type_of_union == 'rid':
+            if rid is None:
+                raise ValueError('a union value must not be None')
+            self._rid = rid
+            self._type = 'rid'
+        elif type_of_union == 'error':
+            if error is None:
+                raise ValueError('a union value must not be None')
+            self._error = error
+            self._type = 'error'
+
+    @builtins.property
+    def rid(self) -> Optional[str]:
+        return self._rid
+
+    @builtins.property
+    def error(self) -> Optional["timeseries_logicalseries_api_ResolveSeriesError"]:
+        return self._error
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, timeseries_logicalseries_api_ResolveSeriesResponseVisitor):
+            raise ValueError('{} is not an instance of timeseries_logicalseries_api_ResolveSeriesResponseVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'rid' and self.rid is not None:
+            return visitor._rid(self.rid)
+        if self._type == 'error' and self.error is not None:
+            return visitor._error(self.error)
+
+
+timeseries_logicalseries_api_ResolveSeriesResponse.__name__ = "ResolveSeriesResponse"
+timeseries_logicalseries_api_ResolveSeriesResponse.__qualname__ = "ResolveSeriesResponse"
+timeseries_logicalseries_api_ResolveSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse, self._return_none_for_unknown_union_types)
+class timeseries_logicalseries_api_ResolveSeriesResponseVisitor:
 
+    @abstractmethod
+    def _rid(self, rid: str) -> Any:
+        pass
 
-timeseries_channelmetadata_ChannelMetadataService.__name__ = "ChannelMetadataService"
-timeseries_channelmetadata_ChannelMetadataService.__qualname__ = "ChannelMetadataService"
-timeseries_channelmetadata_ChannelMetadataService.__module__ = "nominal_api.timeseries_channelmetadata"
+    @abstractmethod
+    def _error(self, error: "timeseries_logicalseries_api_ResolveSeriesError") -> Any:
+        pass
 
 
-class timeseries_channelmetadata_api_BatchGetChannelMetadataRequest(ConjureBeanType):
+timeseries_logicalseries_api_ResolveSeriesResponseVisitor.__name__ = "ResolveSeriesResponseVisitor"
+timeseries_logicalseries_api_ResolveSeriesResponseVisitor.__qualname__ = "ResolveSeriesResponseVisitor"
+timeseries_logicalseries_api_ResolveSeriesResponseVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_TimescaleDbLocator(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_GetChannelMetadataRequest])
+            'table': ConjureFieldDefinition('table', timeseries_logicalseries_api_TableName),
+            'schema': ConjureFieldDefinition('schema', timeseries_logicalseries_api_SchemaName),
+            'column': ConjureFieldDefinition('column', timeseries_logicalseries_api_ColumnName),
+            'time_column': ConjureFieldDefinition('timeColumn', timeseries_logicalseries_api_ColumnName),
+            'dimensions': ConjureFieldDefinition('dimensions', Dict[api_TagName, api_TagValue]),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_TimescaleType)
         }
 
-    __slots__: List[str] = ['_requests']
+    __slots__: List[str] = ['_table', '_schema', '_column', '_time_column', '_dimensions', '_type']
 
-    def __init__(self, requests: List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]) -> None:
-        self._requests = requests
+    def __init__(self, column: str, dimensions: Dict[str, str], schema: str, table: str, time_column: str, type: "timeseries_logicalseries_api_TimescaleType") -> None:
+        self._table = table
+        self._schema = schema
+        self._column = column
+        self._time_column = time_column
+        self._dimensions = dimensions
+        self._type = type
 
     @builtins.property
-    def requests(self) -> List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]:
-        return self._requests
+    def table(self) -> str:
+        return self._table
 
+    @builtins.property
+    def schema(self) -> str:
+        return self._schema
 
-timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__name__ = "BatchGetChannelMetadataRequest"
-timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__qualname__ = "BatchGetChannelMetadataRequest"
-timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+    @builtins.property
+    def column(self) -> str:
+        return self._column
 
+    @builtins.property
+    def time_column(self) -> str:
+        return self._time_column
 
-class timeseries_channelmetadata_api_BatchGetChannelMetadataResponse(ConjureBeanType):
+    @builtins.property
+    def dimensions(self) -> Dict[str, str]:
+        return self._dimensions
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
-        }
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_TimescaleType":
+        return self._type
 
-    __slots__: List[str] = ['_responses']
 
-    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
-        self._responses = responses
+timeseries_logicalseries_api_TimescaleDbLocator.__name__ = "TimescaleDbLocator"
+timeseries_logicalseries_api_TimescaleDbLocator.__qualname__ = "TimescaleDbLocator"
+timeseries_logicalseries_api_TimescaleDbLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-    @builtins.property
-    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
-        return self._responses
 
+class timeseries_logicalseries_api_TimescaleType(ConjureEnumType):
 
-timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__name__ = "BatchGetChannelMetadataResponse"
-timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__qualname__ = "BatchGetChannelMetadataResponse"
-timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
+    BOOLEAN = 'BOOLEAN'
+    '''BOOLEAN'''
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
 
-class timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest(ConjureBeanType):
+timeseries_logicalseries_api_TimescaleType.__name__ = "TimescaleType"
+timeseries_logicalseries_api_TimescaleType.__qualname__ = "TimescaleType"
+timeseries_logicalseries_api_TimescaleType.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_TimestreamLocator(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_UpdateChannelMetadataRequest])
+            'table': ConjureFieldDefinition('table', timeseries_logicalseries_api_TableName),
+            'dimensions': ConjureFieldDefinition('dimensions', Dict[api_TagName, api_TagValue]),
+            'measure': ConjureFieldDefinition('measure', timeseries_logicalseries_api_MeasureName),
+            'attribute': ConjureFieldDefinition('attribute', OptionalTypeWrapper[timeseries_logicalseries_api_AttributeName]),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_TimestreamType)
         }
 
-    __slots__: List[str] = ['_requests']
+    __slots__: List[str] = ['_table', '_dimensions', '_measure', '_attribute', '_type']
 
-    def __init__(self, requests: List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]) -> None:
-        self._requests = requests
+    def __init__(self, dimensions: Dict[str, str], measure: str, table: str, type: "timeseries_logicalseries_api_TimestreamType", attribute: Optional[str] = None) -> None:
+        self._table = table
+        self._dimensions = dimensions
+        self._measure = measure
+        self._attribute = attribute
+        self._type = type
 
     @builtins.property
-    def requests(self) -> List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]:
-        return self._requests
+    def table(self) -> str:
+        return self._table
 
+    @builtins.property
+    def dimensions(self) -> Dict[str, str]:
+        return self._dimensions
 
-timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__name__ = "BatchUpdateChannelMetadataRequest"
-timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__qualname__ = "BatchUpdateChannelMetadataRequest"
-timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+    @builtins.property
+    def measure(self) -> str:
+        return self._measure
+
+    @builtins.property
+    def attribute(self) -> Optional[str]:
+        """If present, will be the attribute within the measurement for multi-measures.
+        """
+        return self._attribute
 
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_TimestreamType":
+        return self._type
 
-class timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse(ConjureBeanType):
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
-        }
+timeseries_logicalseries_api_TimestreamLocator.__name__ = "TimestreamLocator"
+timeseries_logicalseries_api_TimestreamLocator.__qualname__ = "TimestreamLocator"
+timeseries_logicalseries_api_TimestreamLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-    __slots__: List[str] = ['_responses']
 
-    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
-        self._responses = responses
+class timeseries_logicalseries_api_TimestreamType(ConjureEnumType):
 
-    @builtins.property
-    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
-        return self._responses
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
 
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
-timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__name__ = "BatchUpdateChannelMetadataResponse"
-timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__qualname__ = "BatchUpdateChannelMetadataResponse"
-timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+timeseries_logicalseries_api_TimestreamType.__name__ = "TimestreamType"
+timeseries_logicalseries_api_TimestreamType.__qualname__ = "TimestreamType"
+timeseries_logicalseries_api_TimestreamType.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_channelmetadata_api_ChannelIdentifier(ConjureBeanType):
+class timeseries_logicalseries_api_UnitUpdate(ConjureUnionType):
+    """UnitUpdate is used to either set a unit, or to clear an existing unit.
+    """
+    _unit: Optional[str] = None
+    _clear_unit: Optional["api_Empty"] = None
 
     @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'channel_name': ConjureFieldDefinition('channelName', api_Channel),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid)
+            'unit': ConjureFieldDefinition('unit', api_Unit),
+            'clear_unit': ConjureFieldDefinition('clearUnit', api_Empty)
         }
 
-    __slots__: List[str] = ['_channel_name', '_data_source_rid']
+    def __init__(
+            self,
+            unit: Optional[str] = None,
+            clear_unit: Optional["api_Empty"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (unit is not None) + (clear_unit is not None) != 1:
+                raise ValueError('a union must contain a single member')
 
-    def __init__(self, channel_name: str, data_source_rid: str) -> None:
-        self._channel_name = channel_name
-        self._data_source_rid = data_source_rid
+            if unit is not None:
+                self._unit = unit
+                self._type = 'unit'
+            if clear_unit is not None:
+                self._clear_unit = clear_unit
+                self._type = 'clearUnit'
+
+        elif type_of_union == 'unit':
+            if unit is None:
+                raise ValueError('a union value must not be None')
+            self._unit = unit
+            self._type = 'unit'
+        elif type_of_union == 'clearUnit':
+            if clear_unit is None:
+                raise ValueError('a union value must not be None')
+            self._clear_unit = clear_unit
+            self._type = 'clearUnit'
 
     @builtins.property
-    def channel_name(self) -> str:
-        return self._channel_name
+    def unit(self) -> Optional[str]:
+        return self._unit
 
     @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
+    def clear_unit(self) -> Optional["api_Empty"]:
+        return self._clear_unit
 
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, timeseries_logicalseries_api_UnitUpdateVisitor):
+            raise ValueError('{} is not an instance of timeseries_logicalseries_api_UnitUpdateVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'unit' and self.unit is not None:
+            return visitor._unit(self.unit)
+        if self._type == 'clearUnit' and self.clear_unit is not None:
+            return visitor._clear_unit(self.clear_unit)
 
-timeseries_channelmetadata_api_ChannelIdentifier.__name__ = "ChannelIdentifier"
-timeseries_channelmetadata_api_ChannelIdentifier.__qualname__ = "ChannelIdentifier"
-timeseries_channelmetadata_api_ChannelIdentifier.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+timeseries_logicalseries_api_UnitUpdate.__name__ = "UnitUpdate"
+timeseries_logicalseries_api_UnitUpdate.__qualname__ = "UnitUpdate"
+timeseries_logicalseries_api_UnitUpdate.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_channelmetadata_api_ChannelMetadata(ConjureBeanType):
+class timeseries_logicalseries_api_UnitUpdateVisitor:
+
+    @abstractmethod
+    def _unit(self, unit: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _clear_unit(self, clear_unit: "api_Empty") -> Any:
+        pass
+
+
+timeseries_logicalseries_api_UnitUpdateVisitor.__name__ = "UnitUpdateVisitor"
+timeseries_logicalseries_api_UnitUpdateVisitor.__qualname__ = "UnitUpdateVisitor"
+timeseries_logicalseries_api_UnitUpdateVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_UpdateLogicalSeries(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
+            'logical_series_rid': ConjureFieldDefinition('logicalSeriesRid', api_LogicalSeriesRid),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
-            'data_type': ConjureFieldDefinition('dataType', OptionalTypeWrapper[api_SeriesDataType])
+            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate])
         }
 
-    __slots__: List[str] = ['_channel_identifier', '_description', '_unit', '_data_type']
+    __slots__: List[str] = ['_logical_series_rid', '_description', '_unit', '_unit_update']
 
-    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", data_type: Optional["api_SeriesDataType"] = None, description: Optional[str] = None, unit: Optional[str] = None) -> None:
-        self._channel_identifier = channel_identifier
+    def __init__(self, logical_series_rid: str, description: Optional[str] = None, unit: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
+        self._logical_series_rid = logical_series_rid
         self._description = description
         self._unit = unit
-        self._data_type = data_type
+        self._unit_update = unit_update
 
     @builtins.property
-    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
-        return self._channel_identifier
+    def logical_series_rid(self) -> str:
+        return self._logical_series_rid
 
     @builtins.property
     def description(self) -> Optional[str]:
@@ -93623,111 +94292,106 @@ class timeseries_channelmetadata_api_ChannelMetadata(ConjureBeanType):
         return self._unit
 
     @builtins.property
-    def data_type(self) -> Optional["api_SeriesDataType"]:
-        return self._data_type
-
-
-timeseries_channelmetadata_api_ChannelMetadata.__name__ = "ChannelMetadata"
-timeseries_channelmetadata_api_ChannelMetadata.__qualname__ = "ChannelMetadata"
-timeseries_channelmetadata_api_ChannelMetadata.__module__ = "nominal_api.timeseries_channelmetadata_api"
+    def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
+        return self._unit_update
 
 
-class timeseries_channelmetadata_api_GetChannelMetadataRequest(ConjureBeanType):
+timeseries_logicalseries_api_UpdateLogicalSeries.__name__ = "UpdateLogicalSeries"
+timeseries_logicalseries_api_UpdateLogicalSeries.__qualname__ = "UpdateLogicalSeries"
+timeseries_logicalseries_api_UpdateLogicalSeries.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier)
-        }
 
-    __slots__: List[str] = ['_channel_identifier']
+class timeseries_logicalseries_api_VisualCrossingEndpointUri(ConjureEnumType):
 
-    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier") -> None:
-        self._channel_identifier = channel_identifier
+    HISTORY = 'HISTORY'
+    '''HISTORY'''
+    TIMELINE = 'TIMELINE'
+    '''TIMELINE'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
 
-    @builtins.property
-    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
-        return self._channel_identifier
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
 
-timeseries_channelmetadata_api_GetChannelMetadataRequest.__name__ = "GetChannelMetadataRequest"
-timeseries_channelmetadata_api_GetChannelMetadataRequest.__qualname__ = "GetChannelMetadataRequest"
-timeseries_channelmetadata_api_GetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+timeseries_logicalseries_api_VisualCrossingEndpointUri.__name__ = "VisualCrossingEndpointUri"
+timeseries_logicalseries_api_VisualCrossingEndpointUri.__qualname__ = "VisualCrossingEndpointUri"
+timeseries_logicalseries_api_VisualCrossingEndpointUri.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_channelmetadata_api_UpdateChannelMetadataRequest(ConjureBeanType):
+class timeseries_logicalseries_api_VisualCrossingLocator(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate])
+            'location': ConjureFieldDefinition('location', timeseries_logicalseries_api_LocationName),
+            'endpoint': ConjureFieldDefinition('endpoint', OptionalTypeWrapper[timeseries_logicalseries_api_VisualCrossingEndpointUri]),
+            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_VisualCrossingType)
         }
 
-    __slots__: List[str] = ['_channel_identifier', '_description', '_unit_update']
+    __slots__: List[str] = ['_location', '_endpoint', '_field', '_type']
 
-    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", description: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
-        self._channel_identifier = channel_identifier
-        self._description = description
-        self._unit_update = unit_update
+    def __init__(self, field: str, location: str, type: "timeseries_logicalseries_api_VisualCrossingType", endpoint: Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"] = None) -> None:
+        self._location = location
+        self._endpoint = endpoint
+        self._field = field
+        self._type = type
 
     @builtins.property
-    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
-        return self._channel_identifier
+    def location(self) -> str:
+        """Location to fetch data from.  Can be any arbitrary string (i.e. name, abbreviation,
+zip code, lat/long, etc.) as remote endpoint performs location resolution.
+        """
+        return self._location
 
     @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
+    def endpoint(self) -> Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"]:
+        """Defaults to HISTORY.  Endpoint to fetch data from for this series.
+        """
+        return self._endpoint
 
     @builtins.property
-    def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
-        return self._unit_update
-
+    def field(self) -> str:
+        return self._field
 
-timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__name__ = "UpdateChannelMetadataRequest"
-timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__qualname__ = "UpdateChannelMetadataRequest"
-timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_VisualCrossingType":
+        return self._type
 
 
-class timeseries_logicalseries_LogicalSeriesService(Service):
-    """A logical series is a timeseries, represented by a channel name and a tag set.
-    """
+timeseries_logicalseries_api_VisualCrossingLocator.__name__ = "VisualCrossingLocator"
+timeseries_logicalseries_api_VisualCrossingLocator.__qualname__ = "VisualCrossingLocator"
+timeseries_logicalseries_api_VisualCrossingLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-    def create_logical_series(self, auth_header: str, create_logical_series: "timeseries_logicalseries_api_CreateLogicalSeries") -> "timeseries_logicalseries_api_LogicalSeries":
-        """Create a new logical series.
-        """
-        _conjure_encoder = ConjureEncoder()
 
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
+class timeseries_logicalseries_api_VisualCrossingType(ConjureEnumType):
 
-        _params: Dict[str, Any] = {
-        }
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
 
-        _path_params: Dict[str, str] = {
-        }
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
-        _json: Any = _conjure_encoder.default(create_logical_series)
 
-        _path = '/timeseries/logical-series/v1/logical-series'
-        _path = _path.format(**_path_params)
+timeseries_logicalseries_api_VisualCrossingType.__name__ = "VisualCrossingType"
+timeseries_logicalseries_api_VisualCrossingType.__qualname__ = "VisualCrossingType"
+timeseries_logicalseries_api_VisualCrossingType.__module__ = "nominal_api.timeseries_logicalseries_api"
 
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_logicalseries_api_LogicalSeries, self._return_none_for_unknown_union_types)
+class timeseries_metadata_SeriesMetadataService(Service):
+    """[INTERNAL]
+Series metadata represents the constant information about data in a series - specifically, the name, units, a
+description, and the tags. Series metadata can be used to query points from specific series depending on the tag
+value selections.
+    """
 
-    def batch_create_logical_series(self, auth_header: str, request: "timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest") -> "timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse":
-        """Batch create new logical series.
+    def batch_get(self, auth_header: str, request: "timeseries_metadata_api_BatchGetSeriesMetadataRequest") -> "timeseries_metadata_api_BatchGetSeriesMetadataResponse":
+        """Batch get series metadata by DataSourceRid.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -93745,7 +94409,7 @@ class timeseries_logicalseries_LogicalSeriesService(Service):
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/logical-series/v1/logical-series/batch-create'
+        _path = '/timeseries/archetype/v1/series-archetype/batch-get'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -93756,10 +94420,10 @@ class timeseries_logicalseries_LogicalSeriesService(Service):
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), timeseries_metadata_api_BatchGetSeriesMetadataResponse, self._return_none_for_unknown_union_types)
 
-    def batch_update_logical_series(self, auth_header: str, request: "timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest") -> "timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse":
-        """Batch update logical series descriptions and units.
+    def create(self, auth_header: str, request: "timeseries_metadata_api_CreateSeriesMetadataRequest") -> None:
+        """Create new series metadata.
         """
         _conjure_encoder = ConjureEncoder()
 
@@ -93777,7 +94441,7 @@ class timeseries_logicalseries_LogicalSeriesService(Service):
 
         _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/logical-series/v1/logical-series/batch-update'
+        _path = '/timeseries/archetype/v1/series-archetype'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -93787,16 +94451,16 @@ class timeseries_logicalseries_LogicalSeriesService(Service):
             headers=_headers,
             json=_json)
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse, self._return_none_for_unknown_union_types)
+        return
 
-    def get_logical_series(self, auth_header: str, rid: str) -> "timeseries_logicalseries_api_LogicalSeries":
-        """Get a logical series by logical series rid.
+    def batch_create(self, auth_header: str, request: "timeseries_metadata_api_BatchCreateSeriesMetadataRequest") -> None:
+        """Idempotently creates series metadata.
         """
         _conjure_encoder = ConjureEncoder()
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
+            'Content-Type': 'application/json',
             'Authorization': auth_header,
         }
 
@@ -93804,33 +94468,29 @@ class timeseries_logicalseries_LogicalSeriesService(Service):
         }
 
         _path_params: Dict[str, str] = {
-            'rid': quote(str(_conjure_encoder.default(rid)), safe=''),
         }
 
-        _json: Any = None
+        _json: Any = _conjure_encoder.default(request)
 
-        _path = '/timeseries/logical-series/v1/logical-series/{rid}'
+        _path = '/timeseries/archetype/v1/series-archetype/batch-create'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
-            'GET',
+            'POST',
             self._uri + _path,
             params=_params,
             headers=_headers,
             json=_json)
 
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), timeseries_logicalseries_api_LogicalSeries, self._return_none_for_unknown_union_types)
+        return
 
-    def resolve_batch(self, auth_header: str, request: "timeseries_logicalseries_api_BatchResolveSeriesRequest") -> "timeseries_logicalseries_api_BatchResolveSeriesResponse":
-        """Resolves groups of channels, datasources and tags into logical series rids. An error response is provided
-if the channel + datasource + tag cannot be resolved into a logical series rid.
+    def get(self, auth_header: str, rid: str) -> "timeseries_metadata_api_SeriesMetadata":
+        """Get series metadata from its series metadata rid.
         """
         _conjure_encoder = ConjureEncoder()
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
-            'Content-Type': 'application/json',
             'Authorization': auth_header,
         }
 
@@ -93838,443 +94498,256 @@ if the channel + datasource + tag cannot be resolved into a logical series rid.
         }
 
         _path_params: Dict[str, str] = {
+            'rid': quote(str(_conjure_encoder.default(rid)), safe=''),
         }
 
-        _json: Any = _conjure_encoder.default(request)
+        _json: Any = None
 
-        _path = '/timeseries/logical-series/v1/resolve'
+        _path = '/timeseries/archetype/v1/series-archetype/{rid}'
         _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(), timeseries_logicalseries_api_BatchResolveSeriesResponse, self._return_none_for_unknown_union_types)
-
-
-timeseries_logicalseries_LogicalSeriesService.__name__ = "LogicalSeriesService"
-timeseries_logicalseries_LogicalSeriesService.__qualname__ = "LogicalSeriesService"
-timeseries_logicalseries_LogicalSeriesService.__module__ = "nominal_api.timeseries_logicalseries"
-
-
-class timeseries_logicalseries_api_ApiLocator(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
-            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_ApiType)
-        }
-
-    __slots__: List[str] = ['_channel', '_tags', '_type']
-
-    def __init__(self, channel: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_ApiType") -> None:
-        self._channel = channel
-        self._tags = tags
-        self._type = type
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
-
-    @builtins.property
-    def type(self) -> "timeseries_logicalseries_api_ApiType":
-        return self._type
-
-
-timeseries_logicalseries_api_ApiLocator.__name__ = "ApiLocator"
-timeseries_logicalseries_api_ApiLocator.__qualname__ = "ApiLocator"
-timeseries_logicalseries_api_ApiLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ApiType(ConjureEnumType):
-
-    DOUBLE = 'DOUBLE'
-    '''DOUBLE'''
-    STRING = 'STRING'
-    '''STRING'''
-    INT64 = 'INT64'
-    '''INT64'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_ApiType.__name__ = "ApiType"
-timeseries_logicalseries_api_ApiType.__qualname__ = "ApiType"
-timeseries_logicalseries_api_ApiType.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'requests': ConjureFieldDefinition('requests', List[timeseries_logicalseries_api_CreateLogicalSeries])
-        }
-
-    __slots__: List[str] = ['_requests']
-
-    def __init__(self, requests: List["timeseries_logicalseries_api_CreateLogicalSeries"]) -> None:
-        self._requests = requests
-
-    @builtins.property
-    def requests(self) -> List["timeseries_logicalseries_api_CreateLogicalSeries"]:
-        return self._requests
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
 
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_metadata_api_SeriesMetadata, self._return_none_for_unknown_union_types)
 
-timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest.__name__ = "BatchCreateLogicalSeriesRequest"
-timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest.__qualname__ = "BatchCreateLogicalSeriesRequest"
-timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
+    def update_metadata(self, auth_header: str, request: "timeseries_metadata_api_UpdateSeriesMetadataRequest", rid: str) -> "timeseries_metadata_api_SeriesMetadata":
+        """Update existing series metadata. 
+Throws SeriesMetadataNotFound if the series metadata does not exist.
+        """
+        _conjure_encoder = ConjureEncoder()
 
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
 
-class timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse(ConjureBeanType):
+        _params: Dict[str, Any] = {
+        }
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'responses': ConjureFieldDefinition('responses', List[timeseries_logicalseries_api_LogicalSeries])
+        _path_params: Dict[str, str] = {
+            'rid': quote(str(_conjure_encoder.default(rid)), safe=''),
         }
 
-    __slots__: List[str] = ['_responses']
+        _json: Any = _conjure_encoder.default(request)
 
-    def __init__(self, responses: List["timeseries_logicalseries_api_LogicalSeries"]) -> None:
-        self._responses = responses
+        _path = '/timeseries/archetype/v1/series-archetype/{rid}/metadata'
+        _path = _path.format(**_path_params)
 
-    @builtins.property
-    def responses(self) -> List["timeseries_logicalseries_api_LogicalSeries"]:
-        return self._responses
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), timeseries_metadata_api_SeriesMetadata, self._return_none_for_unknown_union_types)
 
 
-timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse.__name__ = "BatchCreateLogicalSeriesResponse"
-timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse.__qualname__ = "BatchCreateLogicalSeriesResponse"
-timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_SeriesMetadataService.__name__ = "SeriesMetadataService"
+timeseries_metadata_SeriesMetadataService.__qualname__ = "SeriesMetadataService"
+timeseries_metadata_SeriesMetadataService.__module__ = "nominal_api.timeseries_metadata"
 
 
-class timeseries_logicalseries_api_BatchResolveSeriesRequest(ConjureBeanType):
+class timeseries_metadata_api_ApiLocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[timeseries_logicalseries_api_ResolveSeriesRequest])
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_ApiType)
         }
 
-    __slots__: List[str] = ['_requests']
+    __slots__: List[str] = ['_channel', '_type']
 
-    def __init__(self, requests: List["timeseries_logicalseries_api_ResolveSeriesRequest"]) -> None:
-        self._requests = requests
+    def __init__(self, channel: str, type: "timeseries_logicalseries_api_ApiType") -> None:
+        self._channel = channel
+        self._type = type
 
     @builtins.property
-    def requests(self) -> List["timeseries_logicalseries_api_ResolveSeriesRequest"]:
-        return self._requests
+    def channel(self) -> str:
+        return self._channel
 
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_ApiType":
+        return self._type
 
-timeseries_logicalseries_api_BatchResolveSeriesRequest.__name__ = "BatchResolveSeriesRequest"
-timeseries_logicalseries_api_BatchResolveSeriesRequest.__qualname__ = "BatchResolveSeriesRequest"
-timeseries_logicalseries_api_BatchResolveSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
 
+timeseries_metadata_api_ApiLocatorTemplate.__name__ = "ApiLocatorTemplate"
+timeseries_metadata_api_ApiLocatorTemplate.__qualname__ = "ApiLocatorTemplate"
+timeseries_metadata_api_ApiLocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
-class timeseries_logicalseries_api_BatchResolveSeriesResponse(ConjureBeanType):
+
+class timeseries_metadata_api_BatchCreateSeriesMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'series': ConjureFieldDefinition('series', List[timeseries_logicalseries_api_ResolveSeriesResponse])
+            'requests': ConjureFieldDefinition('requests', List[timeseries_metadata_api_CreateSeriesMetadataRequest])
         }
 
-    __slots__: List[str] = ['_series']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, series: List["timeseries_logicalseries_api_ResolveSeriesResponse"]) -> None:
-        self._series = series
+    def __init__(self, requests: List["timeseries_metadata_api_CreateSeriesMetadataRequest"]) -> None:
+        self._requests = requests
 
     @builtins.property
-    def series(self) -> List["timeseries_logicalseries_api_ResolveSeriesResponse"]:
-        return self._series
+    def requests(self) -> List["timeseries_metadata_api_CreateSeriesMetadataRequest"]:
+        return self._requests
 
 
-timeseries_logicalseries_api_BatchResolveSeriesResponse.__name__ = "BatchResolveSeriesResponse"
-timeseries_logicalseries_api_BatchResolveSeriesResponse.__qualname__ = "BatchResolveSeriesResponse"
-timeseries_logicalseries_api_BatchResolveSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_BatchCreateSeriesMetadataRequest.__name__ = "BatchCreateSeriesMetadataRequest"
+timeseries_metadata_api_BatchCreateSeriesMetadataRequest.__qualname__ = "BatchCreateSeriesMetadataRequest"
+timeseries_metadata_api_BatchCreateSeriesMetadataRequest.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest(ConjureBeanType):
+class timeseries_metadata_api_BatchGetSeriesMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[timeseries_logicalseries_api_UpdateLogicalSeries])
+            'datasources': ConjureFieldDefinition('datasources', List[api_rids_DataSourceRid])
         }
 
-    __slots__: List[str] = ['_requests']
+    __slots__: List[str] = ['_datasources']
 
-    def __init__(self, requests: List["timeseries_logicalseries_api_UpdateLogicalSeries"]) -> None:
-        self._requests = requests
+    def __init__(self, datasources: List[str]) -> None:
+        self._datasources = datasources
 
     @builtins.property
-    def requests(self) -> List["timeseries_logicalseries_api_UpdateLogicalSeries"]:
-        return self._requests
+    def datasources(self) -> List[str]:
+        return self._datasources
 
 
-timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest.__name__ = "BatchUpdateLogicalSeriesRequest"
-timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest.__qualname__ = "BatchUpdateLogicalSeriesRequest"
-timeseries_logicalseries_api_BatchUpdateLogicalSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_BatchGetSeriesMetadataRequest.__name__ = "BatchGetSeriesMetadataRequest"
+timeseries_metadata_api_BatchGetSeriesMetadataRequest.__qualname__ = "BatchGetSeriesMetadataRequest"
+timeseries_metadata_api_BatchGetSeriesMetadataRequest.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse(ConjureBeanType):
+class timeseries_metadata_api_BatchGetSeriesMetadataResponse(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'responses': ConjureFieldDefinition('responses', List[timeseries_logicalseries_api_LogicalSeries])
+            'responses': ConjureFieldDefinition('responses', Dict[api_rids_DataSourceRid, List[timeseries_metadata_api_SeriesMetadata]])
         }
 
     __slots__: List[str] = ['_responses']
 
-    def __init__(self, responses: List["timeseries_logicalseries_api_LogicalSeries"]) -> None:
+    def __init__(self, responses: Dict[str, List["timeseries_metadata_api_SeriesMetadata"]]) -> None:
         self._responses = responses
 
     @builtins.property
-    def responses(self) -> List["timeseries_logicalseries_api_LogicalSeries"]:
+    def responses(self) -> Dict[str, List["timeseries_metadata_api_SeriesMetadata"]]:
         return self._responses
 
 
-timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse.__name__ = "BatchUpdateLogicalSeriesResponse"
-timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse.__qualname__ = "BatchUpdateLogicalSeriesResponse"
-timeseries_logicalseries_api_BatchUpdateLogicalSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_BatchGetSeriesMetadataResponse.__name__ = "BatchGetSeriesMetadataResponse"
+timeseries_metadata_api_BatchGetSeriesMetadataResponse.__qualname__ = "BatchGetSeriesMetadataResponse"
+timeseries_metadata_api_BatchGetSeriesMetadataResponse.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_BigQueryLocator(ConjureBeanType):
+class timeseries_metadata_api_BigQueryLocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'value_column': ConjureFieldDefinition('valueColumn', timeseries_logicalseries_api_ColumnName),
             'time_column': ConjureFieldDefinition('timeColumn', timeseries_logicalseries_api_ColumnName),
-            'tag_values': ConjureFieldDefinition('tagValues', Dict[api_TagName, api_TagValue]),
             'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_BigQueryType)
         }
 
-    __slots__: List[str] = ['_value_column', '_time_column', '_tag_values', '_type']
+    __slots__: List[str] = ['_value_column', '_time_column', '_type']
 
-    def __init__(self, tag_values: Dict[str, str], time_column: str, type: "timeseries_logicalseries_api_BigQueryType", value_column: str) -> None:
+    def __init__(self, time_column: str, type: "timeseries_logicalseries_api_BigQueryType", value_column: str) -> None:
         self._value_column = value_column
         self._time_column = time_column
-        self._tag_values = tag_values
         self._type = type
 
     @builtins.property
     def value_column(self) -> str:
-        """The name of the column which has the values for this series
-        """
         return self._value_column
 
     @builtins.property
     def time_column(self) -> str:
-        """The name of the column which has the timestamps for this series
-        """
         return self._time_column
 
-    @builtins.property
-    def tag_values(self) -> Dict[str, str]:
-        """The mapping of columns to column values to filter on
-        """
-        return self._tag_values
-
     @builtins.property
     def type(self) -> "timeseries_logicalseries_api_BigQueryType":
         return self._type
 
 
-timeseries_logicalseries_api_BigQueryLocator.__name__ = "BigQueryLocator"
-timeseries_logicalseries_api_BigQueryLocator.__qualname__ = "BigQueryLocator"
-timeseries_logicalseries_api_BigQueryLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_BigQueryType(ConjureEnumType):
-
-    DOUBLE = 'DOUBLE'
-    '''DOUBLE'''
-    STRING = 'STRING'
-    '''STRING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_BigQueryType.__name__ = "BigQueryType"
-timeseries_logicalseries_api_BigQueryType.__qualname__ = "BigQueryType"
-timeseries_logicalseries_api_BigQueryType.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_Context(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'properties': ConjureFieldDefinition('properties', Dict[str, timeseries_logicalseries_api_ContextProperty])
-        }
-
-    __slots__: List[str] = ['_properties']
-
-    def __init__(self, properties: Dict[str, "timeseries_logicalseries_api_ContextProperty"]) -> None:
-        self._properties = properties
-
-    @builtins.property
-    def properties(self) -> Dict[str, "timeseries_logicalseries_api_ContextProperty"]:
-        return self._properties
-
-
-timeseries_logicalseries_api_Context.__name__ = "Context"
-timeseries_logicalseries_api_Context.__qualname__ = "Context"
-timeseries_logicalseries_api_Context.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ContextProperty(ConjureUnionType):
-    _value: Optional[str] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'value': ConjureFieldDefinition('value', str)
-        }
-
-    def __init__(
-            self,
-            value: Optional[str] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (value is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if value is not None:
-                self._value = value
-                self._type = 'value'
-
-        elif type_of_union == 'value':
-            if value is None:
-                raise ValueError('a union value must not be None')
-            self._value = value
-            self._type = 'value'
-
-    @builtins.property
-    def value(self) -> Optional[str]:
-        return self._value
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, timeseries_logicalseries_api_ContextPropertyVisitor):
-            raise ValueError('{} is not an instance of timeseries_logicalseries_api_ContextPropertyVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'value' and self.value is not None:
-            return visitor._value(self.value)
-
-
-timeseries_logicalseries_api_ContextProperty.__name__ = "ContextProperty"
-timeseries_logicalseries_api_ContextProperty.__qualname__ = "ContextProperty"
-timeseries_logicalseries_api_ContextProperty.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ContextPropertyVisitor:
-
-    @abstractmethod
-    def _value(self, value: str) -> Any:
-        pass
-
-
-timeseries_logicalseries_api_ContextPropertyVisitor.__name__ = "ContextPropertyVisitor"
-timeseries_logicalseries_api_ContextPropertyVisitor.__qualname__ = "ContextPropertyVisitor"
-timeseries_logicalseries_api_ContextPropertyVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_BigQueryLocatorTemplate.__name__ = "BigQueryLocatorTemplate"
+timeseries_metadata_api_BigQueryLocatorTemplate.__qualname__ = "BigQueryLocatorTemplate"
+timeseries_metadata_api_BigQueryLocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_CreateLogicalSeries(ConjureBeanType):
+class timeseries_metadata_api_CreateSeriesMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'channel': ConjureFieldDefinition('channel', api_Channel),
-            'locator': ConjureFieldDefinition('locator', timeseries_logicalseries_api_Locator),
-            'id_locator': ConjureFieldDefinition('idLocator', OptionalTypeWrapper[str]),
             'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'locator': ConjureFieldDefinition('locator', timeseries_metadata_api_LocatorTemplate),
             'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
-            'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType]),
-            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity]),
-            'series_archetype_rid': ConjureFieldDefinition('seriesArchetypeRid', OptionalTypeWrapper[api_SeriesArchetypeRid])
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
         }
 
-    __slots__: List[str] = ['_channel', '_locator', '_id_locator', '_data_source_rid', '_description', '_unit', '_series_data_type', '_granularity', '_series_archetype_rid']
+    __slots__: List[str] = ['_channel', '_data_source_rid', '_locator', '_unit', '_description', '_tags']
 
-    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_logicalseries_api_Locator", description: Optional[str] = None, granularity: Optional["api_Granularity"] = None, id_locator: Optional[str] = None, series_archetype_rid: Optional[str] = None, series_data_type: Optional["api_SeriesDataType"] = None, unit: Optional[str] = None) -> None:
+    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_metadata_api_LocatorTemplate", tags: Dict[str, str], description: Optional[str] = None, unit: Optional[str] = None) -> None:
         self._channel = channel
-        self._locator = locator
-        self._id_locator = id_locator
         self._data_source_rid = data_source_rid
-        self._description = description
+        self._locator = locator
         self._unit = unit
-        self._series_data_type = series_data_type
-        self._granularity = granularity
-        self._series_archetype_rid = series_archetype_rid
+        self._description = description
+        self._tags = tags
 
     @builtins.property
     def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def locator(self) -> "timeseries_logicalseries_api_Locator":
-        return self._locator
-
-    @builtins.property
-    def id_locator(self) -> Optional[str]:
-        """If present, will be used as the locator of the LogicalSeriesRid. If a logical series already exists
-with this id, will throw a CONFLICT.
+        """This name should be unique amongst SeriesMetadata within the data source. All series created from this
+metadata will share this name.
         """
-        return self._id_locator
+        return self._channel
 
     @builtins.property
     def data_source_rid(self) -> str:
         return self._data_source_rid
 
     @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
+    def locator(self) -> "timeseries_metadata_api_LocatorTemplate":
+        return self._locator
 
     @builtins.property
     def unit(self) -> Optional[str]:
         return self._unit
 
     @builtins.property
-    def series_data_type(self) -> Optional["api_SeriesDataType"]:
-        return self._series_data_type
-
-    @builtins.property
-    def granularity(self) -> Optional["api_Granularity"]:
-        return self._granularity
+    def description(self) -> Optional[str]:
+        return self._description
 
     @builtins.property
-    def series_archetype_rid(self) -> Optional[str]:
-        """Deprecated. Do not use.
+    def tags(self) -> Dict[str, str]:
+        """Tags specified here will take precedence over tags specified in the RunDatasource, in the case that both specify the same TagName.
         """
-        return self._series_archetype_rid
+        return self._tags
 
 
-timeseries_logicalseries_api_CreateLogicalSeries.__name__ = "CreateLogicalSeries"
-timeseries_logicalseries_api_CreateLogicalSeries.__qualname__ = "CreateLogicalSeries"
-timeseries_logicalseries_api_CreateLogicalSeries.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_CreateSeriesMetadataRequest.__name__ = "CreateSeriesMetadataRequest"
+timeseries_metadata_api_CreateSeriesMetadataRequest.__qualname__ = "CreateSeriesMetadataRequest"
+timeseries_metadata_api_CreateSeriesMetadataRequest.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_Influx1Locator(ConjureBeanType):
+class timeseries_metadata_api_Influx1LocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -94282,17 +94755,15 @@ class timeseries_logicalseries_api_Influx1Locator(ConjureBeanType):
             'database': ConjureFieldDefinition('database', timeseries_logicalseries_api_DatabaseName),
             'measurement': ConjureFieldDefinition('measurement', timeseries_logicalseries_api_MeasurementName),
             'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
             'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_InfluxType)
         }
 
-    __slots__: List[str] = ['_database', '_measurement', '_field', '_tags', '_type']
+    __slots__: List[str] = ['_database', '_measurement', '_field', '_type']
 
-    def __init__(self, database: str, field: str, measurement: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_InfluxType") -> None:
+    def __init__(self, database: str, field: str, measurement: str, type: "timeseries_logicalseries_api_InfluxType") -> None:
         self._database = database
         self._measurement = measurement
         self._field = field
-        self._tags = tags
         self._type = type
 
     @builtins.property
@@ -94307,41 +94778,35 @@ class timeseries_logicalseries_api_Influx1Locator(ConjureBeanType):
     def field(self) -> str:
         return self._field
 
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
-
     @builtins.property
     def type(self) -> "timeseries_logicalseries_api_InfluxType":
         return self._type
 
 
-timeseries_logicalseries_api_Influx1Locator.__name__ = "Influx1Locator"
-timeseries_logicalseries_api_Influx1Locator.__qualname__ = "Influx1Locator"
-timeseries_logicalseries_api_Influx1Locator.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_Influx1LocatorTemplate.__name__ = "Influx1LocatorTemplate"
+timeseries_metadata_api_Influx1LocatorTemplate.__qualname__ = "Influx1LocatorTemplate"
+timeseries_metadata_api_Influx1LocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_Influx2Locator(ConjureBeanType):
+class timeseries_metadata_api_Influx2LocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'bucket': ConjureFieldDefinition('bucket', timeseries_logicalseries_api_BucketName),
             'measurement': ConjureFieldDefinition('measurement', timeseries_logicalseries_api_MeasurementName),
-            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
             'value_column': ConjureFieldDefinition('valueColumn', OptionalTypeWrapper[str]),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
             'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_InfluxType)
         }
 
-    __slots__: List[str] = ['_bucket', '_measurement', '_field', '_value_column', '_tags', '_type']
+    __slots__: List[str] = ['_bucket', '_measurement', '_value_column', '_field', '_type']
 
-    def __init__(self, bucket: str, field: str, measurement: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_InfluxType", value_column: Optional[str] = None) -> None:
+    def __init__(self, bucket: str, field: str, measurement: str, type: "timeseries_logicalseries_api_InfluxType", value_column: Optional[str] = None) -> None:
         self._bucket = bucket
         self._measurement = measurement
-        self._field = field
         self._value_column = value_column
-        self._tags = tags
+        self._field = field
         self._type = type
 
     @builtins.property
@@ -94352,10 +94817,6 @@ class timeseries_logicalseries_api_Influx2Locator(ConjureBeanType):
     def measurement(self) -> str:
         return self._measurement
 
-    @builtins.property
-    def field(self) -> str:
-        return self._field
-
     @builtins.property
     def value_column(self) -> Optional[str]:
         """If omitted, defaults to `_value`. Can be used to extract tag values.
@@ -94363,494 +94824,319 @@ class timeseries_logicalseries_api_Influx2Locator(ConjureBeanType):
         return self._value_column
 
     @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
+    def field(self) -> str:
+        return self._field
 
     @builtins.property
     def type(self) -> "timeseries_logicalseries_api_InfluxType":
         return self._type
 
 
-timeseries_logicalseries_api_Influx2Locator.__name__ = "Influx2Locator"
-timeseries_logicalseries_api_Influx2Locator.__qualname__ = "Influx2Locator"
-timeseries_logicalseries_api_Influx2Locator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_InfluxType(ConjureEnumType):
-
-    BOOLEAN = 'BOOLEAN'
-    '''BOOLEAN'''
-    NUMERIC = 'NUMERIC'
-    '''NUMERIC'''
-    STRING = 'STRING'
-    '''STRING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_InfluxType.__name__ = "InfluxType"
-timeseries_logicalseries_api_InfluxType.__qualname__ = "InfluxType"
-timeseries_logicalseries_api_InfluxType.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_Influx2LocatorTemplate.__name__ = "Influx2LocatorTemplate"
+timeseries_metadata_api_Influx2LocatorTemplate.__qualname__ = "Influx2LocatorTemplate"
+timeseries_metadata_api_Influx2LocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_Locator(ConjureUnionType):
-    _timescale_db_locator: Optional["timeseries_logicalseries_api_TimescaleDbLocator"] = None
-    _influx_locator: Optional["timeseries_logicalseries_api_Influx2Locator"] = None
-    _influx1_locator: Optional["timeseries_logicalseries_api_Influx1Locator"] = None
-    _nominal_locator: Optional["timeseries_logicalseries_api_NominalLocator"] = None
-    _timestream_locator: Optional["timeseries_logicalseries_api_TimestreamLocator"] = None
-    _visual_crossing_locator: Optional["timeseries_logicalseries_api_VisualCrossingLocator"] = None
-    _big_query_locator: Optional["timeseries_logicalseries_api_BigQueryLocator"] = None
-    _api_locator: Optional["timeseries_logicalseries_api_ApiLocator"] = None
+class timeseries_metadata_api_LocatorTemplate(ConjureUnionType):
+    _timescale_db: Optional["timeseries_metadata_api_TimescaleDbLocatorTemplate"] = None
+    _influx: Optional["timeseries_metadata_api_Influx2LocatorTemplate"] = None
+    _influx1: Optional["timeseries_metadata_api_Influx1LocatorTemplate"] = None
+    _nominal: Optional["timeseries_metadata_api_NominalLocatorTemplate"] = None
+    _timestream: Optional["timeseries_metadata_api_TimestreamLocatorTemplate"] = None
+    _visual_crossing: Optional["timeseries_metadata_api_VisualCrossingLocatorTemplate"] = None
+    _big_query: Optional["timeseries_metadata_api_BigQueryLocatorTemplate"] = None
+    _api: Optional["timeseries_metadata_api_ApiLocatorTemplate"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'timescale_db_locator': ConjureFieldDefinition('timescaleDbLocator', timeseries_logicalseries_api_TimescaleDbLocator),
-            'influx_locator': ConjureFieldDefinition('influxLocator', timeseries_logicalseries_api_Influx2Locator),
-            'influx1_locator': ConjureFieldDefinition('influx1Locator', timeseries_logicalseries_api_Influx1Locator),
-            'nominal_locator': ConjureFieldDefinition('nominalLocator', timeseries_logicalseries_api_NominalLocator),
-            'timestream_locator': ConjureFieldDefinition('timestreamLocator', timeseries_logicalseries_api_TimestreamLocator),
-            'visual_crossing_locator': ConjureFieldDefinition('visualCrossingLocator', timeseries_logicalseries_api_VisualCrossingLocator),
-            'big_query_locator': ConjureFieldDefinition('bigQueryLocator', timeseries_logicalseries_api_BigQueryLocator),
-            'api_locator': ConjureFieldDefinition('apiLocator', timeseries_logicalseries_api_ApiLocator)
+            'timescale_db': ConjureFieldDefinition('timescaleDb', timeseries_metadata_api_TimescaleDbLocatorTemplate),
+            'influx': ConjureFieldDefinition('influx', timeseries_metadata_api_Influx2LocatorTemplate),
+            'influx1': ConjureFieldDefinition('influx1', timeseries_metadata_api_Influx1LocatorTemplate),
+            'nominal': ConjureFieldDefinition('nominal', timeseries_metadata_api_NominalLocatorTemplate),
+            'timestream': ConjureFieldDefinition('timestream', timeseries_metadata_api_TimestreamLocatorTemplate),
+            'visual_crossing': ConjureFieldDefinition('visualCrossing', timeseries_metadata_api_VisualCrossingLocatorTemplate),
+            'big_query': ConjureFieldDefinition('bigQuery', timeseries_metadata_api_BigQueryLocatorTemplate),
+            'api': ConjureFieldDefinition('api', timeseries_metadata_api_ApiLocatorTemplate)
         }
 
     def __init__(
             self,
-            timescale_db_locator: Optional["timeseries_logicalseries_api_TimescaleDbLocator"] = None,
-            influx_locator: Optional["timeseries_logicalseries_api_Influx2Locator"] = None,
-            influx1_locator: Optional["timeseries_logicalseries_api_Influx1Locator"] = None,
-            nominal_locator: Optional["timeseries_logicalseries_api_NominalLocator"] = None,
-            timestream_locator: Optional["timeseries_logicalseries_api_TimestreamLocator"] = None,
-            visual_crossing_locator: Optional["timeseries_logicalseries_api_VisualCrossingLocator"] = None,
-            big_query_locator: Optional["timeseries_logicalseries_api_BigQueryLocator"] = None,
-            api_locator: Optional["timeseries_logicalseries_api_ApiLocator"] = None,
+            timescale_db: Optional["timeseries_metadata_api_TimescaleDbLocatorTemplate"] = None,
+            influx: Optional["timeseries_metadata_api_Influx2LocatorTemplate"] = None,
+            influx1: Optional["timeseries_metadata_api_Influx1LocatorTemplate"] = None,
+            nominal: Optional["timeseries_metadata_api_NominalLocatorTemplate"] = None,
+            timestream: Optional["timeseries_metadata_api_TimestreamLocatorTemplate"] = None,
+            visual_crossing: Optional["timeseries_metadata_api_VisualCrossingLocatorTemplate"] = None,
+            big_query: Optional["timeseries_metadata_api_BigQueryLocatorTemplate"] = None,
+            api: Optional["timeseries_metadata_api_ApiLocatorTemplate"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (timescale_db_locator is not None) + (influx_locator is not None) + (influx1_locator is not None) + (nominal_locator is not None) + (timestream_locator is not None) + (visual_crossing_locator is not None) + (big_query_locator is not None) + (api_locator is not None) != 1:
+            if (timescale_db is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) + (api is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if timescale_db_locator is not None:
-                self._timescale_db_locator = timescale_db_locator
-                self._type = 'timescaleDbLocator'
-            if influx_locator is not None:
-                self._influx_locator = influx_locator
-                self._type = 'influxLocator'
-            if influx1_locator is not None:
-                self._influx1_locator = influx1_locator
-                self._type = 'influx1Locator'
-            if nominal_locator is not None:
-                self._nominal_locator = nominal_locator
-                self._type = 'nominalLocator'
-            if timestream_locator is not None:
-                self._timestream_locator = timestream_locator
-                self._type = 'timestreamLocator'
-            if visual_crossing_locator is not None:
-                self._visual_crossing_locator = visual_crossing_locator
-                self._type = 'visualCrossingLocator'
-            if big_query_locator is not None:
-                self._big_query_locator = big_query_locator
-                self._type = 'bigQueryLocator'
-            if api_locator is not None:
-                self._api_locator = api_locator
-                self._type = 'apiLocator'
+            if timescale_db is not None:
+                self._timescale_db = timescale_db
+                self._type = 'timescaleDb'
+            if influx is not None:
+                self._influx = influx
+                self._type = 'influx'
+            if influx1 is not None:
+                self._influx1 = influx1
+                self._type = 'influx1'
+            if nominal is not None:
+                self._nominal = nominal
+                self._type = 'nominal'
+            if timestream is not None:
+                self._timestream = timestream
+                self._type = 'timestream'
+            if visual_crossing is not None:
+                self._visual_crossing = visual_crossing
+                self._type = 'visualCrossing'
+            if big_query is not None:
+                self._big_query = big_query
+                self._type = 'bigQuery'
+            if api is not None:
+                self._api = api
+                self._type = 'api'
 
-        elif type_of_union == 'timescaleDbLocator':
-            if timescale_db_locator is None:
+        elif type_of_union == 'timescaleDb':
+            if timescale_db is None:
                 raise ValueError('a union value must not be None')
-            self._timescale_db_locator = timescale_db_locator
-            self._type = 'timescaleDbLocator'
-        elif type_of_union == 'influxLocator':
-            if influx_locator is None:
+            self._timescale_db = timescale_db
+            self._type = 'timescaleDb'
+        elif type_of_union == 'influx':
+            if influx is None:
                 raise ValueError('a union value must not be None')
-            self._influx_locator = influx_locator
-            self._type = 'influxLocator'
-        elif type_of_union == 'influx1Locator':
-            if influx1_locator is None:
+            self._influx = influx
+            self._type = 'influx'
+        elif type_of_union == 'influx1':
+            if influx1 is None:
                 raise ValueError('a union value must not be None')
-            self._influx1_locator = influx1_locator
-            self._type = 'influx1Locator'
-        elif type_of_union == 'nominalLocator':
-            if nominal_locator is None:
+            self._influx1 = influx1
+            self._type = 'influx1'
+        elif type_of_union == 'nominal':
+            if nominal is None:
                 raise ValueError('a union value must not be None')
-            self._nominal_locator = nominal_locator
-            self._type = 'nominalLocator'
-        elif type_of_union == 'timestreamLocator':
-            if timestream_locator is None:
+            self._nominal = nominal
+            self._type = 'nominal'
+        elif type_of_union == 'timestream':
+            if timestream is None:
                 raise ValueError('a union value must not be None')
-            self._timestream_locator = timestream_locator
-            self._type = 'timestreamLocator'
-        elif type_of_union == 'visualCrossingLocator':
-            if visual_crossing_locator is None:
+            self._timestream = timestream
+            self._type = 'timestream'
+        elif type_of_union == 'visualCrossing':
+            if visual_crossing is None:
                 raise ValueError('a union value must not be None')
-            self._visual_crossing_locator = visual_crossing_locator
-            self._type = 'visualCrossingLocator'
-        elif type_of_union == 'bigQueryLocator':
-            if big_query_locator is None:
+            self._visual_crossing = visual_crossing
+            self._type = 'visualCrossing'
+        elif type_of_union == 'bigQuery':
+            if big_query is None:
                 raise ValueError('a union value must not be None')
-            self._big_query_locator = big_query_locator
-            self._type = 'bigQueryLocator'
-        elif type_of_union == 'apiLocator':
-            if api_locator is None:
+            self._big_query = big_query
+            self._type = 'bigQuery'
+        elif type_of_union == 'api':
+            if api is None:
                 raise ValueError('a union value must not be None')
-            self._api_locator = api_locator
-            self._type = 'apiLocator'
-
-    @builtins.property
-    def timescale_db_locator(self) -> Optional["timeseries_logicalseries_api_TimescaleDbLocator"]:
-        return self._timescale_db_locator
-
-    @builtins.property
-    def influx_locator(self) -> Optional["timeseries_logicalseries_api_Influx2Locator"]:
-        return self._influx_locator
+            self._api = api
+            self._type = 'api'
 
     @builtins.property
-    def influx1_locator(self) -> Optional["timeseries_logicalseries_api_Influx1Locator"]:
-        return self._influx1_locator
+    def timescale_db(self) -> Optional["timeseries_metadata_api_TimescaleDbLocatorTemplate"]:
+        return self._timescale_db
 
     @builtins.property
-    def nominal_locator(self) -> Optional["timeseries_logicalseries_api_NominalLocator"]:
-        return self._nominal_locator
+    def influx(self) -> Optional["timeseries_metadata_api_Influx2LocatorTemplate"]:
+        return self._influx
 
     @builtins.property
-    def timestream_locator(self) -> Optional["timeseries_logicalseries_api_TimestreamLocator"]:
-        return self._timestream_locator
+    def influx1(self) -> Optional["timeseries_metadata_api_Influx1LocatorTemplate"]:
+        return self._influx1
 
     @builtins.property
-    def visual_crossing_locator(self) -> Optional["timeseries_logicalseries_api_VisualCrossingLocator"]:
-        return self._visual_crossing_locator
+    def nominal(self) -> Optional["timeseries_metadata_api_NominalLocatorTemplate"]:
+        return self._nominal
 
     @builtins.property
-    def big_query_locator(self) -> Optional["timeseries_logicalseries_api_BigQueryLocator"]:
-        return self._big_query_locator
+    def timestream(self) -> Optional["timeseries_metadata_api_TimestreamLocatorTemplate"]:
+        return self._timestream
 
     @builtins.property
-    def api_locator(self) -> Optional["timeseries_logicalseries_api_ApiLocator"]:
-        return self._api_locator
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, timeseries_logicalseries_api_LocatorVisitor):
-            raise ValueError('{} is not an instance of timeseries_logicalseries_api_LocatorVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'timescaleDbLocator' and self.timescale_db_locator is not None:
-            return visitor._timescale_db_locator(self.timescale_db_locator)
-        if self._type == 'influxLocator' and self.influx_locator is not None:
-            return visitor._influx_locator(self.influx_locator)
-        if self._type == 'influx1Locator' and self.influx1_locator is not None:
-            return visitor._influx1_locator(self.influx1_locator)
-        if self._type == 'nominalLocator' and self.nominal_locator is not None:
-            return visitor._nominal_locator(self.nominal_locator)
-        if self._type == 'timestreamLocator' and self.timestream_locator is not None:
-            return visitor._timestream_locator(self.timestream_locator)
-        if self._type == 'visualCrossingLocator' and self.visual_crossing_locator is not None:
-            return visitor._visual_crossing_locator(self.visual_crossing_locator)
-        if self._type == 'bigQueryLocator' and self.big_query_locator is not None:
-            return visitor._big_query_locator(self.big_query_locator)
-        if self._type == 'apiLocator' and self.api_locator is not None:
-            return visitor._api_locator(self.api_locator)
+    def visual_crossing(self) -> Optional["timeseries_metadata_api_VisualCrossingLocatorTemplate"]:
+        return self._visual_crossing
 
+    @builtins.property
+    def big_query(self) -> Optional["timeseries_metadata_api_BigQueryLocatorTemplate"]:
+        return self._big_query
 
-timeseries_logicalseries_api_Locator.__name__ = "Locator"
-timeseries_logicalseries_api_Locator.__qualname__ = "Locator"
-timeseries_logicalseries_api_Locator.__module__ = "nominal_api.timeseries_logicalseries_api"
+    @builtins.property
+    def api(self) -> Optional["timeseries_metadata_api_ApiLocatorTemplate"]:
+        return self._api
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, timeseries_metadata_api_LocatorTemplateVisitor):
+            raise ValueError('{} is not an instance of timeseries_metadata_api_LocatorTemplateVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'timescaleDb' and self.timescale_db is not None:
+            return visitor._timescale_db(self.timescale_db)
+        if self._type == 'influx' and self.influx is not None:
+            return visitor._influx(self.influx)
+        if self._type == 'influx1' and self.influx1 is not None:
+            return visitor._influx1(self.influx1)
+        if self._type == 'nominal' and self.nominal is not None:
+            return visitor._nominal(self.nominal)
+        if self._type == 'timestream' and self.timestream is not None:
+            return visitor._timestream(self.timestream)
+        if self._type == 'visualCrossing' and self.visual_crossing is not None:
+            return visitor._visual_crossing(self.visual_crossing)
+        if self._type == 'bigQuery' and self.big_query is not None:
+            return visitor._big_query(self.big_query)
+        if self._type == 'api' and self.api is not None:
+            return visitor._api(self.api)
 
 
-class timeseries_logicalseries_api_LocatorVisitor:
+timeseries_metadata_api_LocatorTemplate.__name__ = "LocatorTemplate"
+timeseries_metadata_api_LocatorTemplate.__qualname__ = "LocatorTemplate"
+timeseries_metadata_api_LocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
+
+
+class timeseries_metadata_api_LocatorTemplateVisitor:
 
     @abstractmethod
-    def _timescale_db_locator(self, timescale_db_locator: "timeseries_logicalseries_api_TimescaleDbLocator") -> Any:
+    def _timescale_db(self, timescale_db: "timeseries_metadata_api_TimescaleDbLocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _influx_locator(self, influx_locator: "timeseries_logicalseries_api_Influx2Locator") -> Any:
+    def _influx(self, influx: "timeseries_metadata_api_Influx2LocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _influx1_locator(self, influx1_locator: "timeseries_logicalseries_api_Influx1Locator") -> Any:
+    def _influx1(self, influx1: "timeseries_metadata_api_Influx1LocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _nominal_locator(self, nominal_locator: "timeseries_logicalseries_api_NominalLocator") -> Any:
+    def _nominal(self, nominal: "timeseries_metadata_api_NominalLocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _timestream_locator(self, timestream_locator: "timeseries_logicalseries_api_TimestreamLocator") -> Any:
+    def _timestream(self, timestream: "timeseries_metadata_api_TimestreamLocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _visual_crossing_locator(self, visual_crossing_locator: "timeseries_logicalseries_api_VisualCrossingLocator") -> Any:
+    def _visual_crossing(self, visual_crossing: "timeseries_metadata_api_VisualCrossingLocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _big_query_locator(self, big_query_locator: "timeseries_logicalseries_api_BigQueryLocator") -> Any:
+    def _big_query(self, big_query: "timeseries_metadata_api_BigQueryLocatorTemplate") -> Any:
         pass
 
     @abstractmethod
-    def _api_locator(self, api_locator: "timeseries_logicalseries_api_ApiLocator") -> Any:
+    def _api(self, api: "timeseries_metadata_api_ApiLocatorTemplate") -> Any:
         pass
 
 
-timeseries_logicalseries_api_LocatorVisitor.__name__ = "LocatorVisitor"
-timeseries_logicalseries_api_LocatorVisitor.__qualname__ = "LocatorVisitor"
-timeseries_logicalseries_api_LocatorVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_LocatorTemplateVisitor.__name__ = "LocatorTemplateVisitor"
+timeseries_metadata_api_LocatorTemplateVisitor.__qualname__ = "LocatorTemplateVisitor"
+timeseries_metadata_api_LocatorTemplateVisitor.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_LogicalSeries(ConjureBeanType):
+class timeseries_metadata_api_NominalLocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'rid': ConjureFieldDefinition('rid', api_LogicalSeriesRid),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
-            'locator': ConjureFieldDefinition('locator', timeseries_logicalseries_api_Locator),
-            'time_locator': ConjureFieldDefinition('timeLocator', OptionalTypeWrapper[timeseries_logicalseries_api_Locator]),
             'channel': ConjureFieldDefinition('channel', api_Channel),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
-            'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType]),
-            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity])
+            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType)
         }
 
-    __slots__: List[str] = ['_rid', '_data_source_rid', '_locator', '_time_locator', '_channel', '_description', '_unit', '_series_data_type', '_granularity']
+    __slots__: List[str] = ['_channel', '_type']
 
-    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_logicalseries_api_Locator", rid: str, description: Optional[str] = None, granularity: Optional["api_Granularity"] = None, series_data_type: Optional["api_SeriesDataType"] = None, time_locator: Optional["timeseries_logicalseries_api_Locator"] = None, unit: Optional[str] = None) -> None:
-        self._rid = rid
-        self._data_source_rid = data_source_rid
-        self._locator = locator
-        self._time_locator = time_locator
+    def __init__(self, channel: str, type: "storage_series_api_NominalDataType") -> None:
         self._channel = channel
-        self._description = description
-        self._unit = unit
-        self._series_data_type = series_data_type
-        self._granularity = granularity
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
-
-    @builtins.property
-    def locator(self) -> "timeseries_logicalseries_api_Locator":
-        return self._locator
-
-    @builtins.property
-    def time_locator(self) -> Optional["timeseries_logicalseries_api_Locator"]:
-        """Only required to be present for legacy CSVs.
-        """
-        return self._time_locator
+        self._type = type
 
     @builtins.property
     def channel(self) -> str:
         return self._channel
 
     @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
-
-    @builtins.property
-    def unit(self) -> Optional[str]:
-        return self._unit
-
-    @builtins.property
-    def series_data_type(self) -> Optional["api_SeriesDataType"]:
-        return self._series_data_type
-
-    @builtins.property
-    def granularity(self) -> Optional["api_Granularity"]:
-        """Time granularity of the series. If omitted, defaults to nanoseconds.
-        """
-        return self._granularity
+    def type(self) -> "storage_series_api_NominalDataType":
+        return self._type
 
 
-timeseries_logicalseries_api_LogicalSeries.__name__ = "LogicalSeries"
-timeseries_logicalseries_api_LogicalSeries.__qualname__ = "LogicalSeries"
-timeseries_logicalseries_api_LogicalSeries.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_NominalLocatorTemplate.__name__ = "NominalLocatorTemplate"
+timeseries_metadata_api_NominalLocatorTemplate.__qualname__ = "NominalLocatorTemplate"
+timeseries_metadata_api_NominalLocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_NominalLocator(ConjureBeanType):
+class timeseries_metadata_api_SeriesMetadata(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'rid': ConjureFieldDefinition('rid', api_SeriesMetadataRid),
             'channel': ConjureFieldDefinition('channel', api_Channel),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
+            'locator': ConjureFieldDefinition('locator', timeseries_metadata_api_LocatorTemplate),
+            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
-            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType)
+            'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType])
         }
 
-    __slots__: List[str] = ['_channel', '_tags', '_type']
+    __slots__: List[str] = ['_rid', '_channel', '_data_source_rid', '_locator', '_unit', '_description', '_tags', '_series_data_type']
 
-    def __init__(self, channel: str, tags: Dict[str, str], type: "storage_series_api_NominalDataType") -> None:
+    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_metadata_api_LocatorTemplate", rid: str, tags: Dict[str, str], description: Optional[str] = None, series_data_type: Optional["api_SeriesDataType"] = None, unit: Optional[str] = None) -> None:
+        self._rid = rid
         self._channel = channel
+        self._data_source_rid = data_source_rid
+        self._locator = locator
+        self._unit = unit
+        self._description = description
         self._tags = tags
-        self._type = type
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
+        self._series_data_type = series_data_type
 
     @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
+    def rid(self) -> str:
+        return self._rid
 
     @builtins.property
-    def type(self) -> "storage_series_api_NominalDataType":
-        return self._type
-
-
-timeseries_logicalseries_api_NominalLocator.__name__ = "NominalLocator"
-timeseries_logicalseries_api_NominalLocator.__qualname__ = "NominalLocator"
-timeseries_logicalseries_api_NominalLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ResolveSeriesError(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'message': ConjureFieldDefinition('message', str),
-            'args': ConjureFieldDefinition('args', Dict[str, str])
-        }
-
-    __slots__: List[str] = ['_message', '_args']
-
-    def __init__(self, args: Dict[str, str], message: str) -> None:
-        self._message = message
-        self._args = args
+    def channel(self) -> str:
+        return self._channel
 
     @builtins.property
-    def message(self) -> str:
-        return self._message
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
 
     @builtins.property
-    def args(self) -> Dict[str, str]:
-        return self._args
-
-
-timeseries_logicalseries_api_ResolveSeriesError.__name__ = "ResolveSeriesError"
-timeseries_logicalseries_api_ResolveSeriesError.__qualname__ = "ResolveSeriesError"
-timeseries_logicalseries_api_ResolveSeriesError.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ResolveSeriesRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'name': ConjureFieldDefinition('name', api_Channel),
-            'datasource': ConjureFieldDefinition('datasource', api_rids_DataSourceRid),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_name', '_datasource', '_tags']
-
-    def __init__(self, datasource: str, name: str, tags: Dict[str, str]) -> None:
-        self._name = name
-        self._datasource = datasource
-        self._tags = tags
+    def locator(self) -> "timeseries_metadata_api_LocatorTemplate":
+        return self._locator
 
     @builtins.property
-    def name(self) -> str:
-        return self._name
+    def unit(self) -> Optional[str]:
+        return self._unit
 
     @builtins.property
-    def datasource(self) -> str:
-        return self._datasource
+    def description(self) -> Optional[str]:
+        return self._description
 
     @builtins.property
     def tags(self) -> Dict[str, str]:
+        """Tags specified here will take precedence over tags specified in the RunDatasource, in the case that both specify the same TagName.
+        """
         return self._tags
 
-
-timeseries_logicalseries_api_ResolveSeriesRequest.__name__ = "ResolveSeriesRequest"
-timeseries_logicalseries_api_ResolveSeriesRequest.__qualname__ = "ResolveSeriesRequest"
-timeseries_logicalseries_api_ResolveSeriesRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ResolveSeriesResponse(ConjureUnionType):
-    _rid: Optional[str] = None
-    _error: Optional["timeseries_logicalseries_api_ResolveSeriesError"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rid': ConjureFieldDefinition('rid', api_LogicalSeriesRid),
-            'error': ConjureFieldDefinition('error', timeseries_logicalseries_api_ResolveSeriesError)
-        }
-
-    def __init__(
-            self,
-            rid: Optional[str] = None,
-            error: Optional["timeseries_logicalseries_api_ResolveSeriesError"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (rid is not None) + (error is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if rid is not None:
-                self._rid = rid
-                self._type = 'rid'
-            if error is not None:
-                self._error = error
-                self._type = 'error'
-
-        elif type_of_union == 'rid':
-            if rid is None:
-                raise ValueError('a union value must not be None')
-            self._rid = rid
-            self._type = 'rid'
-        elif type_of_union == 'error':
-            if error is None:
-                raise ValueError('a union value must not be None')
-            self._error = error
-            self._type = 'error'
-
-    @builtins.property
-    def rid(self) -> Optional[str]:
-        return self._rid
-
     @builtins.property
-    def error(self) -> Optional["timeseries_logicalseries_api_ResolveSeriesError"]:
-        return self._error
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, timeseries_logicalseries_api_ResolveSeriesResponseVisitor):
-            raise ValueError('{} is not an instance of timeseries_logicalseries_api_ResolveSeriesResponseVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'rid' and self.rid is not None:
-            return visitor._rid(self.rid)
-        if self._type == 'error' and self.error is not None:
-            return visitor._error(self.error)
-
-
-timeseries_logicalseries_api_ResolveSeriesResponse.__name__ = "ResolveSeriesResponse"
-timeseries_logicalseries_api_ResolveSeriesResponse.__qualname__ = "ResolveSeriesResponse"
-timeseries_logicalseries_api_ResolveSeriesResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_ResolveSeriesResponseVisitor:
-
-    @abstractmethod
-    def _rid(self, rid: str) -> Any:
-        pass
-
-    @abstractmethod
-    def _error(self, error: "timeseries_logicalseries_api_ResolveSeriesError") -> Any:
-        pass
+    def series_data_type(self) -> Optional["api_SeriesDataType"]:
+        return self._series_data_type
 
 
-timeseries_logicalseries_api_ResolveSeriesResponseVisitor.__name__ = "ResolveSeriesResponseVisitor"
-timeseries_logicalseries_api_ResolveSeriesResponseVisitor.__qualname__ = "ResolveSeriesResponseVisitor"
-timeseries_logicalseries_api_ResolveSeriesResponseVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_SeriesMetadata.__name__ = "SeriesMetadata"
+timeseries_metadata_api_SeriesMetadata.__qualname__ = "SeriesMetadata"
+timeseries_metadata_api_SeriesMetadata.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_TimescaleDbLocator(ConjureBeanType):
+class timeseries_metadata_api_TimescaleDbLocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -94859,18 +95145,16 @@ class timeseries_logicalseries_api_TimescaleDbLocator(ConjureBeanType):
             'schema': ConjureFieldDefinition('schema', timeseries_logicalseries_api_SchemaName),
             'column': ConjureFieldDefinition('column', timeseries_logicalseries_api_ColumnName),
             'time_column': ConjureFieldDefinition('timeColumn', timeseries_logicalseries_api_ColumnName),
-            'dimensions': ConjureFieldDefinition('dimensions', Dict[api_TagName, api_TagValue]),
             'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_TimescaleType)
         }
 
-    __slots__: List[str] = ['_table', '_schema', '_column', '_time_column', '_dimensions', '_type']
+    __slots__: List[str] = ['_table', '_schema', '_column', '_time_column', '_type']
 
-    def __init__(self, column: str, dimensions: Dict[str, str], schema: str, table: str, time_column: str, type: "timeseries_logicalseries_api_TimescaleType") -> None:
+    def __init__(self, column: str, schema: str, table: str, time_column: str, type: "timeseries_logicalseries_api_TimescaleType") -> None:
         self._table = table
         self._schema = schema
         self._column = column
         self._time_column = time_column
-        self._dimensions = dimensions
         self._type = type
 
     @builtins.property
@@ -94889,57 +95173,31 @@ class timeseries_logicalseries_api_TimescaleDbLocator(ConjureBeanType):
     def time_column(self) -> str:
         return self._time_column
 
-    @builtins.property
-    def dimensions(self) -> Dict[str, str]:
-        return self._dimensions
-
     @builtins.property
     def type(self) -> "timeseries_logicalseries_api_TimescaleType":
         return self._type
 
 
-timeseries_logicalseries_api_TimescaleDbLocator.__name__ = "TimescaleDbLocator"
-timeseries_logicalseries_api_TimescaleDbLocator.__qualname__ = "TimescaleDbLocator"
-timeseries_logicalseries_api_TimescaleDbLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_TimescaleType(ConjureEnumType):
-
-    BOOLEAN = 'BOOLEAN'
-    '''BOOLEAN'''
-    DOUBLE = 'DOUBLE'
-    '''DOUBLE'''
-    STRING = 'STRING'
-    '''STRING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_TimescaleType.__name__ = "TimescaleType"
-timeseries_logicalseries_api_TimescaleType.__qualname__ = "TimescaleType"
-timeseries_logicalseries_api_TimescaleType.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_TimescaleDbLocatorTemplate.__name__ = "TimescaleDbLocatorTemplate"
+timeseries_metadata_api_TimescaleDbLocatorTemplate.__qualname__ = "TimescaleDbLocatorTemplate"
+timeseries_metadata_api_TimescaleDbLocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_TimestreamLocator(ConjureBeanType):
+class timeseries_metadata_api_TimestreamLocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'table': ConjureFieldDefinition('table', timeseries_logicalseries_api_TableName),
-            'dimensions': ConjureFieldDefinition('dimensions', Dict[api_TagName, api_TagValue]),
             'measure': ConjureFieldDefinition('measure', timeseries_logicalseries_api_MeasureName),
             'attribute': ConjureFieldDefinition('attribute', OptionalTypeWrapper[timeseries_logicalseries_api_AttributeName]),
             'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_TimestreamType)
         }
 
-    __slots__: List[str] = ['_table', '_dimensions', '_measure', '_attribute', '_type']
+    __slots__: List[str] = ['_table', '_measure', '_attribute', '_type']
 
-    def __init__(self, dimensions: Dict[str, str], measure: str, table: str, type: "timeseries_logicalseries_api_TimestreamType", attribute: Optional[str] = None) -> None:
+    def __init__(self, measure: str, table: str, type: "timeseries_logicalseries_api_TimestreamType", attribute: Optional[str] = None) -> None:
         self._table = table
-        self._dimensions = dimensions
         self._measure = measure
         self._attribute = attribute
         self._type = type
@@ -94948,18 +95206,12 @@ class timeseries_logicalseries_api_TimestreamLocator(ConjureBeanType):
     def table(self) -> str:
         return self._table
 
-    @builtins.property
-    def dimensions(self) -> Dict[str, str]:
-        return self._dimensions
-
     @builtins.property
     def measure(self) -> str:
         return self._measure
 
     @builtins.property
     def attribute(self) -> Optional[str]:
-        """If present, will be the attribute within the measurement for multi-measures.
-        """
         return self._attribute
 
     @builtins.property
@@ -94967,134 +95219,29 @@ class timeseries_logicalseries_api_TimestreamLocator(ConjureBeanType):
         return self._type
 
 
-timeseries_logicalseries_api_TimestreamLocator.__name__ = "TimestreamLocator"
-timeseries_logicalseries_api_TimestreamLocator.__qualname__ = "TimestreamLocator"
-timeseries_logicalseries_api_TimestreamLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_TimestreamType(ConjureEnumType):
-
-    DOUBLE = 'DOUBLE'
-    '''DOUBLE'''
-    STRING = 'STRING'
-    '''STRING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_TimestreamType.__name__ = "TimestreamType"
-timeseries_logicalseries_api_TimestreamType.__qualname__ = "TimestreamType"
-timeseries_logicalseries_api_TimestreamType.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_TimestreamLocatorTemplate.__name__ = "TimestreamLocatorTemplate"
+timeseries_metadata_api_TimestreamLocatorTemplate.__qualname__ = "TimestreamLocatorTemplate"
+timeseries_metadata_api_TimestreamLocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_UnitUpdate(ConjureUnionType):
-    """UnitUpdate is used to either set a unit, or to clear an existing unit.
+class timeseries_metadata_api_UpdateSeriesMetadataRequest(ConjureBeanType):
+    """If fields are present, will override existing values.
     """
-    _unit: Optional[str] = None
-    _clear_unit: Optional["api_Empty"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'unit': ConjureFieldDefinition('unit', api_Unit),
-            'clear_unit': ConjureFieldDefinition('clearUnit', api_Empty)
-        }
-
-    def __init__(
-            self,
-            unit: Optional[str] = None,
-            clear_unit: Optional["api_Empty"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (unit is not None) + (clear_unit is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if unit is not None:
-                self._unit = unit
-                self._type = 'unit'
-            if clear_unit is not None:
-                self._clear_unit = clear_unit
-                self._type = 'clearUnit'
-
-        elif type_of_union == 'unit':
-            if unit is None:
-                raise ValueError('a union value must not be None')
-            self._unit = unit
-            self._type = 'unit'
-        elif type_of_union == 'clearUnit':
-            if clear_unit is None:
-                raise ValueError('a union value must not be None')
-            self._clear_unit = clear_unit
-            self._type = 'clearUnit'
-
-    @builtins.property
-    def unit(self) -> Optional[str]:
-        return self._unit
-
-    @builtins.property
-    def clear_unit(self) -> Optional["api_Empty"]:
-        return self._clear_unit
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, timeseries_logicalseries_api_UnitUpdateVisitor):
-            raise ValueError('{} is not an instance of timeseries_logicalseries_api_UnitUpdateVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'unit' and self.unit is not None:
-            return visitor._unit(self.unit)
-        if self._type == 'clearUnit' and self.clear_unit is not None:
-            return visitor._clear_unit(self.clear_unit)
-
-
-timeseries_logicalseries_api_UnitUpdate.__name__ = "UnitUpdate"
-timeseries_logicalseries_api_UnitUpdate.__qualname__ = "UnitUpdate"
-timeseries_logicalseries_api_UnitUpdate.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_UnitUpdateVisitor:
-
-    @abstractmethod
-    def _unit(self, unit: str) -> Any:
-        pass
-
-    @abstractmethod
-    def _clear_unit(self, clear_unit: "api_Empty") -> Any:
-        pass
-
-
-timeseries_logicalseries_api_UnitUpdateVisitor.__name__ = "UnitUpdateVisitor"
-timeseries_logicalseries_api_UnitUpdateVisitor.__qualname__ = "UnitUpdateVisitor"
-timeseries_logicalseries_api_UnitUpdateVisitor.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_UpdateLogicalSeries(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'logical_series_rid': ConjureFieldDefinition('logicalSeriesRid', api_LogicalSeriesRid),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
-            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate])
+            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate]),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_logical_series_rid', '_description', '_unit', '_unit_update']
+    __slots__: List[str] = ['_unit', '_unit_update', '_description']
 
-    def __init__(self, logical_series_rid: str, description: Optional[str] = None, unit: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
-        self._logical_series_rid = logical_series_rid
-        self._description = description
+    def __init__(self, description: Optional[str] = None, unit: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
         self._unit = unit
         self._unit_update = unit_update
-
-    @builtins.property
-    def logical_series_rid(self) -> str:
-        return self._logical_series_rid
-
-    @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
+        self._description = description
 
     @builtins.property
     def unit(self) -> Optional[str]:
@@ -95104,92 +95251,51 @@ class timeseries_logicalseries_api_UpdateLogicalSeries(ConjureBeanType):
     def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
         return self._unit_update
 
-
-timeseries_logicalseries_api_UpdateLogicalSeries.__name__ = "UpdateLogicalSeries"
-timeseries_logicalseries_api_UpdateLogicalSeries.__qualname__ = "UpdateLogicalSeries"
-timeseries_logicalseries_api_UpdateLogicalSeries.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_VisualCrossingEndpointUri(ConjureEnumType):
-
-    HISTORY = 'HISTORY'
-    '''HISTORY'''
-    TIMELINE = 'TIMELINE'
-    '''TIMELINE'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
 
 
-timeseries_logicalseries_api_VisualCrossingEndpointUri.__name__ = "VisualCrossingEndpointUri"
-timeseries_logicalseries_api_VisualCrossingEndpointUri.__qualname__ = "VisualCrossingEndpointUri"
-timeseries_logicalseries_api_VisualCrossingEndpointUri.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_UpdateSeriesMetadataRequest.__name__ = "UpdateSeriesMetadataRequest"
+timeseries_metadata_api_UpdateSeriesMetadataRequest.__qualname__ = "UpdateSeriesMetadataRequest"
+timeseries_metadata_api_UpdateSeriesMetadataRequest.__module__ = "nominal_api.timeseries_metadata_api"
 
 
-class timeseries_logicalseries_api_VisualCrossingLocator(ConjureBeanType):
+class timeseries_metadata_api_VisualCrossingLocatorTemplate(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'location': ConjureFieldDefinition('location', timeseries_logicalseries_api_LocationName),
-            'endpoint': ConjureFieldDefinition('endpoint', OptionalTypeWrapper[timeseries_logicalseries_api_VisualCrossingEndpointUri]),
             'field': ConjureFieldDefinition('field', timeseries_logicalseries_api_FieldName),
+            'endpoint': ConjureFieldDefinition('endpoint', OptionalTypeWrapper[timeseries_logicalseries_api_VisualCrossingEndpointUri]),
             'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_VisualCrossingType)
         }
 
-    __slots__: List[str] = ['_location', '_endpoint', '_field', '_type']
+    __slots__: List[str] = ['_field', '_endpoint', '_type']
 
-    def __init__(self, field: str, location: str, type: "timeseries_logicalseries_api_VisualCrossingType", endpoint: Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"] = None) -> None:
-        self._location = location
-        self._endpoint = endpoint
+    def __init__(self, field: str, type: "timeseries_logicalseries_api_VisualCrossingType", endpoint: Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"] = None) -> None:
         self._field = field
+        self._endpoint = endpoint
         self._type = type
 
     @builtins.property
-    def location(self) -> str:
-        """Location to fetch data from.  Can be any arbitrary string (i.e. name, abbreviation,
-zip code, lat/long, etc.) as remote endpoint performs location resolution.
-        """
-        return self._location
+    def field(self) -> str:
+        return self._field
 
     @builtins.property
     def endpoint(self) -> Optional["timeseries_logicalseries_api_VisualCrossingEndpointUri"]:
-        """Defaults to HISTORY.  Endpoint to fetch data from for this series.
+        """Defaults to HISTORY.
         """
         return self._endpoint
 
-    @builtins.property
-    def field(self) -> str:
-        return self._field
-
     @builtins.property
     def type(self) -> "timeseries_logicalseries_api_VisualCrossingType":
         return self._type
 
 
-timeseries_logicalseries_api_VisualCrossingLocator.__name__ = "VisualCrossingLocator"
-timeseries_logicalseries_api_VisualCrossingLocator.__qualname__ = "VisualCrossingLocator"
-timeseries_logicalseries_api_VisualCrossingLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_VisualCrossingType(ConjureEnumType):
-
-    DOUBLE = 'DOUBLE'
-    '''DOUBLE'''
-    STRING = 'STRING'
-    '''STRING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_VisualCrossingType.__name__ = "VisualCrossingType"
-timeseries_logicalseries_api_VisualCrossingType.__qualname__ = "VisualCrossingType"
-timeseries_logicalseries_api_VisualCrossingType.__module__ = "nominal_api.timeseries_logicalseries_api"
+timeseries_metadata_api_VisualCrossingLocatorTemplate.__name__ = "VisualCrossingLocatorTemplate"
+timeseries_metadata_api_VisualCrossingLocatorTemplate.__qualname__ = "VisualCrossingLocatorTemplate"
+timeseries_metadata_api_VisualCrossingLocatorTemplate.__module__ = "nominal_api.timeseries_metadata_api"
 
 
 class timeseries_seriescache_SeriesCacheService(Service):
@@ -95984,10 +96090,10 @@ api_ColumnName = str
 
 api_Label = str
 
-timeseries_archetype_api_SeriesArchetypeName = str
-
 scout_datasource_connection_api_influx_OrgId = str
 
+timeseries_metadata_api_SeriesMetadataName = str
+
 api_PropertyValue = str
 
 module_ParameterName = str
@@ -96172,6 +96278,8 @@ scout_rids_api_TemplateRid = str
 
 timeseries_logicalseries_api_BucketName = str
 
+api_SeriesMetadataRid = str
+
 datasource_logset_api_LogSetRid = str
 
 ingest_api_DataSourceRefName = str
@@ -96230,8 +96338,6 @@ timeseries_logicalseries_api_DatasetName = str
 
 api_rids_NominalDataSourceOrDatasetRid = str
 
-api_SeriesArchetypeRid = str
-
 scout_versioning_api_TagRid = str
 
 scout_chartdefinition_api_AxisId = str
@@ -96260,6 +96366,8 @@ scout_chartdefinition_api_DataSourceRefName = str
 
 api_LogicalSeriesRid = str
 
+api_SeriesArchetypeRid = api_SeriesMetadataRid
+
 authentication_api_OrgRid = str
 
 scout_rids_api_ChecklistRid = str