@gooddata/sdk-backend-tiger 11.64.0-alpha.1 → 11.64.0-alpha.3

package/esm/backend/workspace/references/index.js

@@ -1,9 +1,17 @@
 // (C) 2025-2026 GoodData Corporation
 import { uniqBy } from "lodash-es";
-import { ActionsApi_GetDependentEntitiesGraphFromEntryPoints, } from "@gooddata/api-client-tiger";
+import { ActionsApi_GetDependentEntitiesGraph, ActionsApi_GetDependentEntitiesGraphFromEntryPoints, } from "@gooddata/api-client-tiger";
 import { serializeObjRef } from "@gooddata/sdk-model";
-import { isTigerType, objectTypeToTigerIdType, tigerIdTypeToObjectType, } from "../../../types/refTypeMapping.js";
+import { objectTypeToTigerIdType, tigerIdTypeToObjectType } from "../../../types/refTypeMapping.js";
 const sdkObjectTypeToTigerType = objectTypeToTigerIdType;
+const referenceNodeTypeToObjectType = tigerIdTypeToObjectType;
+const workspaceGraphNodeTypeToObjectType = {
+    ...tigerIdTypeToObjectType,
+    automation: "automation",
+    filterView: "filterView",
+    userDataFilter: "userDataFilter",
+    memoryItem: "memoryItem",
+};
 export class TigerReferencesService {
     authCall;
     workspace;
@@ -23,6 +31,16 @@ export class TigerReferencesService {
         }
         return getGraph(this.authCall, this.workspace, roots, direction === "up" ? "DEPENDENTS" : "DEPENDENCIES");
     }
+    async getAllReferences() {
+        const entitiesGraph = await this.authCall(async (client) => {
+            const response = await ActionsApi_GetDependentEntitiesGraph(client.axios, client.basePath, {
+                workspaceId: this.workspace,
+            });
+            return response.data.graph;
+        });
+        // The full graph has the same edge order as the graph of dependencies.
+        return createGraph(entitiesGraph, new Set(), "DEPENDENCIES", workspaceGraphNodeTypeToObjectType);
+    }
 }
 async function getGraph(authCall, workspace, roots, relation) {
     const identifiers = roots.flatMap(refToEntityIdentifier);
@@ -40,11 +58,11 @@ async function getGraph(authCall, workspace, roots, relation) {
         });
         return response.data.graph;
     });
-    return createGraph(entitiesGraph, rootKeys, relation);
+    return createGraph(entitiesGraph, rootKeys, relation, referenceNodeTypeToObjectType);
 }
