@gooddata/sdk-ui-catalog 11.48.0-alpha.1 → 11.48.0-alpha.2

package/esm/AnalyticsCatalogDetail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnalyticsCatalogDetail.d.ts","sourceRoot":"","sources":["../src/AnalyticsCatalogDetail.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,OAAO,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE,OAAO,EAAiB,KAAK,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC3F,OAAO,EAEH,KAAK,0BAA0B,EAClC,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAIjE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAOxD;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,YAAY,CAAC;IACtG;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;OAEG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EACnC,OAAO,EACP,SAAS,EACT,MAAM,EACN,GAAG,SAAS,EACf,EAAE,4BAA4B,2CAM9B;AAED;;GAEG;AACH,MAAM,WAAW,mCAAoC,SAAQ,IAAI,CAC7D,0BAA0B,EAC1B,UAAU,GAAG,YAAY,CAC5B;IACG;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;OAEG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC3E;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,EAC1C,OAAO,EACP,SAAS,EACT,MAAM,EACN,GAAG,SAAS,EACf,EAAE,mCAAmC,2CAMrC"}
+{"version":3,"file":"AnalyticsCatalogDetail.d.ts","sourceRoot":"","sources":["../src/AnalyticsCatalogDetail.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,OAAO,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAMpE,OAAO,EAAiB,KAAK,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC3F,OAAO,EAEH,KAAK,0BAA0B,EAClC,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAMxD;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,YAAY,CAAC;IACtG;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;OAEG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EACnC,OAAO,EACP,SAAS,EACT,MAAM,EACN,GAAG,SAAS,EACf,EAAE,4BAA4B,2CAM9B;AAED;;GAEG;AACH,MAAM,WAAW,mCAAoC,SAAQ,IAAI,CAC7D,0BAA0B,EAC1B,UAAU,GAAG,YAAY,CAC5B;IACG;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;OAEG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC3E;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,EAC1C,OAAO,EACP,SAAS,EACT,MAAM,EACN,GAAG,SAAS,EACf,EAAE,mCAAmC,2CAMrC"}

package/esm/AnalyticsCatalogDetail.js

@@ -1,14 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { BackendProvider, WorkspaceProvider, useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
 import { ToastsCenterContextProvider } from "@gooddata/sdk-ui-kit";
+import { AsCodeMutationProvider } from "./asCode/AsCodeMutationContext.js";
+import { asCodeDescriptors } from "./asCodeRegistry.js";
 import { CatalogDetail } from "./catalogDetail/CatalogDetail.js";
 import { CatalogDetailContent, } from "./catalogDetail/CatalogDetailContent.js";
 import { CatalogResourceProvider } from "./catalogResource/CatalogResourceProvider.js";
 import { IntlWrapper } from "./localization/IntlWrapper.js";
-import { MetricMutationProvider } from "./metric/MetricMutationContext.js";
 import {} from "./objectType/types.js";
 import { OverlayProvider } from "./overlay/OverlayProvider.js";
-import { ParameterMutationProvider } from "./parameter/ParameterMutationContext.js";
 import { PermissionsProvider } from "./permission/PermissionsContext.js";
 import { usePermissionsQuery } from "./permission/usePermissionsQuery.js";
 import { QualityProvider } from "./quality/QualityContext.js";
@@ -28,5 +28,5 @@ function Providers(props) {
     const backend = useBackendStrict(props.backend);
     const workspace = useWorkspaceStrict(props.workspace);
     const permissionsState = usePermissionsQuery({ backend, workspace });
-    return (_jsx(BackendProvider, { backend: backend, children: _jsx(WorkspaceProvider, { workspace: workspace, children: _jsx(IntlWrapper, { locale: props.locale, children: _jsx(ToastsCenterContextProvider, { children: _jsx(OverlayProvider, { children: _jsx(PermissionsProvider, { permissionsState: permissionsState, children: _jsx(QualityProvider, { backend: backend, workspace: workspace, children: _jsx(CatalogResourceProvider, { backend: backend, workspace: workspace, children: _jsx(ParameterMutationProvider, { children: _jsx(MetricMutationProvider, { children: props.children }) }) }) }) }) }) }) }) }) }));
+    return (_jsx(BackendProvider, { backend: backend, children: _jsx(WorkspaceProvider, { workspace: workspace, children: _jsx(IntlWrapper, { locale: props.locale, children: _jsx(ToastsCenterContextProvider, { children: _jsx(OverlayProvider, { children: _jsx(PermissionsProvider, { permissionsState: permissionsState, children: _jsx(QualityProvider, { backend: backend, workspace: workspace, children: _jsx(CatalogResourceProvider, { backend: backend, workspace: workspace, children: _jsx(AsCodeMutationProvider, { descriptors: asCodeDescriptors, children: props.children }) }) }) }) }) }) }) }) }));
 }

package/esm/asCode/AsCodeCreateDialog.d.ts

@@ -0,0 +1,17 @@
+import type { ICatalogItem } from "../catalogItem/types.js";
+import type { IAsCodeDefinition, IAsCodeDescriptor } from "./descriptor.js";
+type Props = {
+    descriptor: IAsCodeDescriptor;
+    duplicateOf?: ICatalogItem;
+    duplicateSource?: IAsCodeDefinition;
+    onClose: () => void;
+    onCreated?: (item: ICatalogItem) => void;
+};
+/**
+ * Creates an as-code object — blank, or seeded from a copy source when duplicating. Generic over the
+ * entity type via its descriptor.
+ * @internal
+ */
+export declare function AsCodeCreateDialog({ descriptor, duplicateOf, duplicateSource, onClose, onCreated }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AsCodeCreateDialog.d.ts.map

package/esm/asCode/AsCodeCreateDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeCreateDialog.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeCreateDialog.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG5E,KAAK,KAAK,GAAG;IACT,UAAU,EAAE,iBAAiB,CAAC;IAE9B,WAAW,CAAC,EAAE,YAAY,CAAC;IAG3B,eAAe,CAAC,EAAE,iBAAiB,CAAC;IACpC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;CAC5C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,2CA8DzG"}

package/esm/asCode/AsCodeCreateDialog.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { useIntl } from "react-intl";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { AsCodeDialog } from "./AsCodeDialog.js";
+import { isDuplicateIdError } from "./copy.js";
+import { useAsCodeBase } from "./useAsCodeBase.js";
+/**
+ * Creates an as-code object — blank, or seeded from a copy source when duplicating. Generic over the
+ * entity type via its descriptor.
+ * @internal
+ */
+export function AsCodeCreateDialog({ descriptor, duplicateOf, duplicateSource, onClose, onCreated }) {
+    const intl = useIntl();
+    const { addSuccess, addError } = useToastMessage();
+    const { base: loadedSource, isLoading, port, } = useAsCodeBase(descriptor, duplicateOf, () => {
+        if (descriptor.messages.loadError) {
+            addError(descriptor.messages.loadError);
+        }
+        onClose();
+    });
+    const source = duplicateSource ?? loadedSource;
+    const copied = useMemo(() => (source === undefined ? undefined : descriptor.toCopy(source)), [descriptor, source]);
+    const initialDefinition = useMemo(() => copied ?? descriptor.emptyDefinition(intl.formatMessage(descriptor.messages.createDefaultTitle)), [copied, descriptor, intl]);
+    const copiedId = copied?.id;
+    const handleSubmit = useCallback(async (definition) => {
+        // A duplicate re-applies the copied source's non-YAML fields; otherwise persist the parsed YAML.
+        const toPersist = copied && descriptor.applyYamlEdits
+            ? descriptor.applyYamlEdits(copied, definition)
+            : definition;
+        let created;
+        try {
+            created = await port.create(toPersist);
+        }
+        catch (error) {
+            // The copied identity collided; let the backend derive a fresh one by dropping the id.
+            if (copiedId !== undefined && toPersist.id === copiedId && isDuplicateIdError(error)) {
+                const { id: _id, ...withoutId } = toPersist;
+                created = await port.create(withoutId);
+            }
+            else {
+                throw error;
+            }
+        }
+        onCreated?.(created);
+        onClose();
+        addSuccess(descriptor.messages.createSuccess);
+    }, [addSuccess, copied, copiedId, descriptor, onClose, onCreated, port]);
+    return (_jsx(AsCodeDialog, { descriptor: descriptor, mode: "create", isLoading: isLoading, initialDefinition: isLoading ? undefined : initialDefinition, onClose: onClose, onSubmit: handleSubmit }));
+}

package/esm/asCode/AsCodeDeleteDialog.d.ts

@@ -0,0 +1,17 @@
+import type { ICatalogItem } from "../catalogItem/types.js";
+import type { IAsCodeDescriptor } from "./descriptor.js";
+type Props = {
+    descriptor: IAsCodeDescriptor;
+    item: ICatalogItem;
+    onClose: () => void;
+    onDeleted: () => void;
+};
+/**
+ * Confirms deletion of an as-code object. A type that reports a referencing count (see
+ * `port.getReferencingObjectsCount`) withholds the confirm until the lookup resolves and warns when
+ * the object is in use; a type without one deletes straight away. Generic over the descriptor.
+ * @internal
+ */
+export declare function AsCodeDeleteDialog({ descriptor, item, onClose, onDeleted }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AsCodeDeleteDialog.d.ts.map

package/esm/asCode/AsCodeDeleteDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeDeleteDialog.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeDeleteDialog.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMzD,KAAK,KAAK,GAAG;IACT,UAAU,EAAE,iBAAiB,CAAC;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,2CAkEjF"}

package/esm/asCode/AsCodeDeleteDialog.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useState } from "react";
+import { FormattedMessage, defineMessages, useIntl } from "react-intl";
+import { useCancelablePromise } from "@gooddata/sdk-ui";
+import { ConfirmDialog, useToastMessage } from "@gooddata/sdk-ui-kit";
+import { useAsCodePort } from "./AsCodeMutationContext.js";
+const messages = defineMessages({
+    cancel: { id: "analyticsCatalog.asCode.dialog.cancel" },
+});
+/**
+ * Confirms deletion of an as-code object. A type that reports a referencing count (see
+ * `port.getReferencingObjectsCount`) withholds the confirm until the lookup resolves and warns when
+ * the object is in use; a type without one deletes straight away. Generic over the descriptor.
+ * @internal
+ */
+export function AsCodeDeleteDialog({ descriptor, item, onClose, onDeleted }) {
+    const intl = useIntl();
+    const { addSuccess, addError } = useToastMessage();
+    const port = useAsCodePort(descriptor.objectType);
+    const { messages: msg } = descriptor;
+    const [isDeleting, setIsDeleting] = useState(false);
+    // For a type with a usage lookup, withhold deletion until it resolves so the dependent-object
+    // warning can surface first; a type without one has nothing to wait for, so starts unblocked.
+    const lookup = port.getReferencingObjectsCount;
+    const { result, status } = useCancelablePromise({ promise: lookup ? () => lookup(item) : undefined }, [
+        item,
+        port,
+    ]);
+    // The lookup is advisory: no lookup or a failed one means no warning and nothing to wait for.
+    const referencingCount = !lookup || status === "error" ? 0 : result;
+    const displayName = item.title || item.identifier;
+    const handleDelete = useCallback(async () => {
+        setIsDeleting(true);
+        try {
+            await port.delete(item);
+            onDeleted();
+            onClose();
+            addSuccess(msg.deleteSuccess);
+        }
+        catch {
+            addError(msg.deleteError);
+            setIsDeleting(false);
+        }
+    }, [addError, addSuccess, item, msg, onClose, onDeleted, port]);
+    const handleClose = useCallback(() => {
+        if (!isDeleting) {
+            onClose();
+        }
+    }, [isDeleting, onClose]);
+    return (_jsxs(ConfirmDialog, { headline: intl.formatMessage(msg.deleteTitle), cancelButtonText: intl.formatMessage(messages.cancel), submitButtonText: intl.formatMessage(msg.deleteSubmit), isPositive: false, isSubmitDisabled: isDeleting || referencingCount === undefined, isCancelDisabled: isDeleting, showProgressIndicator: isDeleting, onCancel: handleClose, onClose: handleClose, onSubmit: handleDelete, displayCloseButton: !isDeleting, children: [_jsx(FormattedMessage, { ...msg.deleteBody, values: {
+                    name: displayName,
+                    b: (chunks) => _jsx("b", { children: chunks }),
+                } }), referencingCount && msg.deleteUsageWarning ? (_jsx("div", { children: _jsx(FormattedMessage, { ...msg.deleteUsageWarning, values: { count: referencingCount } }) })) : null] }));
+}

package/esm/asCode/AsCodeDetailActions.d.ts

@@ -0,0 +1,27 @@
+import { type MouseEvent } from "react";
+import type { OpenHandlerEvent } from "../catalogDetail/types.js";
+import type { ICatalogItem, ICatalogItemRef } from "../catalogItem/types.js";
+import type { IAsCodeDescriptor } from "./descriptor.js";
+/**
+ * @internal
+ */
+export interface IAsCodeDetailActionsProps {
+    descriptor: IAsCodeDescriptor;
+    item: ICatalogItem;
+    /** When provided and the descriptor declares an `openAction` (e.g. "Open in metric editor"), that
+     *  action opens the standalone editor through this handler; omitted, it is not offered. */
+    onOpen?: (event: MouseEvent, openEvent: OpenHandlerEvent) => void;
+    canShare?: boolean;
+    onShare?: () => void;
+    onCatalogItemCreate?: (item: ICatalogItem) => void;
+    onCatalogItemUpdate?: (item: ICatalogItem) => void;
+    onCatalogItemDelete?: (ref: ICatalogItemRef) => void;
+}
+/**
+ * Detail-panel actions for an as-code object: inline edit, duplicate, and delete via the shared
+ * dialogs, plus the Share button and the descriptor's open action if it declares one. Generic over the
+ * entity type via its descriptor.
+ * @internal
+ */
+export declare function AsCodeDetailActions({ descriptor, item, onOpen, canShare, onShare, onCatalogItemCreate, onCatalogItemUpdate, onCatalogItemDelete }: IAsCodeDetailActionsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AsCodeDetailActions.d.ts.map

package/esm/asCode/AsCodeDetailActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeDetailActions.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeDetailActions.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,UAAU,EAAkC,MAAM,OAAO,CAAC;AAS5F,OAAO,KAAK,EAAwB,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAK7E,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAY5E;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB;+FAC2F;IAC3F,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IACnD,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IACnD,mBAAmB,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;CACxD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAChC,UAAU,EACV,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,OAAO,EACP,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACtB,EAAE,yBAAyB,2CAgG3B"}

package/esm/asCode/AsCodeDetailActions.js

@@ -0,0 +1,66 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo, useState } from "react";
+import { useIntl } from "react-intl";
+import { useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { catalogDetailActionDelete, catalogDetailActionDuplicate } from "../automation/testIds.js";
+import { CatalogDetailActionBar } from "../catalogDetail/CatalogDetailActionBar.js";
+import { ShareButton } from "../catalogDetail/share/ShareButton.js";
+import { AsCodeCreateDialog } from "./AsCodeCreateDialog.js";
+import { AsCodeDeleteDialog } from "./AsCodeDeleteDialog.js";
+import { AsCodeEditDialog } from "./AsCodeEditDialog.js";
+const OPEN_ACTION_ID = "open";
+/**
+ * Detail-panel actions for an as-code object: inline edit, duplicate, and delete via the shared
+ * dialogs, plus the Share button and the descriptor's open action if it declares one. Generic over the
+ * entity type via its descriptor.
+ * @internal
+ */
+export function AsCodeDetailActions({ descriptor, item, onOpen, canShare, onShare, onCatalogItemCreate, onCatalogItemUpdate, onCatalogItemDelete, }) {
+    const intl = useIntl();
+    const workspaceId = useWorkspaceStrict();
+    const [dialog, setDialog] = useState(undefined);
+    const actions = useMemo(() => {
+        const result = [];
+        // The open action reaches the standalone editor via onOpen, so it is offered only when the host
+        // provides that handler and the descriptor declares one; the menu then never shows a dead item.
+        if (onOpen && descriptor.openAction) {
+            result.push({ id: OPEN_ACTION_ID, label: intl.formatMessage(descriptor.openAction) });
+        }
+        result.push({
+            id: "duplicate",
+            label: intl.formatMessage(descriptor.messages.duplicate),
+            dataTestId: catalogDetailActionDuplicate,
+        }, {
+            id: "delete",
+            label: intl.formatMessage(descriptor.messages.deleteSubmit),
+            isDestructive: true,
+            dataTestId: catalogDetailActionDelete,
+        });
+        return result;
+    }, [descriptor, intl, onOpen]);
+    const closeDialog = useCallback(() => setDialog(undefined), []);
+    const handleEditOpen = useCallback(() => setDialog({ kind: "edit", item }), [item]);
+    const handleActionsMenuSelect = useCallback((actionId, event) => {
+        if (actionId === OPEN_ACTION_ID) {
+            onOpen?.(event, {
+                item,
+                workspaceId,
+                newTab: event.metaKey || event.ctrlKey,
+                preventDefault: event.preventDefault.bind(event),
+            });
+            return;
+        }
+        if (actionId === "delete") {
+            setDialog({ kind: "delete", item });
+            return;
+        }
+        if (actionId === "duplicate") {
+            setDialog({ kind: "duplicate", duplicateOf: item });
+        }
+    }, [item, onOpen, workspaceId]);
+    const handleEditDuplicate = useCallback((source) => {
+        setDialog({ kind: "duplicate", duplicateSource: source });
+    }, []);
+    return (_jsxs(_Fragment, { children: [_jsx(CatalogDetailActionBar, { item: item, workspaceId: workspaceId, actions: actions, leadingActions: canShare && onShare ? _jsx(ShareButton, { onClick: onShare }) : null, onEditClick: handleEditOpen, onActionsMenuSelect: handleActionsMenuSelect }), dialog?.kind === "edit" ? (_jsx(AsCodeEditDialog, { descriptor: descriptor, item: dialog.item, onClose: closeDialog, onSaved: onCatalogItemUpdate, onDuplicate: handleEditDuplicate })) : null, dialog?.kind === "duplicate" ? (_jsx(AsCodeCreateDialog, { descriptor: descriptor, duplicateOf: dialog.duplicateOf, duplicateSource: dialog.duplicateSource, onClose: closeDialog, onCreated: onCatalogItemCreate })) : null, dialog?.kind === "delete" ? (_jsx(AsCodeDeleteDialog, { descriptor: descriptor, item: dialog.item, onClose: closeDialog, onDeleted: () => onCatalogItemDelete?.(dialog.item) })) : null] }));
+}

package/esm/asCode/AsCodeDialog.d.ts

@@ -0,0 +1,24 @@
+import type { IAsCodeDefinition, IAsCodeDescriptor } from "./descriptor.js";
+/** Whether the dialog creates a new object or edits an existing one. */
+type AsCodeDialogMode = "create" | "edit";
+type Props = {
+    descriptor: IAsCodeDescriptor;
+    mode: AsCodeDialogMode;
+    initialDefinition?: IAsCodeDefinition;
+    isLoading?: boolean;
+    fixedIdentifier?: string;
+    onClose: () => void;
+    onSubmit: (definition: IAsCodeDefinition) => Promise<void>;
+    onDuplicate?: (definition: IAsCodeDefinition) => void;
+};
+/**
+ * Generic create/edit dialog for an as-code object, entity-agnostic via its `descriptor`: it renders
+ * the shared editor chrome and delegates serialization, validation, and copy to the descriptor. The
+ * caller owns loading and persistence (passes `initialDefinition`, handles `onSubmit`); this component
+ * owns only the editing surface.
+ *
+ * @internal
+ */
+export declare function AsCodeDialog(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AsCodeDialog.d.ts.map

package/esm/asCode/AsCodeDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeDialog.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeDialog.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAa5E,wEAAwE;AACxE,KAAK,gBAAgB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1C,KAAK,KAAK,GAAG;IACT,UAAU,EAAE,iBAAiB,CAAC;IAC9B,IAAI,EAAE,gBAAgB,CAAC;IAIvB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,CAAC,UAAU,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACzD,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,2CAyKxC"}

package/esm/asCode/AsCodeDialog.js

@@ -0,0 +1,94 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { Suspense, lazy, useCallback, useMemo, useRef, useState } from "react";
+import { FormattedMessage, defineMessages, useIntl } from "react-intl";
+import { LoadingComponent } from "@gooddata/sdk-ui";
+import { ConfirmDialog, UiButton, UiIcon, UiLink, UiTooltip } from "@gooddata/sdk-ui-kit";
+import { useIsWhiteLabeled } from "../permission/PermissionsContext.js";
+import { extractBackendErrorDetail } from "../utils/backendError.js";
+const AsCodeEditorBody = lazy(() => import("./AsCodeEditorBody.js").then((m) => ({ default: m.AsCodeEditorBody })));
+// Chrome shared by every as-code type; the entity-specific copy comes from `descriptor.messages`.
+const messages = defineMessages({
+    createSubmit: { id: "analyticsCatalog.asCode.dialog.create.submit" },
+    editSubmit: { id: "analyticsCatalog.asCode.dialog.edit.submit" },
+    cancel: { id: "analyticsCatalog.asCode.dialog.cancel" },
+});
+/**
+ * Generic create/edit dialog for an as-code object, entity-agnostic via its `descriptor`: it renders
+ * the shared editor chrome and delegates serialization, validation, and copy to the descriptor. The
+ * caller owns loading and persistence (passes `initialDefinition`, handles `onSubmit`); this component
+ * owns only the editing surface.
+ *
+ * @internal
+ */
+export function AsCodeDialog(props) {
+    const { descriptor, mode, initialDefinition, isLoading = false, fixedIdentifier } = props;
+    const { onClose, onSubmit, onDuplicate } = props;
+    const intl = useIntl();
+    const isEdit = mode === "edit";
+    const isWhiteLabeled = useIsWhiteLabeled();
+    // The descriptor is fixed for the dialog's lifetime (one dialog edits one entity type), so calling
+    // its `useEditing` hook here is unconditional and stable — the rules of hooks hold.
+    const editing = descriptor.useEditing();
+    const { serialize, validate, completionSource, syntaxErrorMessage } = editing;
+    const initialYaml = useMemo(() => (initialDefinition === undefined ? "" : serialize(initialDefinition)), [initialDefinition, serialize]);
+    // The user's edits; `null` until they type. Submit falls back to `initialYaml`, so the editor
+    // mounts once with real data and is the single source of truth — no re-seed effect needed.
+    const yamlValue = useRef(null);
+    const [validationError, setValidationError] = useState(null);
+    const [submitError, setSubmitError] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [isDirty, setIsDirty] = useState(false);
+    const headlineMessage = intl.formatMessage(isEdit ? descriptor.messages.editTitle : descriptor.messages.createTitle);
+    const submitMessage = intl.formatMessage(isEdit ? messages.editSubmit : messages.createSubmit);
+    const cancelMessage = intl.formatMessage(messages.cancel);
+    const handleClose = useCallback(() => {
+        if (!isSubmitting) {
+            onClose();
+        }
+    }, [isSubmitting, onClose]);
+    const handleChange = useCallback((nextValue) => {
+        yamlValue.current = nextValue;
+        setIsDirty(true);
+        setSubmitError(null);
+        setValidationError(null);
+    }, []);
+    const handleSubmit = useCallback(async () => {
+        const result = validate(yamlValue.current ?? initialYaml, { fixedIdentifier });
+        if (!result.isValid) {
+            setValidationError(result.error);
+            return;
+        }
+        setIsSubmitting(true);
+        setSubmitError(null);
+        try {
+            await onSubmit(result.definition);
+        }
+        catch (error) {
+            setSubmitError(extractBackendErrorDetail(error) ?? intl.formatMessage(descriptor.messages.submitError));
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [descriptor, fixedIdentifier, initialYaml, intl, onSubmit, validate]);
+    const handleDuplicate = useCallback(() => {
+        if (!onDuplicate) {
+            return;
+        }
+        setSubmitError(null);
+        // A duplicate is a fresh object, so identity is not fixed even though we started from an edit.
+        const result = validate(yamlValue.current ?? initialYaml, { fixedIdentifier: undefined });
+        if (!result.isValid) {
+            setValidationError(result.error);
+            return;
+        }
+        onDuplicate(result.definition);
+    }, [initialYaml, onDuplicate, validate]);
+    const footerLeftRenderer = useCallback(() => (_jsxs("div", { className: "gd-ascode-dialog-footer-left", children: [isWhiteLabeled ? null : (_jsxs(UiLink, { variant: "secondary", href: descriptor.docsUrl, target: "_blank", rel: "noopener noreferrer", children: [
+                    _jsx(UiIcon, { type: "question", size: 14, color: "complementary-6" }), intl.formatMessage(descriptor.messages.help)] })), isEdit && onDuplicate ? (_jsx(UiButton, { label: intl.formatMessage(descriptor.messages.duplicate), variant: "tertiary", isDisabled: isSubmitting || isLoading, onClick: handleDuplicate })) : null] })), [descriptor, handleDuplicate, intl, isEdit, isLoading, isSubmitting, isWhiteLabeled, onDuplicate]);
+    const bodySpinner = (_jsx("div", { className: "gd-ascode-dialog-loading", children: _jsx(LoadingComponent, {}) }));
+    return (_jsx(ConfirmDialog, { className: "gd-ascode-dialog", containerClassName: "gd-ascode-dialog-overlay", headline: headlineMessage, cancelButtonText: cancelMessage, submitButtonText: submitMessage, isPositive: true, isSubmitDisabled: isSubmitting || isLoading || (isEdit && !isDirty), isCancelDisabled: isSubmitting, shouldCloseOnEscape: !isSubmitting, onCancel: handleClose, onClose: handleClose, onSubmit: handleSubmit, displayCloseButton: !isSubmitting, footerLeftRenderer: footerLeftRenderer, children: _jsx("div", { className: "gd-ascode-dialog-content", children: _jsx(Suspense, { fallback: bodySpinner, children: isLoading ? (bodySpinner) : (_jsxs(_Fragment, { children: [
+                        _jsxs("div", { className: "gd-ascode-dialog-section-header", children: [intl.formatMessage(descriptor.messages.sectionHeader), _jsx(UiTooltip, { arrowPlacement: "top", optimalPlacement: true, triggerBy: ["hover", "click", "focus"], anchor: _jsx(UiIcon, { type: "question", size: 14, color: "complementary-6" }), content: intl.formatMessage(descriptor.messages.sectionHeaderTooltip) })
+                            ] }), _jsx("div", { className: "gd-ascode-dialog-editor", children: _jsx(AsCodeEditorBody, { initialValue: initialYaml, onChange: handleChange, disabled: isSubmitting, completionSource: completionSource, syntaxErrorMessage: syntaxErrorMessage }) }), validationError || submitError ? (_jsxs("div", { className: "gd-ascode-dialog-error", children: [
+                                _jsx("span", { className: "gd-ascode-dialog-error-label", children: _jsx(FormattedMessage, { id: "analyticsCatalog.dialog.error.label" }) }), " ", validationError ?? submitError] })) : null] })) }) }) }));
+}

package/esm/asCode/AsCodeEditDialog.d.ts

@@ -0,0 +1,18 @@
+import type { ICatalogItem } from "../catalogItem/types.js";
+import type { IAsCodeDefinition, IAsCodeDescriptor } from "./descriptor.js";
+type Props = {
+    descriptor: IAsCodeDescriptor;
+    item: ICatalogItem;
+    onClose: () => void;
+    onSaved?: (item: ICatalogItem) => void;
+    onDuplicate?: (source: IAsCodeDefinition) => void;
+};
+/**
+ * Edits an existing as-code object. Its editable definition is resolved by {@link useAsCodeBase} —
+ * fetched for a type with `port.load` (a metric's MAQL), or mapped from the item for one without.
+ * Generic over the entity type via its descriptor.
+ * @internal
+ */
+export declare function AsCodeEditDialog({ descriptor, item, onClose, onSaved, onDuplicate }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AsCodeEditDialog.d.ts.map

package/esm/asCode/AsCodeEditDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeEditDialog.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeEditDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG5E,KAAK,KAAK,GAAG;IACT,UAAU,EAAE,iBAAiB,CAAC;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IAGvC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,KAAK,2CA6C1F"}

package/esm/asCode/AsCodeEditDialog.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback } from "react";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { AsCodeDialog } from "./AsCodeDialog.js";
+import { useAsCodeBase } from "./useAsCodeBase.js";
+/**
+ * Edits an existing as-code object. Its editable definition is resolved by {@link useAsCodeBase} —
+ * fetched for a type with `port.load` (a metric's MAQL), or mapped from the item for one without.
+ * Generic over the entity type via its descriptor.
+ * @internal
+ */
+export function AsCodeEditDialog({ descriptor, item, onClose, onSaved, onDuplicate }) {
+    const { addSuccess, addError } = useToastMessage();
+    const { base, isLoading, port } = useAsCodeBase(descriptor, item, () => {
+        if (descriptor.messages.loadError) {
+            addError(descriptor.messages.loadError);
+        }
+        onClose();
+    });
+    const handleSubmit = useCallback(async (definition) => {
+        if (base === undefined) {
+            return;
+        }
+        const saved = await port.update(base, definition);
+        onSaved?.(saved);
+        onClose();
+        addSuccess(descriptor.messages.updateSuccess);
+    }, [addSuccess, base, descriptor, onClose, onSaved, port]);
+    const handleDuplicate = useCallback((edited) => {
+        if (base === undefined || !onDuplicate) {
+            return;
+        }
+        // Overlay the edits onto the loaded base so the copy keeps fields the YAML can't express.
+        onDuplicate(descriptor.applyYamlEdits ? descriptor.applyYamlEdits(base, edited) : edited);
+    }, [base, descriptor, onDuplicate]);
+    return (_jsx(AsCodeDialog, { descriptor: descriptor, mode: "edit", isLoading: isLoading, initialDefinition: base, fixedIdentifier: item.identifier, onClose: onClose, onSubmit: handleSubmit, onDuplicate: onDuplicate ? handleDuplicate : undefined }));
+}

package/esm/asCode/AsCodeEditorBody.d.ts

@@ -0,0 +1,16 @@
+import type { CompletionSource } from "@codemirror/autocomplete";
+type Props = {
+    initialValue: string;
+    onChange: (value: string) => void;
+    disabled: boolean;
+    completionSource: CompletionSource;
+    syntaxErrorMessage: string;
+};
+/**
+ * The editor half of {@link AsCodeDialog}, split into its own module so the dialog can `lazy()`-load
+ * it: this keeps CodeMirror out of the eager catalog bundle. The completion source and syntax-error
+ * copy come from the entity's descriptor, so this stays entity-agnostic.
+ */
+export declare function AsCodeEditorBody({ initialValue, onChange, disabled, completionSource, syntaxErrorMessage }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AsCodeEditorBody.d.ts.map

package/esm/asCode/AsCodeEditorBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeEditorBody.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeEditorBody.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAIjE,KAAK,KAAK,GAAG;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,kBAAkB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAC7B,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EACrB,EAAE,KAAK,2CAUP"}

package/esm/asCode/AsCodeEditorBody.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { YamlEditor } from "@gooddata/sdk-ui-kit";
+/**
+ * The editor half of {@link AsCodeDialog}, split into its own module so the dialog can `lazy()`-load
+ * it: this keeps CodeMirror out of the eager catalog bundle. The completion source and syntax-error
+ * copy come from the entity's descriptor, so this stays entity-agnostic.
+ */
+export function AsCodeEditorBody({ initialValue, onChange, disabled, completionSource, syntaxErrorMessage, }) {
+    return (_jsx(YamlEditor, { initialValue: initialValue, onChange: onChange, disabled: disabled, completionSource: completionSource, syntaxErrorMessage: syntaxErrorMessage }));
+}

package/esm/asCode/AsCodeMutationContext.d.ts

@@ -0,0 +1,24 @@
+import { type PropsWithChildren } from "react";
+import type { ObjectType } from "../objectType/types.js";
+import type { AsCodeObjectType, IAsCodeDescriptor, IAsCodeMutationPort } from "./descriptor.js";
+type AsCodeMutations = Partial<Record<AsCodeObjectType, IAsCodeMutationPort>>;
+type ProviderProps = PropsWithChildren<{
+    /** Descriptors for each as-code capable object type; used to build adapters. */
+    descriptors?: Record<AsCodeObjectType, IAsCodeDescriptor>;
+    /** Per-type port overrides for tests. */
+    ports?: AsCodeMutations;
+}>;
+/**
+ * Builds and provides one mutation port per supplied descriptor. Must be placed inside `BackendProvider`
+ * and `WorkspaceProvider`.
+ * @internal
+ */
+export declare function AsCodeMutationProvider({ children, descriptors, ports }: ProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * The mutation port for one as-code type. Throws for a non-as-code type (a caller should only reach
+ * this via a resolved descriptor) or when the provider is missing.
+ * @internal
+ */
+export declare function useAsCodePort(type: ObjectType): IAsCodeMutationPort;
+export {};
+//# sourceMappingURL=AsCodeMutationContext.d.ts.map

package/esm/asCode/AsCodeMutationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsCodeMutationContext.d.ts","sourceRoot":"","sources":["../../src/asCode/AsCodeMutationContext.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAsC,MAAM,OAAO,CAAC;AAInF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEhG,KAAK,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,CAAC,CAAC;AAI9E,KAAK,aAAa,GAAG,iBAAiB,CAAC;IACnC,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;IAC1D,yCAAyC;IACzC,KAAK,CAAC,EAAE,eAAe,CAAC;CAC3B,CAAC,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,aAAa,2CAerF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,CAUnE"}

package/esm/asCode/AsCodeMutationContext.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { createContext, useContext, useMemo } from "react";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+const AsCodeMutationContext = createContext(null);
+/**
+ * Builds and provides one mutation port per supplied descriptor. Must be placed inside `BackendProvider`
+ * and `WorkspaceProvider`.
+ * @internal
+ */
+export function AsCodeMutationProvider({ children, descriptors, ports }) {
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    const mutations = useMemo(() => {
+        const built = {};
+        // Object.entries widens the key to string; the map's own type guarantees it is an AsCodeObjectType.
+        const entries = Object.entries(descriptors ?? {});
+        for (const [type, descriptor] of entries) {
+            built[type] = descriptor.createMutationPort(backend, workspace);
+        }
+        return { ...built, ...ports };
+    }, [backend, workspace, descriptors, ports]);
+    return _jsx(AsCodeMutationContext.Provider, { value: mutations, children: children });
+}
+/**
+ * The mutation port for one as-code type. Throws for a non-as-code type (a caller should only reach
+ * this via a resolved descriptor) or when the provider is missing.
+ * @internal
+ */
+export function useAsCodePort(type) {
+    const mutations = useContext(AsCodeMutationContext);
+    if (!mutations) {
+        throw new Error("useAsCodePort must be used within AsCodeMutationProvider");
+    }
+    const port = mutations[type];
+    if (!port) {
+        throw new Error(`No as-code mutation port is registered for object type "${type}".`);
+    }
+    return port;
+}

package/esm/asCode/copy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derives the identity (id + title) of a copied as-code object from the original; the remaining
+ * fields are copied by each type.
+ *
+ * The title gains a ` (2)` suffix, or increments an existing ` (N)`. The id is re-derived from that
+ * title or dropped (see `shouldOmitCopiedId`). Absent fields are left off so a spread does not
+ * introduce them.
+ */
+export declare function deriveCopyIdentity(source: {
+    id?: string;
+    title?: string;
+}): {
+    id?: string;
+    title?: string;
+};
+/** A create failed because the chosen id already exists (backend responds with HTTP 409). */
+export declare function isDuplicateIdError(error: unknown): boolean;
+//# sourceMappingURL=copy.d.ts.map

package/esm/asCode/copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../src/asCode/copy.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACzE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAOA;AAwCD,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE1D"}