industrial-model 0.7.0 → 0.8.0

package/README.md

@@ -13,6 +13,8 @@ TypeScript SDK for querying [Cognite Flexible Data Models (FDM)](https://docs.co
 - **Pagination support** - use cursors manually or fetch all root pages with `limit: -1`.
 - **Aggregation support** - count, group, list distinct values, and aggregate numeric properties.
 - **Mutation support** - upsert model-shaped node patches and delete nodes by identity.
+- **Datapoints support** - read, write, and delete time series datapoints through model-friendly option objects.
+- **Files support** - upload files and retrieve pre-signed download URLs, keyed to model node identities.
 - **Runtime validation option** - parse query results with Zod schemas derived from Cognite view metadata.
 - **CJS and ESM builds** - works in Node.js and common bundler setups.
 
@@ -627,6 +629,122 @@ await core.delete([{ space: "asset-space", externalId: "pump-1" }]);
 
 Deletes are sent through Cognite apply. When more than 1000 nodes are provided, the SDK splits them into multiple Cognite calls.
 
+## Datapoints
+
+Use `model.datapoints` for Cognite time series data. The public API talks in terms of `timeSeries`, ranges, and datapoint batches; the Cognite SDK `items` and `instanceId` payload shape stays internal.
+
+```ts
+const { items } = await model.datapoints.retrieve({
+  timeSeries: [{ space: "ts-space", externalId: "temperature", targetUnit: "degC" }],
+  start: new Date("2024-01-01T00:00:00.000Z"),
+  end: new Date("2024-01-02T00:00:00.000Z"),
+  limit: 100,
+});
+
+items[0]?.timeSeries.externalId;
+items[0]?.datapoints;
+items[0]?.cursor; // next cursor, or null
+```
+
+Pass `limit: -1` to follow datapoint cursors and return all pages for each requested time series.
+
+```ts
+const history = await model.datapoints.retrieve({
+  timeSeries: [{ space: "ts-space", externalId: "temperature" }],
+  start: new Date("2024-01-01T00:00:00.000Z"),
+  limit: -1,
+});
+```
+
+Read the latest datapoint before a given timestamp:
+
+```ts
+const latest = await model.datapoints.latest({
+  timeSeries: [{ space: "ts-space", externalId: "temperature" }],
+  ignoreUnknownIds: true,
+});
+```
+
+Write datapoints by passing an array of insert items directly:
+
+```ts
+await model.datapoints.insert([
+  {
+    timeSeries: { space: "ts-space", externalId: "temperature" },
+    datapoints: [{ timestamp: new Date(), value: 42 }],
+  },
+]);
+```
+
+Delete datapoints by passing an array of ranges directly:
+
+```ts
+await model.datapoints.delete([
+  {
+    timeSeries: { space: "ts-space", externalId: "temperature" },
+    start: new Date("2024-01-01T00:00:00.000Z"),
+    end: new Date("2024-01-02T00:00:00.000Z"),
+  },
+]);
+```
+
+## Files
+
+Use `model.files` to upload files to Cognite and retrieve pre-signed download URLs. Both operations use `space` and `externalId` node identities as keys; the Cognite `instanceId` payload shape stays internal.
+
+Upload a file and optionally pass the binary content as a second argument to complete the upload in one call. When content is provided, Cognite uploads it inline and `uploaded` is `true` on the result.
+
+```ts
+const result = await model.files.upload(
+  {
+    space: "file-space",
+    externalId: "report-2024",
+    name: "annual-report.pdf",
+    mimeType: "application/pdf",
+    directory: "/reports",
+    source: "erp",
+    metadata: { department: "finance", year: "2024" },
+  },
+  pdfContent, // Buffer, Blob, ArrayBuffer, ReadableStream, …
+);
+
+result.space;          // "file-space"
+result.externalId;     // "report-2024"
+result.name;           // "annual-report.pdf"
+result.uploaded;       // true — content was provided
+result.createdTime;    // Date
+result.lastUpdatedTime; // Date
+```
+
+Omit the content argument to receive a pre-signed `uploadUrl` instead. Use it to push the file binary from the client side without routing it through your server:
+
+```ts
+const result = await model.files.upload({
+  space: "file-space",
+  externalId: "report-2024",
+  name: "annual-report.pdf",
+  mimeType: "application/pdf",
+});
+
+result.uploaded;   // false — content not yet uploaded
+result.uploadUrl;  // "https://storage.example.com/…" — use to PUT the file
+```
+
+Retrieve pre-signed download URLs for one or more files by node identity:
+
+```ts
+const urls = await model.files.getDownloadUrls([
+  { space: "file-space", externalId: "report-2024" },
+  { space: "file-space", externalId: "manual-v3" },
+]);
+
+urls[0]?.downloadUrl; // pre-signed URL ready to use
+urls[0]?.space;
+urls[0]?.externalId;
+```
+
+The returned array preserves the input order. Passing an empty array returns `[]` without calling Cognite.
+
 ## Aggregation
 
 Use `aggregate()` when you need grouped counts, distinct values, or numeric summaries without loading every instance.
@@ -826,6 +944,15 @@ Deletes are view-independent:
 await core.delete([{ space: "asset-space", externalId: "pump-1" }]);
 ```
 
+`core.datapoints` exposes the same executor API as `model.datapoints` on `IndustrialModelClient`:
+
+```ts
+const { items } = await core.datapoints.retrieve({
+  timeSeries: [{ space: "ts-space", externalId: "temperature" }],
+  limit: 100,
+});
+```
+
 All Cognite Core view types are exported from `industrial-model` and can be imported directly for use with `IndustrialModelClient` if needed:
 
 ```ts
@@ -987,6 +1114,10 @@ Same as `model.upsert<TModel>()(options)` on `IndustrialModelClient`, with the v
 
 Same as `model.delete(items)` on `IndustrialModelClient`. Deletes nodes by `space` and `externalId`; no view name is required.
 
+### `core.datapoints`
+
+Same as `model.datapoints` on `IndustrialModelClient`. All four methods — `retrieve`, `latest`, `insert`, and `delete` — are available without a view name.
+
 ### `new IndustrialModelClient(client, dataModelId, options?)`
 
 | Parameter | Type | Description |
@@ -1093,6 +1224,50 @@ Provide at least one of `groupBy` or `aggregate`. Omit `aggregate` to fetch dist
 | `max` | `{ max: "volume" }` | Maximum numeric value. |
 | `sum` | `{ sum: "volume" }` | Sum of a numeric property. |
 
+### `model.files.upload(fileInfo, content?)`
+
+Uploads a file to Cognite. `fileInfo` fields:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `space` | `string` | Node space. |
+| `externalId` | `string` | Node external ID. |
+| `name` | `string` | File name. |
+| `mimeType` | `string` | Optional MIME type. |
+| `directory` | `string` | Optional directory path within the project. |
+| `source` | `string` | Optional source system identifier. |
+| `metadata` | `Record<string, string>` | Optional key-value metadata. |
+
+`content` accepts any value accepted by the Cognite SDK file upload (`Buffer`, `Blob`, `ArrayBuffer`, `ReadableStream`, …). When provided, the file is uploaded inline and `uploaded` is `true`. When omitted, Cognite returns a pre-signed `uploadUrl` for a separate upload and `uploaded` is `false`.
+
+Returns `FileUploadResult`:
+
+```ts
+type FileUploadResult = NodeId & {
+  name: string;
+  uploaded: boolean;
+  mimeType?: string;
+  directory?: string;
+  source?: string;
+  uploadedTime?: Date;
+  createdTime: Date;
+  lastUpdatedTime: Date;
+  uploadUrl?: string;
+};
+```
+
+### `model.files.getDownloadUrls(nodeIds)`
+
+Retrieves one pre-signed download URL per node, in the same order as the input. Passing an empty array returns `[]` without calling Cognite.
+
+Returns `FileDownloadUrl[]`:
+
+```ts
+type FileDownloadUrl = NodeId & {
+  downloadUrl: string;
+};
+```
+
 ### Filter Operators
 
 | Field type | Operators |
@@ -1132,6 +1307,8 @@ Logical combinators `AND`, `OR`, and `NOT` are supported at any nesting level, i
 | `UpsertResult`, `UpsertResultItem` | Upsert output types. |
 | `DeleteExecutor`, `DeleteResult`, `DeleteResultItem` | Delete helper and output types. |
 | `EdgeCreationContext`, `EdgeCreationCallback`, `EdgeCreationCallbacks`, `EdgeMode` | Edge upsert helper types. |
+| `DatapointsExecutor`, `DatapointsRetrieveOptions`, `DatapointsLatestOptions`, `DatapointsLatestSeries`, `DatapointsInsertItem`, `DatapointsDeleteRange`, `DatapointsResult`, `DatapointSeriesResult`, `DatapointAggregate` | Datapoints types. |
+| `FilesExecutor`, `FileUploadInfo`, `FileUploadResult`, `FileDownloadUrl` | Files types. |
 | `IndustrialModelClientOptions` | Client configuration options. |
 
 **Cognite Core**

package/dist/cognite-core/index.cjs

@@ -50,7 +50,92 @@ var CogniteSdkAdapter = class {
       items: response.items
     };
   }