-function createGraph(entitiesGraph, rootKeys, relation) {
+function createGraph(entitiesGraph, rootKeys, relation, nodeTypes) {
     const nodes = entitiesGraph.nodes.flatMap((node) => {
-        const ref = tigerNodeToRef(node);
+        const ref = tigerNodeToRef(node, nodeTypes);
         if (!ref) {
             return [];
         }
@@ -55,8 +73,8 @@ function createGraph(entitiesGraph, rootKeys, relation) {
         if (!from || !to) {
             return [];
         }
-        const fromRef = tigerNodeToRef(from);
-        const toRef = tigerNodeToRef(to);
+        const fromRef = tigerNodeToRef(from, nodeTypes);
+        const toRef = tigerNodeToRef(to, nodeTypes);
         if (!fromRef || !toRef) {
             return [];
         }
@@ -74,10 +92,9 @@ function refToEntityIdentifier(ref) {
     const tigerType = ref.type ? sdkObjectTypeToTigerType[ref.type] : "visualizationObject";
     return isGraphSupportedType(tigerType) ? [{ id: ref.identifier, type: tigerType }] : [];
 }
-function tigerNodeToRef(node) {
-    return isTigerType(node.type)
-        ? { identifier: node.id, type: tigerIdTypeToObjectType[node.type] }
-        : undefined;
+function tigerNodeToRef(node, nodeTypes) {
+    const type = nodeTypes[node.type];
+    return type ? { identifier: node.id, type } : undefined;
 }
 // Prompt is not accepted by the dependency graph endpoint.
 function isGraphSupportedType(type) {

package/esm/backend/workspaces/index.d.ts

@@ -9,6 +9,6 @@ export declare class TigerWorkspaceQueryFactory implements IWorkspacesQueryFacto
     constructor(authCall: TigerAuthenticatedCallGuard, dateFormatter: DateFormatter, dateStringifier: DateStringifier, dateNormalizer: DateNormalizer);
     forUser(userId: string): IWorkspacesQuery;
     forCurrentUser(): IWorkspacesQuery;
-    createWorkspace({ id, title, parentWorkspace, }: IWorkspaceDefinition): Promise<IWorkspaceDescriptor>;
+    createWorkspace({ id, title, description, parentWorkspace, prefix, earlyAccessValues, cacheExtraLimit, dataSource, }: IWorkspaceDefinition): Promise<IWorkspaceDescriptor>;
 }
 //# sourceMappingURL=index.d.ts.map

package/esm/backend/workspaces/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/workspaces/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAGH,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAI/B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACH,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,eAAe,EACvB,MAAM,sDAAsD,CAAC;AAE9D,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAIxE,qBAAa,0BAA2B,YAAW,uBAAuB;IAElE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAJnC,YACqB,QAAQ,EAAE,2BAA2B,EACrC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,EAC/C;IAEG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAQ/C;IAEM,cAAc,IAAI,gBAAgB,CAOxC;IAEY,eAAe,CAAC,EACzB,EAAE,EACF,KAAK,EACL,eAAe,GAClB,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAgBtD;CACJ"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/workspaces/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAGH,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAI/B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACH,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,eAAe,EACvB,MAAM,sDAAsD,CAAC;AAE9D,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAIxE,qBAAa,0BAA2B,YAAW,uBAAuB;IAElE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAJnC,YACqB,QAAQ,EAAE,2BAA2B,EACrC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,EAC/C;IAEG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAQ/C;IAEM,cAAc,IAAI,gBAAgB,CAOxC;IAEY,eAAe,CAAC,EACzB,EAAE,EACF,KAAK,EACL,WAAW,EACX,eAAe,EACf,MAAM,EACN,iBAAiB,EACjB,eAAe,EACf,UAAU,GACb,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAuBtD;CACJ"}

package/esm/backend/workspaces/index.js

@@ -23,13 +23,20 @@ export class TigerWorkspaceQueryFactory {
     forCurrentUser() {
         return new TigerWorkspaceQuery(this.authCall, this.dateFormatter, this.dateStringifier, this.dateNormalizer);
     }
-    async createWorkspace({ id, title, parentWorkspace, }) {
+    async createWorkspace({ id, title, description, parentWorkspace, prefix, earlyAccessValues, cacheExtraLimit, dataSource, }) {
         const result = await this.authCall((client) => EntitiesApi_CreateEntityWorkspaces(client.axios, client.basePath, {
             jsonApiWorkspaceInDocument: {
                 data: {
                     id,
                     type: "workspace",
-                    attributes: { name: title },
+                    attributes: {
+                        name: title,
+                        description,
+                        prefix,
+                        earlyAccessValues,
+                        cacheExtraLimit,
+                        dataSource,
+                    },
                     relationships: parentWorkspace
                         ? { parent: { data: { id: parentWorkspace, type: "workspace" } } }
                         : undefined,

package/esm/convertors/fromBackend/DeclarativeModelConverter.d.ts

@@ -0,0 +1,4 @@
+import { type DeclarativeLdm } from "@gooddata/api-client-tiger";
+import { type IDeclarativeLogicalModel } from "@gooddata/sdk-model";
+export declare function convertDeclarativeLdm(ldm: DeclarativeLdm | undefined): IDeclarativeLogicalModel;
+//# sourceMappingURL=DeclarativeModelConverter.d.ts.map

package/esm/convertors/fromBackend/DeclarativeModelConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeclarativeModelConverter.d.ts","sourceRoot":"","sources":["../../../src/convertors/fromBackend/DeclarativeModelConverter.ts"],"names":[],"mappings":"AAEA,OAAO,EAcH,KAAK,cAAc,EAUtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAmBH,KAAK,wBAAwB,EAKhC,MAAM,qBAAqB,CAAC;AAU7B,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,cAAc,GAAG,SAAS,GAAG,wBAAwB,CAY/F"}

package/esm/convertors/fromBackend/DeclarativeModelConverter.js

@@ -0,0 +1,280 @@
+// (C) 2026 GoodData Corporation
+import { assertAllFieldsMapped, copyArray, mapArray, mapRecord, withoutUndefined, } from "../shared/declarativeFields.js";
+export function convertDeclarativeLdm(ldm) {
+    if (!ldm) {
+        return {};
+    }
+    const { calendars, datasetExtensions, datasets, dateInstances, ...unmapped } = ldm;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        calendars: mapRecord(calendars, convertCalendar),
+        datasetExtensions: mapArray(datasetExtensions, convertDatasetExtension),
+        datasets: mapArray(datasets, convertDataset),
+        dateInstances: mapArray(dateInstances, convertDateDataset),
+    });
+}
+function convertCalendar(calendar) {
+    const { definition, description, enabledGranularities, name, ...unmapped } = calendar;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        definition: convertCalendarDefinition(definition),
+        description,
+        enabledGranularities: enabledGranularities.map(({ granularity, prefix, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { granularity, prefix };
+        }),
+        name,
+    });
+}
+function convertCalendarDefinition(definition) {
+    if (definition.type === "fiscalYear") {
+        const { type, monthOffset, ...unmapped } = definition;
+        assertAllFieldsMapped(unmapped);
+        return { type, monthOffset };
+    }
+    const { type, dataSourceTables, ...unmapped } = definition;
+    assertAllFieldsMapped(unmapped);
+    return {
+        type,
+        dataSourceTables: mapRecord(dataSourceTables, ({ path, version, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { path: [...path], version };
+        }) ?? {},
+    };
+}
+function convertDatasetExtension(extension) {
+    const { id, workspaceDataFilterReferences, ...unmapped } = extension;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        id,
+        workspaceDataFilterReferences: mapArray(workspaceDataFilterReferences, convertWorkspaceDataFilterReference),
+    });
+}
+function convertWorkspaceDataFilterReference(reference) {
+    const { filterColumn, filterColumnDataType, filterId, ...unmapped } = reference;
+    assertAllFieldsMapped(unmapped);
+    const { id, type, ...unmappedId } = filterId;
+    assertAllFieldsMapped(unmappedId);
+    return { filterColumn, filterColumnDataType, filterId: { id, type } };
+}
+function convertDataset(dataset) {
+    const { aggregatedFacts, attributes, dataSourceTableId, description, facts, grain, id, precedence, references, sql, tags, title, type, workspaceDataFilterColumns, workspaceDataFilterReferences, ...unmapped } = dataset;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        aggregatedFacts: mapArray(aggregatedFacts, convertAggregatedFact),
+        attributes: mapArray(attributes, convertAttribute),
+        dataSourceTableId: dataSourceTableId && convertDataSourceTableId(dataSourceTableId),
+        description,
+        facts: mapArray(facts, convertFact),
+        grain: mapArray(grain, convertGrainIdentifier),
+        id,
+        precedence,
+        references: mapArray(references, convertReference),
+        sql: sql && convertDatasetSql(sql),
+        tags: copyArray(tags),
+        title,
+        type,
+        workspaceDataFilterColumns: mapArray(workspaceDataFilterColumns, convertWorkspaceDataFilterColumn),
+        workspaceDataFilterReferences: mapArray(workspaceDataFilterReferences, convertWorkspaceDataFilterReference),
+    });
+}
+function convertAggregatedFact(fact) {
+    const { description, id, isNullable, nullValue, sourceColumn, sourceColumnDataType, sourceFactReference, tags, ...unmapped } = fact;
+    assertAllFieldsMapped(unmapped);
+    const { operation, reference, ...unmappedReference } = sourceFactReference;
+    assertAllFieldsMapped(unmappedReference);
+    const { id: referenceId, type: referenceType, ...unmappedIdentifier } = reference;
+    assertAllFieldsMapped(unmappedIdentifier);
+    return withoutUndefined({
+        description,
+        id,
+        isNullable,
+        nullValue,
+        sourceColumn,
+        sourceColumnDataType,
+        sourceFactReference: { operation, reference: { id: referenceId, type: referenceType } },
+        tags: copyArray(tags),
+    });
+}
+function convertAttribute(attribute) {
+    const { conditionalFormatting, defaultView, description, id, isHidden, isNullable, labels, locale, nullValue, sortColumn, sortDirection, sourceColumn, sourceColumnDataType, tags, title, ...unmapped } = attribute;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        conditionalFormatting: convertConditionalFormatting(conditionalFormatting),
+        defaultView: defaultView && convertLabelIdentifier(defaultView),
+        description,
+        id,
+        isHidden,
+        isNullable,
+        labels: mapArray(labels, convertLabel),
+        locale,
+        nullValue,
+        sortColumn,
+        sortDirection,
+        sourceColumn,
+        sourceColumnDataType,
+        tags: copyArray(tags),
+        title,
+    });
+}
+function convertLabel(label) {
+    const { conditionalFormatting, description, geoAreaConfig, id, isHidden, isNullable, locale, nullValue, sourceColumn, sourceColumnDataType, tags, title, translations, valueType, ...unmapped } = label;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        conditionalFormatting: convertConditionalFormatting(conditionalFormatting),
+        description,
+        geoAreaConfig: geoAreaConfig && convertGeoAreaConfig(geoAreaConfig),
+        id,
+        isHidden,
+        isNullable,
+        locale,
+        nullValue,
+        sourceColumn,
+        sourceColumnDataType,
+        tags: copyArray(tags),
+        title,
+        translations: mapArray(translations, ({ locale, sourceColumn, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { locale, sourceColumn };
+        }),
+        valueType,
+    });
+}
+function convertConditionalFormatting(conditionalFormatting) {
+    if (!conditionalFormatting) {
+        return conditionalFormatting;
+    }
+    const { conditions, enabled, ...unmapped } = conditionalFormatting;
+    assertAllFieldsMapped(unmapped);
+    return { conditions: conditions.map(convertConditionalFormattingCondition), enabled };
+}
+function convertConditionalFormattingCondition(condition) {
+    const { format, id, operator, value, ...unmapped } = condition;
+    assertAllFieldsMapped(unmapped);
+    const { backgroundColor, color, scope, ...unmappedFormat } = format;
+    assertAllFieldsMapped(unmappedFormat);
+    return withoutUndefined({
+        format: withoutUndefined({ backgroundColor, color, scope }),
+        id,
+        operator,
+        value: convertConditionalFormattingValue(value),
+    });
+}
+function convertConditionalFormattingValue(value) {
+    switch (value.kind) {
+        case "none": {
+            const { kind, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind };
+        }
+        case "literal": {
+            const { kind, value: literal, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind, value: literal };
+        }
+        case "literalRange": {
+            const { kind, from, to, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind, from, to };
+        }
+        case "absoluteDate": {
+            const { from, to, kind, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { from, to, kind };
+        }
+        case "relativeDate": {
+            const { kind, granularity, from, to, ...unmapped } = value;
+            assertAllFieldsMapped(unmapped);
+            return { kind, granularity, from, to };
+        }
+    }
+}
+function convertDataSourceTableId(tableId) {
+    const { dataSourceId, id, path, type, ...unmapped } = tableId;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({ dataSourceId, id, path: copyArray(path), type });
+}
+function convertFact(fact) {
+    const { description, id, isHidden, isNullable, nullValue, sourceColumn, sourceColumnDataType, tags, title, ...unmapped } = fact;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        description,
+        id,
+        isHidden,
+        isNullable,
+        nullValue,
+        sourceColumn,
+        sourceColumnDataType,
+        tags: copyArray(tags),
+        title,
+    });
+}
+function convertGrainIdentifier(grain) {
+    const { id, type, ...unmapped } = grain;
+    assertAllFieldsMapped(unmapped);
+    return { id, type };
+}
+function convertReference(reference) {
+    const { identifier, multivalue, sourceColumnDataTypes, sourceColumns, sources, ...unmapped } = reference;
+    assertAllFieldsMapped(unmapped);
+    const { id, type, ...unmappedIdentifier } = identifier;
+    assertAllFieldsMapped(unmappedIdentifier);
+    return withoutUndefined({
+        identifier: { id, type },
+        multivalue,
+        sourceColumnDataTypes: copyArray(sourceColumnDataTypes),
+        sourceColumns: copyArray(sourceColumns),
+        sources: mapArray(sources, convertReferenceSource),
+    });
+}
+function convertReferenceSource(source) {
+    const { column, dataType, isNullable, nullValue, target, ...unmapped } = source;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        column,
+        dataType,
+        isNullable,
+        nullValue,
+        target: convertGrainIdentifier(target),
+    });
+}
+function convertDatasetSql(sql) {
+    const { dataSourceId, statement, ...unmapped } = sql;
+    assertAllFieldsMapped(unmapped);
+    return { dataSourceId, statement };
+}
+function convertWorkspaceDataFilterColumn(column) {
+    const { dataType, name, ...unmapped } = column;
+    assertAllFieldsMapped(unmapped);
+    return { dataType, name };
+}
+function convertDateDataset(dateDataset) {
+    const { conditionalFormatting, description, granularities, granularitiesFormatting, id, tags, title, ...unmapped } = dateDataset;
+    assertAllFieldsMapped(unmapped);
+    const { titleBase, titlePattern, ...unmappedFormatting } = granularitiesFormatting;
+    assertAllFieldsMapped(unmappedFormatting);
+    return withoutUndefined({
+        conditionalFormatting: convertConditionalFormatting(conditionalFormatting),
+        description,
+        granularities: [...granularities],
+        granularitiesFormatting: { titleBase, titlePattern },
+        id,
+        tags: copyArray(tags),
+        title,
+    });
+}
+function convertLabelIdentifier(identifier) {
+    const { id, type, ...unmapped } = identifier;
+    assertAllFieldsMapped(unmapped);
+    return { id, type };
+}
+function convertGeoAreaConfig(config) {
+    const { collection, ...unmapped } = config;
+    assertAllFieldsMapped(unmapped);
+    return { collection: convertGeoCollectionIdentifier(collection) };
+}
+function convertGeoCollectionIdentifier(identifier) {
+    const { id, kind, ...unmapped } = identifier;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({ id, kind });
+}

package/esm/convertors/fromBackend/PhysicalModelConverter.d.ts

@@ -0,0 +1,5 @@
+import { type ScanResultPdm, type ScanSqlResponse } from "@gooddata/api-client-tiger";
+import { type IDataSourceScanResult, type ISqlScanResult } from "@gooddata/sdk-model";
+export declare function convertScanResult(result: ScanResultPdm): IDataSourceScanResult;
+export declare function convertSqlScanResult(result: ScanSqlResponse): ISqlScanResult;
+//# sourceMappingURL=PhysicalModelConverter.d.ts.map

package/esm/convertors/fromBackend/PhysicalModelConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicalModelConverter.d.ts","sourceRoot":"","sources":["../../../src/convertors/fromBackend/PhysicalModelConverter.ts"],"names":[],"mappings":"AAEA,OAAO,EAIH,KAAK,aAAa,EAClB,KAAK,eAAe,EAEvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACH,KAAK,qBAAqB,EAK1B,KAAK,cAAc,EACtB,MAAM,qBAAqB,CAAC;AAI7B,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,qBAAqB,CAS9E;AAsDD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,cAAc,CAO5E"}

package/esm/convertors/fromBackend/PhysicalModelConverter.js

@@ -0,0 +1,63 @@
+// (C) 2026 GoodData Corporation
+import { assertAllFieldsMapped, mapArray, withoutUndefined } from "../shared/declarativeFields.js";
+export function convertScanResult(result) {
+    const { pdm, warnings, ...unmapped } = result;
+    assertAllFieldsMapped(unmapped);
+    const { tables, ...unmappedPdm } = pdm;
+    assertAllFieldsMapped(unmappedPdm);
+    return {
+        pdm: { tables: tables.map(convertPhysicalTable) },
+        warnings: mapArray(warnings, convertTableWarning) ?? [],
+    };
+}
+function convertPhysicalTable(table) {
+    const { columns, id, namePrefix, path, type, ...unmapped } = table;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        columns: columns.map(convertPhysicalColumn),
+        id,
+        namePrefix,
+        path: [...path],
+        type,
+    });
+}
+function convertPhysicalColumn(column) {
+    const { dataType, defaultLabelOf, description, isNullable, isPrimaryKey, name, nullValue, referencedTableColumn, referencedTableId, ...unmapped } = column;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        dataType,
+        defaultLabelOf,
+        description,
+        isNullable,
+        isPrimaryKey,
+        name,
+        nullValue,
+        referencedTableColumn,
+        referencedTableId,
+    });
+}
+function convertTableWarning(warning) {
+    const { columns, message, name, ...unmapped } = warning;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        columns: columns.map(({ message, name, ...rest }) => {
+            assertAllFieldsMapped(rest);
+            return { message, name };
+        }),
+        message,
+        name,
+    });
+}
+export function convertSqlScanResult(result) {
+    const { columns, dataPreview, ...unmapped } = result;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({
+        columns: columns.map(convertSqlColumn),
+        dataPreview: mapArray(dataPreview, (row) => [...row]),
+    });
+}
+function convertSqlColumn(column) {
+    const { dataType, description, name, nullValue, ...unmapped } = column;
+    assertAllFieldsMapped(unmapped);
+    return withoutUndefined({ dataType, description, name, nullValue });
+}

