@gooddata/sdk-backend-tiger 11.64.0-alpha.2 → 11.64.0-alpha.4

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/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"}

package/esm/convertors/toBackend/DeclarativeModelConverter.js

@@ -0,0 +1,277 @@
+// (C) 2026 GoodData Corporation
+import { assertAllFieldsMapped, copyArray, mapArray, mapRecord, withoutUndefined, } from "../shared/declarativeFields.js";
+export function convertDeclarativeLdmToBackend(ldm) {
+    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 });
+}