+  async retrieveDatapoints(options) {
+    const { items, ...rest } = options;
+    const sdkItems = items.map(({ space, externalId, ...itemRest }) => ({
+      ...itemRest,
+      instanceId: { space, externalId }
+    }));
+    const response = await this.client.datapoints.retrieve({
+      ...rest,
+      items: sdkItems
+    });
+    return { items: response.map(mapDatapointResult) };
+  }
+  async retrieveLatestDatapoints(items, options) {
+    const sdkItems = items.map(({ space, externalId, before }) => ({
+      instanceId: { space, externalId },
+      ...before !== void 0 ? { before } : {}
+    }));
+    const response = await this.client.datapoints.retrieveLatest(
+      sdkItems,
+      options
+    );
+    return { items: response.map(mapDatapointResult) };
+  }
+  async insertDatapoints(items) {
+    const sdkItems = items.map(({ space, externalId, datapoints }) => ({
+      instanceId: { space, externalId },
+      datapoints
+    }));
+    await this.client.datapoints.insert(
+      sdkItems
+    );
+  }
+  async deleteDatapoints(items) {
+    const sdkItems = items.map(({ space, externalId, inclusiveBegin, exclusiveEnd }) => ({
+      instanceId: { space, externalId },
+      inclusiveBegin,
+      ...exclusiveEnd !== void 0 ? { exclusiveEnd } : {}
+    }));
+    await this.client.datapoints.delete(
+      sdkItems
+    );
+  }
+  async uploadFile(fileInfo, content) {
+    const { instanceId, ...rest } = fileInfo;
+    const response = await this.client.files.upload(
+      { ...rest, instanceId },
+      content,
+      false,
+      content !== void 0
+    );
+    return mapFileResult(response);
+  }
+  async getFileDownloadUrls(ids) {
+    const response = await this.client.files.getDownloadUrls(
+      ids
+    );
+    return response.map((item) => ({
+      ...item.instanceId !== void 0 ? { instanceId: item.instanceId } : {},
+      downloadUrl: item.downloadUrl
+    }));
+  }
 };