package/esm/convertors/fromBackend/genAIConvertor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"genAIConvertor.d.ts","sourceRoot":"","sources":["../../../src/convertors/fromBackend/genAIConvertor.ts"],"names":[],"mappings":"AAKA,OAAO,EAGH,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAK/B,KAAK,yBAAyB,EAM9B,KAAK,aAAa,EAUrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEH,KAAK,iBAAiB,EAGtB,KAAK,sBAAsB,EAE3B,KAAK,gCAAgC,EACrC,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAGhC,KAAK,gBAAgB,EAExB,MAAM,2BAA2B,CAAC;AAyCnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,wBAAgB,kCAAkC,CAAC,YAAY,EAAE,sBAAsB,GAAG,iBAAiB,CAS1G;AAED,wBAAgB,sCAAsC,CAClD,IAAI,EAAE,0BAA0B,EAChC,SAAS,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG,SAAS,EAC9D,OAAO,EAAE,qBAAqB,EAAE,EAChC,cAAc,EAAE,cAAc,EAC9B,MAAM,CAAC,EAAE,gBAAgB,EACzB,QAAQ,CAAC,EAAE,MAAM,GAClB,qBAAqB,GAAG,SAAS,CA6BnC;AAED,wBAAgB,uCAAuC,CACnD,KAAK,EAAE,0BAA0B,EAAE,EACnC,SAAS,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG,SAAS,EAC9D,cAAc,EAAE,cAAc,EAC9B,MAAM,CAAC,EAAE,gBAAgB,EACzB,QAAQ,CAAC,EAAE,MAAM,GAClB,qBAAqB,EAAE,CAkBzB;AAuND,wBAAgB,uCAAuC,CACnD,IAAI,EAAE,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EACrE,OAAO,CAAC,EAAE,MAAM,GACjB,sBAAsB,CAQxB;AAED;;;GAGG;AACH,wBAAgB,iDAAiD,CAC7D,IAAI,EAAE,yBAAyB,EAC/B,OAAO,CAAC,EAAE,MAAM,GACjB,gCAAgC,CAgBlC;AAED;;;;GAIG;AACH,wBAAgB,4CAA4C,CACxD,MAAM,EAAE,gCAAgC,GAAG,IAAI,GAAG,SAAS,GAC5D,2BAA2B,GAAG,SAAS,CAgEzC;AA2FD,wBAAgB,oCAAoC,CAChD,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GACvC,gBAAgB,CAQlB"}
+{"version":3,"file":"genAIConvertor.d.ts","sourceRoot":"","sources":["../../../src/convertors/fromBackend/genAIConvertor.ts"],"names":[],"mappings":"AAKA,OAAO,EAGH,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAK/B,KAAK,yBAAyB,EAM9B,KAAK,aAAa,EAUrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEH,KAAK,iBAAiB,EAGtB,KAAK,sBAAsB,EAE3B,KAAK,gCAAgC,EACrC,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAIhC,KAAK,gBAAgB,EAExB,MAAM,2BAA2B,CAAC;AAyCnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,wBAAgB,kCAAkC,CAAC,YAAY,EAAE,sBAAsB,GAAG,iBAAiB,CAS1G;AAED,wBAAgB,sCAAsC,CAClD,IAAI,EAAE,0BAA0B,EAChC,SAAS,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG,SAAS,EAC9D,OAAO,EAAE,qBAAqB,EAAE,EAChC,cAAc,EAAE,cAAc,EAC9B,MAAM,CAAC,EAAE,gBAAgB,EACzB,QAAQ,CAAC,EAAE,MAAM,GAClB,qBAAqB,GAAG,SAAS,CA6BnC;AAED,wBAAgB,uCAAuC,CACnD,KAAK,EAAE,0BAA0B,EAAE,EACnC,SAAS,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG,SAAS,EAC9D,cAAc,EAAE,cAAc,EAC9B,MAAM,CAAC,EAAE,gBAAgB,EACzB,QAAQ,CAAC,EAAE,MAAM,GAClB,qBAAqB,EAAE,CAkBzB;AA4ND,wBAAgB,uCAAuC,CACnD,IAAI,EAAE,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EACrE,OAAO,CAAC,EAAE,MAAM,GACjB,sBAAsB,CAQxB;AAED;;;GAGG;AACH,wBAAgB,iDAAiD,CAC7D,IAAI,EAAE,yBAAyB,EAC/B,OAAO,CAAC,EAAE,MAAM,GACjB,gCAAgC,CAgBlC;AAED;;;;GAIG;AACH,wBAAgB,4CAA4C,CACxD,MAAM,EAAE,gCAAgC,GAAG,IAAI,GAAG,SAAS,GAC5D,2BAA2B,GAAG,SAAS,CAgEzC;AA2FD,wBAAgB,oCAAoC,CAChD,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GACvC,gBAAgB,CAQlB"}

