@datalayer/core 1.1.60 → 1.2.10

package/lib/client/auth/storage.js

@@ -2,11 +2,6 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- *
- * Datalayer License
- */
 /**
  * Token storage backend implementations
  */

package/lib/client/auth/strategies.js

@@ -2,11 +2,6 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- *
- * Datalayer License
- */
 /**
  * Authentication strategy implementations
  */

package/lib/client/base.d.ts

@@ -19,6 +19,8 @@ export interface DatalayerClientConfig {
     runtimesUrl?: string;
     /** URL for the Spacer service */
     spacerUrl?: string;
+    /** URL for the Contents service */
+    contentsUrl?: string;
     /** Custom token storage backend (optional, defaults to auto-detected) */
     storage?: TokenStorage;
     /** Handlers for intercepting Client method calls */
@@ -32,6 +34,8 @@ export declare class DatalayerClientBase {
     readonly runtimesUrl: string;
     /** URL for Spacer service */
     readonly spacerUrl: string;
+    /** URL for Contents service */
+    readonly contentsUrl: string;
     /** Authentication token */
     token?: string;
     /** Method lifecycle handlers */
@@ -54,6 +58,8 @@ export declare class DatalayerClientBase {
     getRuntimesUrl(): string;
     /** Get the Spacer service URL. */
     getSpacerUrl(): string;
+    /** Get the Contents service URL. */
+    getContentsUrl(): string;
     /** Get the current authentication token. */
     getToken(): string | undefined;
     /**

package/lib/client/base.js

@@ -16,6 +16,8 @@ export class DatalayerClientBase {
     runtimesUrl;
     /** URL for Spacer service */
     spacerUrl;
+    /** URL for Contents service */
+    contentsUrl;
     /** Authentication token */
     token;
     /** Method lifecycle handlers */
@@ -31,6 +33,7 @@ export class DatalayerClientBase {
         this.runtimesUrl =
             config.runtimesUrl || DEFAULT_SERVICE_URLS.RUNTIMES;
         this.spacerUrl = config.spacerUrl || DEFAULT_SERVICE_URLS.SPACER;
+        this.contentsUrl = config.contentsUrl || DEFAULT_SERVICE_URLS.CONTENTS;
         this.token = config.token;
         this.handlers = config.handlers;
         // Initialize authentication manager with custom storage if provided
@@ -49,6 +52,7 @@ export class DatalayerClientBase {
             iamUrl: this.iamUrl,
             runtimesUrl: this.runtimesUrl,
             spacerUrl: this.spacerUrl,
+            contentsUrl: this.contentsUrl,
             token: this.token,
         };
     }
@@ -64,6 +68,10 @@ export class DatalayerClientBase {
     getSpacerUrl() {
         return this.spacerUrl;
     }
+    /** Get the Contents service URL. */
+    getContentsUrl() {
+        return this.contentsUrl;
+    }
     /** Get the current authentication token. */
     getToken() {
         return this.token;

package/lib/client/constants.d.ts

@@ -11,6 +11,7 @@
 export declare const ItemTypes: {
     readonly NOTEBOOK: "notebook";
     readonly LEXICAL: "document";
+    readonly DECK: "deck";
     readonly EXERCISE: "exercise";
     readonly CELL: "cell";
     readonly SPACE: "space";

package/lib/client/constants.js

@@ -15,6 +15,7 @@
 export const ItemTypes = {
     NOTEBOOK: 'notebook',
     LEXICAL: 'document',
+    DECK: 'deck',
     EXERCISE: 'exercise',
     CELL: 'cell',
     SPACE: 'space',

package/lib/client/index.d.ts

@@ -20,8 +20,6 @@ import type { CreditsDTO } from '../models/CreditsDTO';
 import type { HealthCheck } from '../models/HealthCheck';
 import type { SecretDTO } from '../models/Secret';
 import type { CreateSecretRequest, UpdateSecretRequest } from '../models/Secret';
-import type { DatasourceDTO } from '../models/Datasource';
-import type { CreateDatasourceRequest, UpdateDatasourceRequest } from '../models/Datasource';
 declare const DatalayerCoreClientWithMixins: typeof DatalayerClientBase;
 /**
  * Core Datalayer Client providing access to identity, plans and account
@@ -57,13 +55,10 @@ export { HealthCheck } from '../models/HealthCheck';
 export type { HealthCheckJSON } from '../models/HealthCheck';
 export { SecretDTO as Secret } from './../models/Secret';
 export type { SecretJSON, SecretData, CreateSecretRequest, UpdateSecretRequest, CreateSecretResponse, GetSecretResponse, ListSecretsResponse, UpdateSecretResponse, DeleteSecretResponse, } from './../models/Secret';
-export { DatasourceDTO as Datasource } from './../models/Datasource';
-export type { DatasourceJSON, DatasourceData, DatasourceType, CreateDatasourceRequest, UpdateDatasourceRequest, CreateDatasourceResponse, GetDatasourceResponse, ListDatasourcesResponse, UpdateDatasourceResponse, } from './../models/Datasource';
 export type { LoginRequest, LoginResponse, UserMeResponse, MembershipsResponse, WhoAmIResponse, } from '../models/IAM';
 export type { HealthzPingResponse } from '../models/Common';
 export { AuthenticationManager } from './auth/AuthenticationManager';
 export type { IUser, IBaseUser } from '../models/User';
-export type { IDatasource, IDatasourceVariant } from '../models/Datasource';
 export type { ICredits, ICreditsReservation } from '../models/Credits';
 export type { ISurvey } from '../models/Survey';
 export type { IBaseTeam, IAnyTeam } from '../models/Team';
@@ -111,10 +106,5 @@ export interface DatalayerCoreClient {
     getSecret(secretId: string): Promise<SecretDTO>;
     updateSecret(secretId: string, updates: UpdateSecretRequest): Promise<SecretDTO>;
     deleteSecret(secretId: string): Promise<void>;
-    createDatasource(data: CreateDatasourceRequest): Promise<DatasourceDTO>;
-    listDatasources(): Promise<DatasourceDTO[]>;
-    getDatasource(datasourceId: string): Promise<DatasourceDTO>;
-    updateDatasource(datasourceId: string, updates: UpdateDatasourceRequest): Promise<DatasourceDTO>;
-    deleteDatasource(datasourceId: string): Promise<void>;
     calculateCreditsFromMinutes(minutes: number, burningRate: number): number;
 }

package/lib/client/index.js

@@ -20,6 +20,7 @@
  */
 import { DatalayerClientBase, } from './base.js';
 import { IAMMixin } from './mixins/IAMMixin.js';
+import { ContentsMixin } from './mixins/ContentsMixin.js';
 /**
  * Helper function to compose mixins in a more readable way.
  * Applies mixins in the order provided.
@@ -33,7 +34,7 @@ function composeMixins(...mixins) {
 // Apply the IAM mixin to the base class. Runtime and content (Spacer) features
 // live in @datalayer/agent-runtimes, which composes AgentRuntimesClient on top
 // of this core client.
-const DatalayerCoreClientWithMixins = composeMixins(IAMMixin);
+const DatalayerCoreClientWithMixins = composeMixins(IAMMixin, ContentsMixin);
 /**
  * Core Datalayer Client providing access to identity, plans and account
  * services (IAM). Runtime and workspace/content features are provided by
@@ -68,7 +69,6 @@ export { UserDTO as User } from './../models/UserDTO.js';
 export { CreditsDTO as Credits } from '../models/CreditsDTO.js';
 export { HealthCheck } from '../models/HealthCheck.js';
 export { SecretDTO as Secret } from './../models/Secret.js';
-export { DatasourceDTO as Datasource } from './../models/Datasource.js';
 // Export auth types
 export { AuthenticationManager } from './auth/AuthenticationManager.js';
 // Constants

package/lib/client/mixins/ContentsMixin.d.ts

@@ -0,0 +1,71 @@
+/** Contents mixin providing the typed source catalog API. */
+import { type ConditionalCatalogSource, type AttachmentCreate, type AttachmentList, type ContentAttachment, type ContentAttachmentManifest, type DatasetRevision, type DatasetRevisionCreate, type DatasetRevisionList, type DatasetPublication, type DatasetPublicationCreate, type DatasetPublicationList, type ContentSourceCreate, type ContentSourceUpdate, type EffectivePermissions, type ContentObject, type DownloadedObject, type ObjectList, type OperationView, type RestoreRequest, type Sharing, type SourceList, type TransferCreate, type TransferList, type TransferView, type UploadProgress, type HomeFolderObjectListOptions, type HomeFolderQuota, type VersionList } from '../../api/contents';
+import type { Constructor } from '../utils/mixins';
+export declare function ContentsMixin<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {
+        contentsRequestContext(): {
+            token: string;
+            baseUrl: string;
+        };
+        listContentSources(options?: {
+            kind?: string;
+            spaceUid?: string;
+            cursor?: string;
+            limit?: number;
+        }): Promise<SourceList>;
+        createContentAttachment(request: AttachmentCreate, idempotencyKey: string): Promise<ContentAttachment>;
+        createDatasetRevision(sourceUid: string, request: DatasetRevisionCreate, idempotencyKey: string): Promise<DatasetRevision>;
+        listDatasetRevisions(sourceUid: string): Promise<DatasetRevisionList>;
+        getDatasetRevision(sourceUid: string, revisionUid: string): Promise<DatasetRevision>;
+        createDatasetPublication(sourceUid: string, request: DatasetPublicationCreate, idempotencyKey: string): Promise<DatasetPublication>;
+        listDatasetPublications(sourceUid: string): Promise<DatasetPublicationList>;
+        unpublishDataset(sourceUid: string, publicationUid: string): Promise<DatasetPublication>;
+        listContentAttachments(options?: {
+            sandboxUid?: string;
+            sourceUid?: string;
+            active?: boolean;
+        }): Promise<AttachmentList>;
+        getContentAttachmentManifest(sandboxUid: string): Promise<ContentAttachmentManifest>;
+        revokeContentAttachment(attachmentUid: string): Promise<ContentAttachment>;
+        createContentSource(source: ContentSourceCreate, idempotencyKey: string): Promise<ConditionalCatalogSource>;
+        getContentSource(sourceUid: string): Promise<ConditionalCatalogSource>;
+        getHomeFolder(): Promise<ConditionalCatalogSource>;
+        listHomeFolderObjects(options?: HomeFolderObjectListOptions): Promise<ObjectList>;
+        getHomeFolderQuota(): Promise<HomeFolderQuota>;
+        statHomeFolderObject(path: string): Promise<ContentObject>;
+        listHomeFolderObjectVersions(objectUid: string, options?: {
+            cursor?: string;
+            limit?: number;
+        }): Promise<VersionList>;
+        deleteHomeFolderObject(objectUid: string, idempotencyKey: string): Promise<ContentObject>;
+        restoreHomeFolderObject(objectUid: string, request: RestoreRequest, idempotencyKey: string): Promise<ContentObject>;
+        createContentTransfer(request: TransferCreate, idempotencyKey: string): Promise<TransferView>;
+        getContentTransfer(transferUid: string): Promise<TransferView>;
+        listContentTransfers(options?: {
+            active?: boolean;
+            cursor?: string;
+            limit?: number;
+        }): Promise<TransferList>;
+        uploadContentTransferPart(transferUid: string, partNumber: number, content: Uint8Array, checksum: string): Promise<TransferView>;
+        completeContentTransfer(transferUid: string): Promise<TransferView>;
+        cancelContentTransfer(transferUid: string): Promise<TransferView>;
+        uploadHomeFolderFile(path: string, content: Blob | Uint8Array | ArrayBuffer, options: {
+            idempotencyKey: string;
+            mediaType?: string;
+            overwrite?: "reject" | "replace" | "new-version";
+            chunkSize?: number;
+            onProgress?: (progress: UploadProgress) => void;
+        }): Promise<TransferView>;
+        downloadHomeFolderObject(objectUid: string, options?: {
+            versionUid?: string;
+            range?: string;
+        }): Promise<DownloadedObject>;
+        updateContentSource(sourceUid: string, update: ContentSourceUpdate, etag: string): Promise<ConditionalCatalogSource>;
+        archiveContentSource(sourceUid: string, etag: string): Promise<ConditionalCatalogSource>;
+        getContentSourcePermissions(sourceUid: string): Promise<EffectivePermissions>;
+        getContentSourceSharing(sourceUid: string): Promise<Sharing>;
+        replaceContentSourceSharing(sourceUid: string, sharing: Sharing, etag: string): Promise<ConditionalCatalogSource>;
+        getContentOperation(operationUid: string): Promise<OperationView>;
+        cancelContentOperation(operationUid: string): Promise<OperationView>;
+    };
+} & TBase;

package/lib/client/mixins/ContentsMixin.js

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** Contents mixin providing the typed source catalog API. */
+import { createAttachment, createDatasetRevision, createDatasetPublication, archiveSource, cancelOperation, cancelTransfer, completeTransfer, createSource, createTransfer, downloadHomeFolderObject, getSource, getHomeFolderQuota, getHomeFolder, getAttachmentManifest, getDatasetRevision, getOperation, getTransfer, getSourcePermissions, getSourceSharing, listHomeFolderObjects, listHomeFolderObjectVersions, listSources, listTransfers, listAttachments, listDatasetRevisions, listDatasetPublications, deleteHomeFolderObject, replaceSourceSharing, restoreHomeFolderObject, revokeAttachment, unpublishDataset, statHomeFolderObject, uploadTransferPart, uploadHomeFolderFile, updateSource, } from '../../api/contents/index.js';
+export function ContentsMixin(Base) {
+    return class extends Base {
+        contentsRequestContext() {
+            const client = this;
+            return {
+                token: client.getToken() ?? '',
+                baseUrl: client.getContentsUrl(),
+            };
+        }
+        async listContentSources(options = {}) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listSources(token, options, baseUrl);
+        }
+        async createContentAttachment(request, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return createAttachment(token, request, idempotencyKey, baseUrl);
+        }
+        async createDatasetRevision(sourceUid, request, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return createDatasetRevision(token, sourceUid, request, idempotencyKey, baseUrl);
+        }
+        async listDatasetRevisions(sourceUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listDatasetRevisions(token, sourceUid, baseUrl);
+        }
+        async getDatasetRevision(sourceUid, revisionUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getDatasetRevision(token, sourceUid, revisionUid, baseUrl);
+        }
+        async createDatasetPublication(sourceUid, request, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return createDatasetPublication(token, sourceUid, request, idempotencyKey, baseUrl);
+        }
+        async listDatasetPublications(sourceUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listDatasetPublications(token, sourceUid, baseUrl);
+        }
+        async unpublishDataset(sourceUid, publicationUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return unpublishDataset(token, sourceUid, publicationUid, baseUrl);
+        }
+        async listContentAttachments(options = {}) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listAttachments(token, options, baseUrl);
+        }
+        async getContentAttachmentManifest(sandboxUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getAttachmentManifest(token, sandboxUid, baseUrl);
+        }
+        async revokeContentAttachment(attachmentUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return revokeAttachment(token, attachmentUid, baseUrl);
+        }
+        async createContentSource(source, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return createSource(token, source, idempotencyKey, baseUrl);
+        }
+        async getContentSource(sourceUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getSource(token, sourceUid, baseUrl);
+        }
+        async getHomeFolder() {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getHomeFolder(token, baseUrl);
+        }
+        async listHomeFolderObjects(options = {}) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listHomeFolderObjects(token, options, baseUrl);
+        }
+        async getHomeFolderQuota() {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getHomeFolderQuota(token, baseUrl);
+        }
+        async statHomeFolderObject(path) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return statHomeFolderObject(token, path, baseUrl);
+        }
+        async listHomeFolderObjectVersions(objectUid, options = {}) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listHomeFolderObjectVersions(token, objectUid, options, baseUrl);
+        }
+        async deleteHomeFolderObject(objectUid, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return deleteHomeFolderObject(token, objectUid, idempotencyKey, baseUrl);
+        }
+        async restoreHomeFolderObject(objectUid, request, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return restoreHomeFolderObject(token, objectUid, request, idempotencyKey, baseUrl);
+        }
+        async createContentTransfer(request, idempotencyKey) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return createTransfer(token, request, idempotencyKey, baseUrl);
+        }
+        async getContentTransfer(transferUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getTransfer(token, transferUid, baseUrl);
+        }
+        async listContentTransfers(options = {}) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return listTransfers(token, options, baseUrl);
+        }
+        async uploadContentTransferPart(transferUid, partNumber, content, checksum) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return uploadTransferPart(token, transferUid, partNumber, content, checksum, baseUrl);
+        }
+        async completeContentTransfer(transferUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return completeTransfer(token, transferUid, baseUrl);
+        }
+        async cancelContentTransfer(transferUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return cancelTransfer(token, transferUid, baseUrl);
+        }
+        async uploadHomeFolderFile(path, content, options) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return uploadHomeFolderFile(token, path, content, options, baseUrl);
+        }
+        async downloadHomeFolderObject(objectUid, options = {}) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return downloadHomeFolderObject(token, objectUid, options, baseUrl);
+        }
+        async updateContentSource(sourceUid, update, etag) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return updateSource(token, sourceUid, update, etag, baseUrl);
+        }
+        async archiveContentSource(sourceUid, etag) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return archiveSource(token, sourceUid, etag, baseUrl);
+        }
+        async getContentSourcePermissions(sourceUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getSourcePermissions(token, sourceUid, baseUrl);
+        }
+        async getContentSourceSharing(sourceUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getSourceSharing(token, sourceUid, baseUrl);
+        }
+        async replaceContentSourceSharing(sourceUid, sharing, etag) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return replaceSourceSharing(token, sourceUid, sharing, etag, baseUrl);
+        }
+        async getContentOperation(operationUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return getOperation(token, operationUid, baseUrl);
+        }
+        async cancelContentOperation(operationUid) {
+            const { token, baseUrl } = this.contentsRequestContext();
+            return cancelOperation(token, operationUid, baseUrl);
+        }
+    };
+}