+function mapFileResult(item) {
+  return {
+    ...item.instanceId !== void 0 ? { instanceId: item.instanceId } : {},
+    name: item.name,
+    uploaded: item.uploaded,
+    createdTime: item.createdTime,
+    lastUpdatedTime: item.lastUpdatedTime,
+    ...item.uploadedTime !== void 0 ? { uploadedTime: item.uploadedTime } : {},
+    ...item.mimeType !== void 0 ? { mimeType: item.mimeType } : {},
+    ...item.directory !== void 0 ? { directory: item.directory } : {},
+    ...item.source !== void 0 ? { source: item.source } : {},
+    ...item.uploadUrl !== void 0 ? { uploadUrl: item.uploadUrl } : {}
+  };
+}
+function mapDatapointResult(item) {
+  return {
+    ...item.instanceId?.space !== void 0 ? { space: item.instanceId.space } : {},
+    ...item.instanceId?.externalId !== void 0 ? { externalId: item.instanceId.externalId } : {},
+    isString: item.isString ?? false,
+    ...item.unit !== void 0 ? { unit: item.unit } : {},
+    datapoints: item.datapoints ?? [],
+    ...item.nextCursor !== void 0 ? { nextCursor: item.nextCursor } : {}
+  };
+}
 
 // src/constants.ts
 var NESTED_SEP = "|";
@@ -61,6 +146,15 @@ var MAX_DEPENDENCY_DEPTH = 3;
 var AGGREGATE_LIMIT = 1e3;
 var MAX_GROUP_BY = 5;
 