package/esm/convertors/fromBackend/genAIConvertor.js

@@ -105,6 +105,11 @@ function convertChatConversationContentFromBackend(content, history, dateNormali
                 callId: content.callId,
                 result: tryParseJson(content.result),
             };
+        case "skillsActivated":
+            return {
+                type: "skillsActivated",
+                skills: content.skills.map(({ name, title }) => ({ name, title })),
+            };
         default:
             // Unknown content type (e.g. sent by a newer backend): log and drop the item,
             // do not fail the whole conversation stream.

package/esm/convertors/shared/declarativeFields.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Fails to compile when a converter does not destructure every field of its input.
+ * Pass the rest of the destructured input object.
+ */
+export declare function assertAllFieldsMapped(_unmapped: Record<string, never>): void;
+/**
+ * Returns the object without the keys whose value is undefined. A key with a null value stays.
+ */
+export declare function withoutUndefined<T extends object>(obj: NoInfer<T>): T;
+export declare function copyArray<T>(array: T[]): T[];
+export declare function copyArray<T>(array: T[] | undefined): T[] | undefined;
+export declare function copyArray<T>(array: T[] | null | undefined): T[] | null | undefined;
+export declare function mapArray<T, R>(array: T[], fn: (item: T) => R): R[];
+export declare function mapArray<T, R>(array: T[] | undefined, fn: (item: T) => R): R[] | undefined;
+export declare function mapRecord<T, R>(record: {
+    [key: string]: T;
+} | undefined, fn: (item: T) => R): {
+    [key: string]: R;
+} | undefined;
+//# sourceMappingURL=declarativeFields.d.ts.map