package/lib/client/mixins/IAMMixin.d.ts

@@ -4,8 +4,6 @@ import { CreditsDTO } from '../../models/CreditsDTO';
 import { HealthCheck } from '../../models/HealthCheck';
 import { SecretDTO } from '../../models/Secret';
 import type { CreateSecretRequest, UpdateSecretRequest } from '../../models/Secret';
-import { DatasourceDTO } from '../../models/Datasource';
-import type { CreateDatasourceRequest, UpdateDatasourceRequest } from '../../models/Datasource';
 /** IAM mixin providing authentication and user management. */
 export declare function IAMMixin<TBase extends Constructor>(Base: TBase): {
     new (...args: any[]): {
@@ -83,34 +81,5 @@ export declare function IAMMixin<TBase extends Constructor>(Base: TBase): {
          * @param secretId - Secret unique identifier
          */
         deleteSecret(secretId: string): Promise<void>;
-        /**
-         * Create a new datasource.
-         * @param data - Datasource configuration
-         * @returns Created datasource instance
-         */
-        createDatasource(data: CreateDatasourceRequest): Promise<DatasourceDTO>;
-        /**
-         * List all datasources.
-         * @returns Array of datasource instances
-         */
-        listDatasources(): Promise<DatasourceDTO[]>;
-        /**
-         * Get a specific datasource by ID.
-         * @param datasourceId - Datasource unique identifier
-         * @returns Datasource instance
-         */
-        getDatasource(datasourceId: string): Promise<DatasourceDTO>;
-        /**
-         * Update a datasource.
-         * @param datasourceId - Datasource unique identifier
-         * @param updates - Fields to update
-         * @returns Updated datasource instance
-         */
-        updateDatasource(datasourceId: string, updates: UpdateDatasourceRequest): Promise<DatasourceDTO>;
-        /**
-         * Delete a datasource.
-         * @param datasourceId - Datasource unique identifier
-         */
-        deleteDatasource(datasourceId: string): Promise<void>;
     };
 } & TBase;

package/lib/client/mixins/IAMMixin.js

@@ -10,12 +10,10 @@ import * as authentication from '../../api/iam/authentication.js';
 import * as profile from '../../api/iam/profile.js';
 import * as usage from '../../api/iam/usage.js';
 import * as secrets from '../../api/iam/secrets.js';
-import * as datasources from '../../api/iam/datasources.js';
 import { UserDTO } from '../../models/UserDTO.js';
 import { CreditsDTO } from '../../models/CreditsDTO.js';
 import { HealthCheck } from '../../models/HealthCheck.js';
 import { SecretDTO } from '../../models/Secret.js';
-import { DatasourceDTO } from '../../models/Datasource.js';
 /** IAM mixin providing authentication and user management. */
 export function IAMMixin(Base) {
     return class extends Base {
@@ -237,61 +235,5 @@ export function IAMMixin(Base) {
             const iamUrl = this.getIamUrl();
             await secrets.deleteSecret(token, secretId, iamUrl);
         }
-        // ========================================================================
-        // Datasources Management
-        // ========================================================================
-        /**
-         * Create a new datasource.
-         * @param data - Datasource configuration
-         * @returns Created datasource instance
-         */
-        async createDatasource(data) {
-            const token = this.getToken();
-            const iamUrl = this.getIamUrl();
-            const response = await datasources.createDatasource(token, data, iamUrl);
-            return new DatasourceDTO(response.datasource, this);
-        }
-        /**
-         * List all datasources.
-         * @returns Array of datasource instances
-         */
-        async listDatasources() {
-            const token = this.getToken();
-            const iamUrl = this.getIamUrl();
-            const response = await datasources.listDatasources(token, iamUrl);
-            return response.datasources.map(d => new DatasourceDTO(d, this));
-        }
-        /**
-         * Get a specific datasource by ID.
-         * @param datasourceId - Datasource unique identifier
-         * @returns Datasource instance
-         */
-        async getDatasource(datasourceId) {
-            const token = this.getToken();
-            const iamUrl = this.getIamUrl();
-            const response = await datasources.getDatasource(token, datasourceId, iamUrl);
-            return new DatasourceDTO(response.datasource, this);
-        }
-        /**
-         * Update a datasource.
-         * @param datasourceId - Datasource unique identifier
-         * @param updates - Fields to update
-         * @returns Updated datasource instance
-         */
-        async updateDatasource(datasourceId, updates) {
-            const token = this.getToken();
-            const iamUrl = this.getIamUrl();
-            const response = await datasources.updateDatasource(token, datasourceId, updates, iamUrl);
-            return new DatasourceDTO(response.datasource, this);
-        }
-        /**
-         * Delete a datasource.
-         * @param datasourceId - Datasource unique identifier
-         */
-        async deleteDatasource(datasourceId) {
-            const token = this.getToken();
-            const iamUrl = this.getIamUrl();
-            await datasources.deleteDatasource(token, datasourceId, iamUrl);
-        }
     };
 }

package/lib/components/animation/AnimatedText.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 /**
  * One piece of an animated line.
  *
@@ -17,8 +18,6 @@ export type AnimatedTextWords = {
      * it resolves to the CSS variable Primer sets.
      */
     color?: AnimatedTextColor;
-    /** Overrides the background of this piece alone. */
-    background?: string;
 };
 export type AnimatedTextColor = 'accent' | 'success' | 'attention' | 'severe' | 'done' | 'muted' | 'default' | (string & {});
 export interface AnimatedTextProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children' | 'color'> {