+// src/utils/array.ts
+function chunks(items, size) {
+  const result = [];
+  for (let index = 0; index < items.length; index += size) {
+    result.push(items.slice(index, index + size));
+  }
+  return result;
+}
+
 // src/utils/query.ts
 function mapNodesAndEdges(queryResult, _query) {
   return queryResult.items;
@@ -717,6 +811,63 @@ ${errors.map((error) => `- ${error}`).join("\n")}`
     return [];
   }
 };
+var dateSchema2 = zod.z.date();
+var nodeIdSchema2 = zod.z.object({ space: zod.z.string(), externalId: zod.z.string() }).loose();
+var retrieveOptionsSchema = zod.z.object({
+  timeSeries: zod.z.array(nodeIdSchema2),
+  start: dateSchema2.optional(),
+  end: dateSchema2.optional()
+}).loose();
+var deleteRangeSchema = zod.z.object({
+  timeSeries: zod.z.object({ space: zod.z.string(), externalId: zod.z.string() }).loose(),
+  start: dateSchema2,
+  end: dateSchema2.optional()
+}).loose();
+function formatIssues(error, prefix) {
+  return error.issues.map((issue) => {
+    const parts = prefix ? [prefix, ...issue.path] : [...issue.path];
+    return `${parts.map(String).join(".")}: ${issue.message}`;
+  });
+}
+var DatapointsValidator = class {
+  validateRetrieve(options) {
+    const result = retrieveOptionsSchema.safeParse(options);
+    if (!result.success) {
+      const messages = formatIssues(result.error);
+      throw new Error(`Invalid datapoints options:
+- ${messages.join("\n- ")}`);
+    }
+  }
+  validateDelete(ranges) {
+    const result = zod.z.array(deleteRangeSchema).safeParse(ranges);
+    if (!result.success) {
+      const messages = formatIssues(result.error, "ranges");
+      throw new Error(`Invalid datapoints options:
+- ${messages.join("\n- ")}`);
+    }
+  }
+};
+var nodeIdSchema3 = zod.z.object({
+  space: zod.z.string().min(1),
+  externalId: zod.z.string().min(1)
+}).loose();
+var deleteItemsSchema = zod.z.array(nodeIdSchema3);
+function formatIssues2(error, prefix) {
+  return error.issues.map((issue) => {
+    const parts = [prefix, ...issue.path];
+    return `${parts.map(String).join(".")}: ${issue.message}`;
+  });
+}
+var DeleteValidator = class {
+  validateItems(items) {
+    const result = deleteItemsSchema.safeParse(items);
+    if (!result.success) {
+      const messages = formatIssues2(result.error, "items");
+      throw new Error(`Invalid delete options:
+- ${messages.join("\n- ")}`);
+    }
+  }
+};
 var nodeMetadataSchema = {
   instanceType: zod.z.literal("node").optional(),
   space: zod.z.string(),
@@ -1120,6 +1271,178 @@ var AggregateResultMapper = class {
   }
 };
 
+// src/mappers/datapoints-mapper.ts
+var CHUNK_SIZE = 100;
+var DatapointsMapper = class {
+  constructor(cognite) {
+    this.cognite = cognite;
+    this.validator = new DatapointsValidator();
+  }
+  async retrieve(options) {
+    this.validator.validateRetrieve(options);
+    const cogniteOptions = this.toCogniteOptions(options);
+    const allPages = options.limit === -1;
+    if (!allPages) {
+      const result = await this.cognite.retrieveDatapoints(cogniteOptions);
+      return this.mapResult(result.items, cogniteOptions.items, options.aggregate);
+    }
+    const accumulated = /* @__PURE__ */ new Map();
+    const itemByKey = new Map(cogniteOptions.items.map((item) => [this.toKey(item), item]));
+    let currentItems = cogniteOptions.items;
+    while (currentItems.length > 0) {
+      const result = await this.cognite.retrieveDatapoints({
+        ...cogniteOptions,
+        items: currentItems
+      });
+      const nextItems = [];
+      for (const resultItem of result.items) {
+        const key = this.toKey(resultItem);
+        let acc = accumulated.get(key);
+        if (!acc) {
+          acc = { ...resultItem, datapoints: [] };
+          accumulated.set(key, acc);
+        }
+        acc.datapoints.push(...resultItem.datapoints);
+        if (resultItem.nextCursor) {
+          acc.nextCursor = resultItem.nextCursor;
+        } else {
+          delete acc.nextCursor;
+        }
+        if (resultItem.nextCursor) {
+          const original = itemByKey.get(key);
+          nextItems.push({
+            ...original,
+            space: resultItem.space ?? original?.space ?? "",
+            externalId: resultItem.externalId ?? original?.externalId ?? "",
+            cursor: resultItem.nextCursor
+          });
+        }
+      }
+      currentItems = nextItems;
+    }
+    return this.mapResult(
+      Array.from(accumulated.values()),
+      cogniteOptions.items,
+      options.aggregate
+    );
+  }
+  async retrieveLatest(options) {
+    const items = options.timeSeries.map(
+      ({ space, externalId, before }) => ({
+        space,
+        externalId,
+        ...before !== void 0 ? { before } : {}
+      })
+    );
+    const latestOptions = options.ignoreUnknownIds !== void 0 ? { ignoreUnknownIds: options.ignoreUnknownIds } : void 0;
+    const result = await this.cognite.retrieveLatestDatapoints(items, latestOptions);
+    return this.mapResult(result.items, items);
+  }
+  async insert(items) {
+    const cogniteItems = items.map(({ timeSeries, datapoints }) => ({
+      space: timeSeries.space,
+      externalId: timeSeries.externalId,
+      datapoints
+    }));
+    for (const chunk of chunks(cogniteItems, CHUNK_SIZE)) {
+      await this.cognite.insertDatapoints(chunk);
+    }
+  }
+  async delete(ranges) {
+    this.validator.validateDelete(ranges);
+    const cogniteItems = ranges.map(({ timeSeries, start, end }) => ({
+      space: timeSeries.space,
+      externalId: timeSeries.externalId,
+      inclusiveBegin: start,
+      ...end !== void 0 ? { exclusiveEnd: end } : {}
+    }));
+    for (const chunk of chunks(cogniteItems, CHUNK_SIZE)) {
+      await this.cognite.deleteDatapoints(chunk);
+    }
+  }
+  toKey(item) {
+    return `${item.space ?? ""}:${item.externalId ?? ""}`;
+  }
+  toCogniteOptions(options) {
+    const { timeSeries, aggregate, ...rest } = options;
+    return {
+      ...rest,
+      ...aggregate !== void 0 ? { aggregates: [aggregate] } : {},
+      items: timeSeries.map(({ space, externalId }) => ({ space, externalId }))
+    };
+  }
+  mapResult(items, requestedItems, aggregate) {
+    const requestedByKey = new Map(requestedItems.map((item) => [this.toKey(item), item]));
+    const mappedItems = items.filter((item) => !item.isString).map((item) => {
+      const requested = requestedByKey.get(this.toKey(item));
+      const datapoints = aggregate !== void 0 ? item.datapoints.map((dp) => ({
+        timestamp: dp.timestamp,
+        value: dp[aggregate] ?? 0
+      })) : item.datapoints;
+      return {
+        timeSeries: {
+          space: item.space ?? requested?.space ?? "",
+          externalId: item.externalId ?? requested?.externalId ?? ""
+        },
+        ...item.unit !== void 0 ? { unit: item.unit } : {},
+        datapoints,
+        cursor: item.nextCursor ?? null
+      };
+    });
+    return { items: mappedItems };
+  }
+};
+
+// src/mappers/files-mapper.ts
+var FilesMapper = class {
+  constructor(cognite) {
+    this.cognite = cognite;
+  }
+  async upload(fileInfo, content) {
+    const { space, externalId, ...rest } = fileInfo;
+    const result = await this.cognite.uploadFile(
+      { instanceId: { space, externalId }, ...rest },
+      content
+    );
+    return this.mapUploadResult(result, { space, externalId });
+  }
+  async getDownloadUrls(nodeIds) {
+    if (nodeIds.length === 0) return [];
+    const ids = nodeIds.map(({ space, externalId }) => ({ instanceId: { space, externalId } }));
+    const result = await this.cognite.getFileDownloadUrls(ids);
+    return result.map(
+      (item, i) => this.mapDownloadUrl(item, nodeIds[i] ?? { space: "", externalId: "" })
+    );
+  }
+  toNodeId(item, fallback) {
+    return {
+      space: item.instanceId?.space ?? fallback.space,
+      externalId: item.instanceId?.externalId ?? fallback.externalId
+    };
+  }
+  mapUploadResult(item, fallback) {
+    const nodeId = this.toNodeId(item, fallback);
+    return {
+      ...nodeId,
+      name: item.name,
+      uploaded: item.uploaded,
+      createdTime: item.createdTime,
+      lastUpdatedTime: item.lastUpdatedTime,
+      ...item.uploadedTime !== void 0 ? { uploadedTime: item.uploadedTime } : {},
+      ...item.mimeType !== void 0 ? { mimeType: item.mimeType } : {},
+      ...item.directory !== void 0 ? { directory: item.directory } : {},
+      ...item.source !== void 0 ? { source: item.source } : {},
+      ...item.uploadUrl !== void 0 ? { uploadUrl: item.uploadUrl } : {}
+    };
+  }
+  mapDownloadUrl(item, fallback) {
+    return {
+      ...this.toNodeId(item, fallback),
+      downloadUrl: item.downloadUrl
+    };
+  }
+};
+
 // src/mappers/sort-mapper.ts
 var SortMapper = class {
   map(sort, rootView) {
@@ -1709,6 +2032,17 @@ var ViewMapper = class {
 var APPLY_ITEM_LIMIT = 1e3;
 var IndustrialModelClient = class {
   constructor(client, dataModelId, options = {}) {
+    this.deleteValidator = new DeleteValidator();
+    this.files = {
+      upload: (fileInfo, content) => this.filesMapper.upload(fileInfo, content),
+      getDownloadUrls: (nodeIds) => this.filesMapper.getDownloadUrls(nodeIds)
+    };
+    this.datapoints = {
+      retrieve: (options) => this.datapointsMapper.retrieve(options),
+      latest: (options) => this.datapointsMapper.retrieveLatest(options),
+      insert: (items) => this.datapointsMapper.insert(items),
+      delete: (ranges) => this.datapointsMapper.delete(ranges)
+    };
     const cognite = createCogniteAdapter(client);
     this.cognite = cognite;
     const viewMapper = new ViewMapper(cognite, dataModelId);
@@ -1717,6 +2051,8 @@ var IndustrialModelClient = class {
     this.upsertMapper = new UpsertMapper(viewMapper, cognite);
     this.aggregateResultMapper = new AggregateResultMapper();
     this.resultMapper = new QueryResultMapper(viewMapper);
+    this.datapointsMapper = new DatapointsMapper(cognite);
+    this.filesMapper = new FilesMapper(cognite);
     this.resultValidator = new QueryResultValidator(viewMapper);
     this.validateResults = options.validateResults ?? false;
   }
@@ -1733,14 +2069,12 @@ var IndustrialModelClient = class {
     return execute;
   }
   async delete(items) {
-    const deleteItems = items.map((item) => {
-      assertNodeId2(item);
-      return {
-        instanceType: "node",
-        space: item.space,
-        externalId: item.externalId
-      };
-    });
+    this.deleteValidator.validateItems(items);
+    const deleteItems = items.map((item) => ({
+      instanceType: "node",
+      space: item.space,
+      externalId: item.externalId
+    }));
     const response = await this.applyInstancesInChunks({
       items: [],
       delete: deleteItems
@@ -1832,18 +2166,6 @@ var IndustrialModelClient = class {
     return appendNodesAndEdges(result, nestedResults);
   }
 };
-function chunks(items, size) {
-  const result = [];
-  for (let index = 0; index < items.length; index += size) {
-    result.push(items.slice(index, index + size));
-  }
-  return result;
-}
-function assertNodeId2(value) {
-  if (value == null || typeof value !== "object" || Array.isArray(value) || typeof value.space !== "string" || value.space?.length === 0 || typeof value.externalId !== "string" || value.externalId?.length === 0) {
-    throw new Error("Invalid delete options:\n- items: expected NodeId values");
-  }
-}
 
 // src/cognite-core/client.ts
 var COGNITE_CORE_DATA_MODEL = {
@@ -1874,6 +2196,9 @@ var CogniteCoreClient = class {
   delete(items) {
     return this.model.delete(items);
   }
+  get datapoints() {
+    return this.model.datapoints;
+  }
 };
 
 exports.COGNITE_CORE_DATA_MODEL = COGNITE_CORE_DATA_MODEL;