package/esm/convertors/shared/declarativeFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarativeFields.d.ts","sourceRoot":"","sources":["../../../src/convertors/shared/declarativeFields.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI,CAAG;AAEhF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAErE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;AAC9C,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,SAAS,GAAG,CAAC,EAAE,GAAG,SAAS,CAAC;AACtE,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAKpF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;AACpE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,SAAS,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,CAAC;AAK5F,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC1B,MAAM,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAA;CAAE,GAAG,SAAS,EACxC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACnB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAA;CAAE,GAAG,SAAS,CAIlC"}

package/esm/convertors/shared/declarativeFields.js

@@ -0,0 +1,23 @@
+// (C) 2026 GoodData Corporation
+/**
+ * Fails to compile when a converter does not destructure every field of its input.
+ * Pass the rest of the destructured input object.
+ */
+export function assertAllFieldsMapped(_unmapped) { }
+/**
+ * Returns the object without the keys whose value is undefined. A key with a null value stays.
+ */
+export function withoutUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+export function copyArray(array) {
+    return array ? [...array] : array;
+}
+export function mapArray(array, fn) {
+    return array?.map((item) => fn(item));
+}
+export function mapRecord(record, fn) {
+    return record
+        ? Object.fromEntries(Object.entries(record).map(([key, value]) => [key, fn(value)]))
+        : undefined;
+}

package/esm/convertors/toBackend/DeclarativeModelConverter.d.ts

@@ -0,0 +1,4 @@
+import { type DeclarativeLdm } from "@gooddata/api-client-tiger";
+import { type IDeclarativeLogicalModel } from "@gooddata/sdk-model";
+export declare function convertDeclarativeLdmToBackend(ldm: IDeclarativeLogicalModel): DeclarativeLdm;
+//# sourceMappingURL=DeclarativeModelConverter.d.ts.map

package/esm/convertors/toBackend/DeclarativeModelConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeclarativeModelConverter.d.ts","sourceRoot":"","sources":["../../../src/convertors/toBackend/DeclarativeModelConverter.ts"],"names":[],"mappings":"AAEA,OAAO,EAcH,KAAK,cAAc,EAUtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAmBH,KAAK,wBAAwB,EAKhC,MAAM,qBAAqB,CAAC;AAU7B,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,wBAAwB,GAAG,cAAc,CAS5F"}