@@ -35,39 +34,6 @@ export interface AnimatedTextProps extends Omit<React.HTMLAttributes<HTMLSpanEle
     parts?: AnimatedTextPart[];
     /** Colour applied to cycling pieces that do not name their own. */
     color?: AnimatedTextColor;
-    /**
-     * The colours to draw cycling words in when neither the piece nor `color`
-     * names one. Each word takes a different colour, and changes colour as it
-     * changes word.
-     */
-    palette?: string[];
-    /**
-     * What sits behind the cycling words. White by default so a coloured word
-     * stays readable over artwork; pass `'transparent'` for a plain background
-     * where the plate is not wanted.
-     */
-    background?: string;
-    /**
-     * Hold every cycling piece at the width of the longest word it can show,
-     * instead of letting it size itself to whichever word is currently up.
-     *
-     * Off by default, because it changes the look: a piece is then as wide as
-     * its longest word even when a short one is showing, which is right for a
-     * line that reads as a slot being filled and wrong for one meant to read as
-     * an ordinary sentence.
-     *
-     * Turn it on when the line is set large, or is close to the width it has.
-     * Words of different lengths otherwise shove the rest of the sentence
-     * sideways on every tick, and the longest combination can take a line that
-     * fits on one row and drop it onto two — which, since a theme may set any
-     * typeface, is not something a caller can rule out by measuring.
-     *
-     * The reservation is made by the browser, not by a measurement: all of the
-     * words are laid into one grid cell and the ones not showing are hidden, so
-     * the piece is exactly as wide as the widest of them in the font and size it
-     * actually ends up with.
-     */
-    reserveWidth?: boolean;
     intervalMs?: number;
     transitionMs?: number;
 }
@@ -85,14 +51,6 @@ export interface AnimatedTextProps extends Omit<React.HTMLAttributes<HTMLSpanEle
  *   ]}
  * />
  * ```
- *
- * Set large, or set close to the width available, pass `reserveWidth` so the
- * cycling pieces hold the width of their longest word and the line neither
- * shifts on each tick nor wraps on its longest combination:
- *
- * ```tsx
- * <AnimatedText reserveWidth parts={[...]} background="transparent" />
- * ```
  */
-export declare function AnimatedText({ prefix, words, suffix, parts, color, palette, background, reserveWidth, intervalMs, transitionMs, style, ...rest }: AnimatedTextProps): JSX.Element;
+export declare function AnimatedText({ prefix, words, suffix, parts, color, intervalMs, transitionMs, style, ...rest }: AnimatedTextProps): JSX.Element;
 export default AnimatedText;