@uipath/data-fabric-tool 1.1.0 → 1.195.0

package/src/commands/choice-sets.ts

@@ -1,14 +1,32 @@
 import {
     type CommandExample,
     catchError,
+    createHiddenDeprecatedTenantOption,
     extractErrorMessage,
     OutputFormatter,
     processContext,
     RESULTS,
 } from "@uipath/common";
+import type {
+    ChoiceSetCreateOptions,
+    ChoiceSetServiceModel,
+    ChoiceSetUpdateOptions,
+    ChoiceSetValueInsertOptions,
+} from "@uipath/uipath-typescript";
 import type { Command } from "commander";
-import { extractCursorValue } from "../utils/pagination";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { fail, requireDestructiveConfirmation } from "../utils/output";
+import { connectOrFail } from "../utils/sdk-client";
+
+const OUTPUT_CODES = {
+    ChoiceSetList: "ChoiceSetList",
+    ChoiceSetValues: "ChoiceSetValues",
+    ChoiceSetCreated: "ChoiceSetCreated",
+    ChoiceSetUpdated: "ChoiceSetUpdated",
+    ChoiceSetDeleted: "ChoiceSetDeleted",
+    ChoiceSetValueCreated: "ChoiceSetValueCreated",
+    ChoiceSetValueUpdated: "ChoiceSetValueUpdated",
+    ChoiceSetValuesDeleted: "ChoiceSetValuesDeleted",
+} as const;
 
 interface ListOptions {
     tenant?: string;
@@ -21,24 +39,59 @@ interface GetOptions {
     cursor?: string;
 }
 
+interface CreateOptions {
+    tenant?: string;
+    displayName?: string;
+    description?: string;
+    folderKey?: string;
+}
+
+interface UpdateOptions {
+    tenant?: string;
+    displayName?: string;
+    description?: string;
+}
+
+interface DeleteOptions {
+    tenant?: string;
+    confirm?: boolean;
+    reason?: string;
+}
+
+interface ValueCreateOptions {
+    tenant?: string;
+    displayName?: string;
+}
+
+interface ValueUpdateOptions {
+    tenant?: string;
+}
+
+interface ValueDeleteOptions {
+    tenant?: string;
+    ids?: string;
+    confirm?: boolean;
+    reason?: string;
+}
+
 const CHOICE_SETS_LIST_EXAMPLES: CommandExample[] = [
     {
         Description:
-            "List all Data Fabric choice sets. The returned 'ID' is the value to pass as 'choiceSetId' on a CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity field, or to 'df choice-sets get <id>'.",
+            "List all Data Fabric choice sets. The returned 'id' is the value to pass as 'choiceSetId' on a CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity field, or to 'df choice-sets list-values <id>'.",
         Command: "uip df choice-sets list",
         Output: {
-            Code: "ChoiceSetList",
+            Code: OUTPUT_CODES.ChoiceSetList,
             Data: [
                 {
-                    ID: "c1d2e3f4-0000-0000-0000-000000000001",
-                    Name: "ExpenseTypes",
-                    DisplayName: "Expense Types",
-                    Description: "Categories of expenses",
-                    FolderId: "f1000000-0000-0000-0000-000000000001",
-                    CreatedBy: "u1000000-0000-0000-0000-000000000001",
-                    UpdatedBy: "u1000000-0000-0000-0000-000000000001",
-                    CreatedTime: "2026-01-01T00:00:00Z",
-                    UpdatedTime: "2026-01-02T00:00:00Z",
+                    id: "c1d2e3f4-0000-0000-0000-000000000001",
+                    name: "ExpenseTypes",
+                    displayName: "Expense Types",
+                    description: "Categories of expenses",
+                    folderId: "f1000000-0000-0000-0000-000000000001",
+                    createdBy: "u1000000-0000-0000-0000-000000000001",
+                    updatedBy: "u1000000-0000-0000-0000-000000000001",
+                    createdTime: "2026-01-01T00:00:00Z",
+                    updatedTime: "2026-01-02T00:00:00Z",
                 },
             ],
         },
@@ -48,28 +101,70 @@ const CHOICE_SETS_LIST_EXAMPLES: CommandExample[] = [
 const CHOICE_SETS_GET_EXAMPLES: CommandExample[] = [
     {
         Description:
-            "Get values for a choice set. The 'NumberId' on each value is the integer to pass when inserting or updating a record into a CHOICE_SET_SINGLE field (or in an array for CHOICE_SET_MULTIPLE).",
+            "List the values of a choice set. The 'numberId' on each value is the integer to pass when inserting or updating a record into a CHOICE_SET_SINGLE field (or in an array for CHOICE_SET_MULTIPLE).",
         Command:
-            "uip df choice-sets get c1d2e3f4-0000-0000-0000-000000000001 --limit 2",
+            "uip df choice-sets list-values c1d2e3f4-0000-0000-0000-000000000001 --limit 2",
         Output: {
-            Code: "ChoiceSetValues",
+            Code: OUTPUT_CODES.ChoiceSetValues,
             Data: {
-                TotalCount: 2,
-                Values: [
+                items: [
                     {
-                        Id: "v1000000-0000-0000-0000-000000000001",
-                        Name: "travel",
-                        DisplayName: "Travel",
-                        NumberId: 1,
+                        id: "v1000000-0000-0000-0000-000000000001",
+                        name: "travel",
+                        displayName: "Travel",
+                        numberId: 0,
                     },
                     {
-                        Id: "v1000000-0000-0000-0000-000000000002",
-                        Name: "meals",
-                        DisplayName: "Meals",
-                        NumberId: 2,
+                        id: "v1000000-0000-0000-0000-000000000002",
+                        name: "meals",
+                        displayName: "Meals",
+                        numberId: 1,
                     },
                 ],
-                HasNextPage: false,
+                totalCount: 2,
+                hasNextPage: false,
+            },
+        },
+    },
+];
+
+const CHOICE_SETS_CREATE_EXAMPLES: CommandExample[] = [
+    {
+        Description:
+            "Create a choice set. The returned 'ID' is used as 'choiceSetId' on CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity fields. Add values with 'df choice-set-values create'.",
+        Command:
+            'uip df choice-sets create ExpenseTypes --display-name "Expense Types" --description "Categories of expenses"',
+        Output: {
+            Code: OUTPUT_CODES.ChoiceSetCreated,
+            Data: { ID: "c1d2e3f4-0000-0000-0000-000000000001" },
+        },
+    },
+];
+
+const CHOICE_SETS_UPDATE_EXAMPLES: CommandExample[] = [
+    {
+        Description:
+            "Update a choice set's display name and/or description. At least one of --display-name or --description is required.",
+        Command:
+            'uip df choice-sets update c1d2e3f4-0000-0000-0000-000000000001 --display-name "Expense Categories"',
+        Output: {
+            Code: OUTPUT_CODES.ChoiceSetUpdated,
+            Data: { ID: "c1d2e3f4-0000-0000-0000-000000000001" },
+        },
+    },
+];
+
+const CHOICE_SETS_DELETE_EXAMPLES: CommandExample[] = [
+    {
+        Description:
+            "Delete a choice set (irreversible — requires --confirm and --reason).",
+        Command:
+            'uip df choice-sets delete c1d2e3f4-0000-0000-0000-000000000001 --confirm --reason "no longer used"',
+        Output: {
+            Code: OUTPUT_CODES.ChoiceSetDeleted,
+            Data: {
+                ID: "c1d2e3f4-0000-0000-0000-000000000001",
+                Reason: "no longer used",
             },
         },
     },
@@ -79,68 +174,46 @@ export const registerChoiceSetsCommand = (program: Command) => {
     const choiceSets = program
         .command("choice-sets")
         .description(
-            "Browse Data Fabric choice sets. Read-only: choice sets are authored in the Data Fabric web UI and cannot be created, updated, or deleted from the CLI. " +
-                "Use 'list' to find a choice set's ID (used as 'choiceSetId' on CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity fields), and 'get' to inspect its values.",
+            "Manage Data Fabric choice sets — the enumerated value lists referenced by CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity fields. " +
+                "Use 'list'/'list-values' to inspect, and 'create'/'update'/'delete' to manage them. Manage individual values with 'df choice-set-values'.",
         );
 
     choiceSets
         .command("list")
         .description("List all Data Fabric choice sets")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .examples(CHOICE_SETS_LIST_EXAMPLES)
         .trackedAction(processContext, async (options: ListOptions) => {
-            const [clientError, sdk] = await catchError(
-                createDataFabricClient(options.tenant),
-            );
-
-            if (clientError) {
-                OutputFormatter.error({
-                    Result: RESULTS.Failure,
-                    Message: "Error connecting to Data Fabric",
-                    Instructions: await extractErrorMessage(clientError),
-                });
-                processContext.exit(1);
-                return;
-            }
+            const sdk = await connectOrFail(options.tenant);
+            if (!sdk) return;
 
             const [listError, result] = await catchError(
                 sdk.entities.choicesets.getAll(),
             );
 
             if (listError) {
-                OutputFormatter.error({
-                    Result: RESULTS.Failure,
-                    Message: "Error listing choice sets",
-                    Instructions: await extractErrorMessage(listError),
-                });
-                processContext.exit(1);
-                return;
+                return fail(
+                    "Error listing choice sets",
+                    await extractErrorMessage(listError),
+                );
             }
 
-            const items = (result ?? []).map((cs) => ({
-                ID: (cs as { id?: string }).id,
-                Name: cs.name,
-                DisplayName: cs.displayName || cs.name,
-                Description: cs.description || "",
-                FolderId: cs.folderId,
-                CreatedBy: cs.createdBy,
-                UpdatedBy: cs.updatedBy,
-                CreatedTime: cs.createdTime,
-                UpdatedTime: cs.updatedTime,
-            }));
-
             OutputFormatter.success({
                 Result: RESULTS.Success,
-                Code: "ChoiceSetList",
-                Data: items,
+                Code: OUTPUT_CODES.ChoiceSetList,
+                Data: result ?? [],
             });
         });
 
     choiceSets
-        .command("get")
-        .description("Get values for a Data Fabric choice set")
+        .command("list-values")
+        .description("List the values of a Data Fabric choice set")
         .argument("<choice-set-id>", "Choice set ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .option(
             "-l, --limit <number>",
             "Number of values to return per page",
@@ -160,58 +233,36 @@ export const registerChoiceSetsCommand = (program: Command) => {
             async (choiceSetId: string, options: GetOptions) => {
                 const pageSize = Number(options.limit ?? "50");
                 if (Number.isNaN(pageSize) || pageSize < 1) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Invalid --limit value",
-                        Instructions: "Provide a positive integer for --limit.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Invalid --limit value",
+                        "Provide a positive integer for --limit.",
+                    );
                 }
 
                 if (
                     options.cursor !== undefined &&
                     options.offset !== undefined
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "--offset and --cursor are mutually exclusive",
-                        Instructions:
-                            "Use --offset to jump to a position by record count, or --cursor to continue from a previous response.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "--offset and --cursor are mutually exclusive",
+                        "Use --offset to jump to a position by record count, or --cursor to continue from a previous response.",
+                    );
                 }
 
                 let jumpToPage: number | undefined;
                 if (options.offset !== undefined) {
                     const offsetValue = Number(options.offset);
                     if (Number.isNaN(offsetValue) || offsetValue < 0) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Invalid --offset value",
-                            Instructions:
-                                "Provide a non-negative integer for --offset.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Invalid --offset value",
+                            "Provide a non-negative integer for --offset.",
+                        );
                     }
                     jumpToPage = Math.floor(offsetValue / pageSize) + 1;
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const paginationOptions =
                     options.cursor !== undefined
@@ -228,57 +279,410 @@ export const registerChoiceSetsCommand = (program: Command) => {
                 );
 
                 if (getError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error getting choice set '${choiceSetId}'`,
-                        Instructions: await extractErrorMessage(getError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error getting choice set '${choiceSetId}'`,
+                        await extractErrorMessage(getError),
+                    );
                 }
 
-                type ChoiceSetValue = {
-                    id?: string;
-                    name?: string;
-                    displayName?: string;
-                    numberId?: number;
-                    createdTime?: string;
-                    updatedTime?: string;
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: OUTPUT_CODES.ChoiceSetValues,
+                    Data: result,
+                });
+            },
+        );
+
+    choiceSets
+        .command("create")
+        .description("Create a new Data Fabric choice set")
+        .argument(
+            "<name>",
+            "Choice set name (must start with a letter; letters, numbers, and underscores only)",
+        )
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
+        .option("--display-name <name>", "Human-readable display name")
+        .option("--description <text>", "Choice set description")
+        .option(
+            "--folder-key <uuid>",
+            "UUID of the folder to place the choice set in (defaults to the tenant-level folder)",
+        )
+        .examples(CHOICE_SETS_CREATE_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (name: string, options: CreateOptions) => {
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
+
+                const createOpts: ChoiceSetCreateOptions = {
+                    ...(options.displayName !== undefined && {
+                        displayName: options.displayName,
+                    }),
+                    ...(options.description !== undefined && {
+                        description: options.description,
+                    }),
+                    ...(options.folderKey !== undefined && {
+                        folderKey: options.folderKey,
+                    }),
                 };
-                const response = result as unknown as {
-                    items?: ChoiceSetValue[];
-                    totalCount?: number;
-                    hasNextPage?: boolean;
-                    nextCursor?: unknown;
-                    currentPage?: number;
-                    totalPages?: number;
+
+                const choiceSetService: ChoiceSetServiceModel =
+                    sdk.entities.choicesets;
+                const [createError, choiceSetId] = await catchError(
+                    choiceSetService.create(
+                        name,
+                        Object.keys(createOpts).length > 0
+                            ? createOpts
+                            : undefined,
+                    ),
+                );
+
+                if (createError) {
+                    return fail(
+                        "Error creating choice set",
+                        await extractErrorMessage(createError),
+                    );
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: OUTPUT_CODES.ChoiceSetCreated,
+                    Data: { ID: choiceSetId },
+                });
+            },
+        );
+
+    choiceSets
+        .command("update")
+        .description("Update the metadata of a Data Fabric choice set")
+        .argument("<choice-set-id>", "Choice set ID")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
+        .option("--display-name <name>", "New display name")
+        .option("--description <text>", "New description")
+        .examples(CHOICE_SETS_UPDATE_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (choiceSetId: string, options: UpdateOptions) => {
+                if (
+                    options.displayName === undefined &&
+                    options.description === undefined
+                ) {
+                    return fail(
+                        "No update fields provided",
+                        "Provide at least one of --display-name or --description.",
+                    );
+                }
+
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
+
+                const updateOpts: ChoiceSetUpdateOptions = {
+                    ...(options.displayName !== undefined && {
+                        displayName: options.displayName,
+                    }),
+                    ...(options.description !== undefined && {
+                        description: options.description,
+                    }),
                 };
-                const values = (response.items ?? []).map((v) => ({
-                    Id: v.id,
-                    Name: v.name,
-                    DisplayName: v.displayName || v.name,
-                    NumberId: v.numberId,
-                    CreatedTime: v.createdTime,
-                    UpdatedTime: v.updatedTime,
-                }));
-                const nextCursor = extractCursorValue(response.nextCursor);
+
+                const choiceSetService: ChoiceSetServiceModel =
+                    sdk.entities.choicesets;
+                const [updateError] = await catchError(
+                    choiceSetService.updateById(choiceSetId, updateOpts),
+                );
+
+                if (updateError) {
+                    return fail(
+                        `Error updating choice set '${choiceSetId}'`,
+                        await extractErrorMessage(updateError),
+                    );
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: OUTPUT_CODES.ChoiceSetUpdated,
+                    Data: { ID: choiceSetId },
+                });
+            },
+        );
+
+    choiceSets
+        .command("delete")
+        .description("Delete a Data Fabric choice set (irreversible)")
+        .argument("<choice-set-id>", "Choice set ID")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
+        .option("--confirm", "Acknowledge this is an irreversible operation")
+        .option(
+            "--reason <reason>",
+            "Reason for the deletion — echoed back in the response so the caller can log it",
+        )
+        .examples(CHOICE_SETS_DELETE_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (choiceSetId: string, options: DeleteOptions) => {
+                const reason = requireDestructiveConfirmation(
+                    options,
+                    'Pass --reason "<text>" to record why the choice set is being deleted.',
+                );
+                if (reason === null) return;
+
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
+
+                const choiceSetService: ChoiceSetServiceModel =
+                    sdk.entities.choicesets;
+                const [deleteError] = await catchError(
+                    choiceSetService.deleteById(choiceSetId),
+                );
+
+                if (deleteError) {
+                    return fail(
+                        `Error deleting choice set '${choiceSetId}'`,
+                        await extractErrorMessage(deleteError),
+                    );
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: OUTPUT_CODES.ChoiceSetDeleted,
+                    Data: { ID: choiceSetId, Reason: reason },
+                });
+            },
+        );
+};
+
+const CHOICE_SET_VALUES_CREATE_EXAMPLES: CommandExample[] = [
+    {
+        Description:
+            "Add a value to a choice set. The returned 'numberId' is the integer to pass when inserting or updating records into a CHOICE_SET_SINGLE field (or in an array for CHOICE_SET_MULTIPLE).",
+        Command:
+            'uip df choice-set-values create c1d2e3f4-0000-0000-0000-000000000001 travel --display-name "Travel"',
+        Output: {
+            Code: OUTPUT_CODES.ChoiceSetValueCreated,
+            Data: {
+                id: "v1000000-0000-0000-0000-000000000001",
+                name: "travel",
+                displayName: "Travel",
+                numberId: 0,
+            },
+        },
+    },
+];
+
+const CHOICE_SET_VALUES_UPDATE_EXAMPLES: CommandExample[] = [
+    {
+        Description:
+            "Update the display name of an existing choice set value. Find value IDs with 'df choice-sets list-values <choice-set-id>'.",
+        Command:
+            'uip df choice-set-values update c1d2e3f4-0000-0000-0000-000000000001 v1000000-0000-0000-0000-000000000001 "Business Travel"',
+        Output: {
+            Code: OUTPUT_CODES.ChoiceSetValueUpdated,
+            Data: {
+                id: "v1000000-0000-0000-0000-000000000001",
+                name: "travel",
+                displayName: "Business Travel",
+                numberId: 0,
+            },
+        },
+    },
+];
+
+const CHOICE_SET_VALUES_DELETE_EXAMPLES: CommandExample[] = [
+    {
+        Description:
+            "Delete one or more values from a choice set (irreversible — requires --confirm and --reason). Pass value IDs as a comma-separated list.",
+        Command:
+            'uip df choice-set-values delete c1d2e3f4-0000-0000-0000-000000000001 --ids v1000000-0000-0000-0000-000000000001,v1000000-0000-0000-0000-000000000002 --confirm --reason "deprecated categories"',
+        Output: {
+            Code: OUTPUT_CODES.ChoiceSetValuesDeleted,
+            Data: {
+                ChoiceSetId: "c1d2e3f4-0000-0000-0000-000000000001",
+                DeletedIds: [
+                    "v1000000-0000-0000-0000-000000000001",
+                    "v1000000-0000-0000-0000-000000000002",
+                ],
+                Reason: "deprecated categories",
+            },
+        },
+    },
+];
+
+export const registerChoiceSetValuesCommand = (program: Command) => {
+    const values = program
+        .command("choice-set-values")
+        .description(
+            "Manage the individual values of a Data Fabric choice set. " +
+                "Use 'df choice-sets list-values <choice-set-id>' to list existing values and their IDs.",
+        );
+
+    values
+        .command("create")
+        .description("Add a value to a Data Fabric choice set")
+        .argument("<choice-set-id>", "Choice set ID")
+        .argument(
+            "<name>",
+            "Value name (must start with a letter; letters, numbers, and underscores only)",
+        )
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
+        .option("--display-name <name>", "Human-readable display name")
+        .examples(CHOICE_SET_VALUES_CREATE_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (
+                choiceSetId: string,
+                name: string,
+                options: ValueCreateOptions,
+            ) => {
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
+
+                const insertOpts: ChoiceSetValueInsertOptions = {
+                    ...(options.displayName !== undefined && {
+                        displayName: options.displayName,
+                    }),
+                };
+
+                const choiceSetService: ChoiceSetServiceModel =
+                    sdk.entities.choicesets;
+                const [createError, result] = await catchError(
+                    choiceSetService.insertValueById(
+                        choiceSetId,
+                        name,
+                        Object.keys(insertOpts).length > 0
+                            ? insertOpts
+                            : undefined,
+                    ),
+                );
+
+                if (createError) {
+                    return fail(
+                        `Error creating value in choice set '${choiceSetId}'`,
+                        await extractErrorMessage(createError),
+                    );
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: OUTPUT_CODES.ChoiceSetValueCreated,
+                    Data: result,
+                });
+            },
+        );
+
+    values
+        .command("update")
+        .description("Update the display name of a choice set value")
+        .argument("<choice-set-id>", "Choice set ID")
+        .argument("<value-id>", "Choice set value ID")
+        .argument("<display-name>", "New display name for the value")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
+        .examples(CHOICE_SET_VALUES_UPDATE_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (
+                choiceSetId: string,
+                valueId: string,
+                displayName: string,
+                options: ValueUpdateOptions,
+            ) => {
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
+
+                const choiceSetService: ChoiceSetServiceModel =
+                    sdk.entities.choicesets;
+                const [updateError, result] = await catchError(
+                    choiceSetService.updateValueById(
+                        choiceSetId,
+                        valueId,
+                        displayName,
+                    ),
+                );
+
+                if (updateError) {
+                    return fail(
+                        `Error updating value '${valueId}' in choice set '${choiceSetId}'`,
+                        await extractErrorMessage(updateError),
+                    );
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: OUTPUT_CODES.ChoiceSetValueUpdated,
+                    Data: result,
+                });
+            },
+        );
+
+    values
+        .command("delete")
+        .description(
+            "Delete values from a Data Fabric choice set (irreversible)",
+        )
+        .argument("<choice-set-id>", "Choice set ID")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
+        .option("--ids <ids>", "Comma-separated list of value IDs to delete")
+        .option("--confirm", "Acknowledge this is an irreversible operation")
+        .option(
+            "--reason <reason>",
+            "Reason for the deletion — echoed back in the response so the caller can log it",
+        )
+        .examples(CHOICE_SET_VALUES_DELETE_EXAMPLES)
+        .trackedAction(
+            processContext,
+            async (choiceSetId: string, options: ValueDeleteOptions) => {
+                const valueIds = (options.ids ?? "")
+                    .split(",")
+                    .map((id) => id.trim())
+                    .filter((id) => id.length > 0);
+
+                if (valueIds.length === 0) {
+                    return fail(
+                        "No value IDs provided",
+                        "Pass --ids <id,id,...> with at least one value ID to delete.",
+                    );
+                }
+
+                const reason = requireDestructiveConfirmation(
+                    options,
+                    'Pass --reason "<text>" to record why the values are being deleted.',
+                );
+                if (reason === null) return;
+
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
+
+                const choiceSetService: ChoiceSetServiceModel =
+                    sdk.entities.choicesets;
+                const [deleteError] = await catchError(
+                    choiceSetService.deleteValuesById(choiceSetId, valueIds),
+                );
+
+                if (deleteError) {
+                    return fail(
+                        `Error deleting values from choice set '${choiceSetId}'`,
+                        await extractErrorMessage(deleteError),
+                    );
+                }
 
                 OutputFormatter.success({
                     Result: RESULTS.Success,
-                    Code: "ChoiceSetValues",
+                    Code: OUTPUT_CODES.ChoiceSetValuesDeleted,
                     Data: {
-                        TotalCount: response.totalCount ?? values.length,
-                        Values: values,
-                        HasNextPage: response.hasNextPage ?? false,
-                        ...(nextCursor !== undefined && {
-                            NextCursor: nextCursor,
-                        }),
-                        ...(response.currentPage !== undefined && {
-                            CurrentPage: response.currentPage,
-                        }),
-                        ...(response.totalPages !== undefined && {
-                            TotalPages: response.totalPages,
-                        }),
+                        ChoiceSetId: choiceSetId,
+                        DeletedIds: valueIds,
+                        Reason: reason,
                     },
                 });
             },