@celonis/content-cli 1.13.1 → 1.14.1

package/core/utils/file-service.js

@@ -29,13 +29,6 @@
                 mode: file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS,
             });
         }
-        writeBufferToPath(targetDir, filename, data) {
-            const resolvedDir = path.resolve(process.cwd(), targetDir);
-            const absolutePath = path.join(resolvedDir, filename);
-            this.mkdirRecursive(resolvedDir);
-            this.writeBufferToFileWithGivenName(data, absolutePath);
-            return absolutePath;
-        }
         extractZipBufferToDirectory(data, targetDir) {
             const targetPath = path.resolve(process.cwd(), targetDir);
             this.mkdirRecursive(targetPath);
@@ -64,11 +57,12 @@
             return this.extractExportedZipWithNestedZipsToDir(zipFile, tempDir);
         }
         extractExportedZipWithNestedZipsToDir(zipFile, targetDir) {
-            this.mkdirRecursive(targetDir);
-            zipFile.extractAllTo(targetDir, true, true);
-            const files = fs.readdirSync(targetDir);
+            const targetPath = path.resolve(process.cwd(), targetDir);
+            this.mkdirRecursive(targetPath);
+            zipFile.extractAllTo(targetPath, true, true);
+            const files = fs.readdirSync(targetPath);
             for (const file of files) {
-                const innerZipPath = path.join(targetDir, file);
+                const innerZipPath = path.join(targetPath, file);
                 if (file.endsWith(".zip")) {
                     const nestedZip = new AdmZip(innerZipPath);
                     const nestedDir = innerZipPath.replace(/\.zip$/, "");
@@ -77,8 +71,8 @@
                     fs.rmSync(innerZipPath); // Optionally remove the inner zip
                 }
             }
-            this.restrictFilePermissions(targetDir);
-            return targetDir;
+            this.restrictFilePermissions(targetPath);
+            return targetPath;
         }
         isDirectory(sourcePath) {
             var _a;

package/lib/commands/action-flows/action-flow/action-flow.service.d.ts

@@ -2,6 +2,7 @@ import { Context } from "../../../core/command/cli-context";
 export declare class ActionFlowService {
     static readonly METADATA_FILE_NAME = "metadata.json";
     private actionFlowApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportActionFlows(packageId: string, metadataFilePath: string): Promise<void>;
     analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;

package/lib/commands/asset-registry/asset-registry-api.d.ts

@@ -1,17 +1,13 @@
-/// <reference types="node" />
 import { Context } from "../../core/command/cli-context";
-import { AgentSkillsResponse, AssetRegistryDescriptor, AssetRegistryMetadata } from "./asset-registry.interfaces";
+import { AssetRegistryDescriptor, AssetRegistryMetadata } from "./asset-registry.interfaces";
 export declare class AssetRegistryApi {
     private static readonly BASE_URL;
-    private httpClient;
+    private readonly httpClient;
     constructor(context: Context);
     listTypes(): Promise<AssetRegistryMetadata>;
-    listSkills(): Promise<AgentSkillsResponse>;
     getType(assetType: string): Promise<AssetRegistryDescriptor>;
     getSchema(assetType: string): Promise<any>;
     getExamples(assetType: string): Promise<any>;
     validate(assetType: string, body: any): Promise<any>;
-    getSkillFile(skillPath: string, filePath?: string): Promise<Buffer>;
-    private buildSkillFileUrl;
     private static endpointUrl;
 }

package/lib/commands/asset-registry/asset-registry.interfaces.d.ts

@@ -36,20 +36,3 @@ export interface ValidateOptions {
     file?: string;
     json: boolean;
 }
-export interface AgentSkillMetadata {
-    version: string;
-}
-export interface AgentSkill {
-    name: string;
-    description: string;
-    path: string;
-    metadata: AgentSkillMetadata;
-}
-export interface AgentSkillsResponse {
-    skills: AgentSkill[];
-}
-export interface GetSkillFileOptions {
-    path: string;
-    file?: string;
-    output?: string;
-}

package/lib/commands/asset-registry/asset-registry.service.d.ts

@@ -1,12 +1,10 @@
-import { GetSkillFileOptions, ValidateOptions } from "./asset-registry.interfaces";
+import { ValidateOptions } from "./asset-registry.interfaces";
 import { Context } from "../../core/command/cli-context";
 export declare class AssetRegistryService {
-    private api;
+    private readonly api;
+    private readonly cuiFileService;
     constructor(context: Context);
     listTypes(jsonResponse: boolean): Promise<void>;
-    getSkillFile(opts: GetSkillFileOptions): Promise<void>;
-    private resolveLocalFilename;
-    listSkills(jsonResponse: boolean): Promise<void>;
     getType(assetType: string, jsonResponse: boolean): Promise<void>;
     getSchema(assetType: string, jsonResponse: boolean): Promise<void>;
     getExamples(assetType: string, jsonResponse: boolean): Promise<void>;
@@ -16,6 +14,5 @@ export declare class AssetRegistryService {
     private parseJson;
     private outputResponse;
     private logDescriptorSummary;
-    private logSkillSummary;
     private logDescriptorDetail;
 }

package/lib/commands/asset-registry/module.d.ts

@@ -7,7 +7,5 @@ declare class Module extends IModule {
     private getSchema;
     private validate;
     private getExamples;
-    private listSkills;
-    private getSkillFile;
 }
 export = Module;

package/lib/commands/bookmarks/bookmarks-api.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../../core/command/cli-context";
+import { BookmarksExport, BookmarksImportRequest, BookmarksImportResult } from "./bookmarks.interfaces";
+export declare class BookmarksApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    exportBookmarks(packageKey: string): Promise<BookmarksExport>;
+    importBookmarks(packageKey: string, payload: BookmarksImportRequest): Promise<BookmarksImportResult>;
+}

package/lib/commands/bookmarks/bookmarks-command.service.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../../core/command/cli-context";
+export declare class BookmarksCommandService {
+    private readonly bookmarksApi;
+    private readonly cuiFileService;
+    constructor(context: Context);
+    exportBookmarks(packageKey: string, file?: string): Promise<void>;
+    importBookmarks(packageKey: string, file: string): Promise<void>;
+}

package/lib/commands/bookmarks/bookmarks.interfaces.d.ts

@@ -0,0 +1,34 @@
+export interface BookmarkEntry {
+    assetKey: string;
+    assetType: string;
+    bookmark: BookmarkDetails;
+    preference: BookmarkPreference;
+}
+export interface BookmarkDetails {
+    name: string;
+    ownerId: string;
+    sharedByLink: boolean;
+    published: boolean;
+}
+export interface BookmarkPreference {
+    configuration: string;
+    shareable: boolean;
+    mode: string;
+    userId: string;
+}
+export interface BookmarksExport {
+    packageKey: string;
+    entries: BookmarkEntry[];
+}
+export interface BookmarksImportRequest {
+    entries: BookmarkEntry[];
+}
+export interface BookmarksImportResultEntry {
+    assetKey: string;
+    status: string;
+    reason: string | null;
+}
+export interface BookmarksImportResult {
+    packageKey: string;
+    entries: BookmarksImportResultEntry[];
+}

package/lib/commands/bookmarks/module.d.ts

@@ -0,0 +1,8 @@
+import { Configurator, IModule } from "../../core/command/module-handler";
+import { Context } from "../../core/command/cli-context";
+declare class Module extends IModule {
+    register(context: Context, configurator: Configurator): void;
+    private exportBookmarks;
+    private importBookmarks;
+}
+export = Module;

package/lib/commands/configuration-management/api/node-api.d.ts

@@ -8,5 +8,6 @@ export declare class NodeApi {
     createStagingNode(packageKey: string, transport: SaveNodeTransport, validateOnly: boolean): Promise<NodeTransport | void>;
     updateStagingNode(packageKey: string, nodeKey: string, transport: UpdateNodeTransport, validateOnly: boolean): Promise<NodeTransport | void>;
     archiveStagingNode(packageKey: string, nodeKey: string, force: boolean): Promise<void>;
+    findStagingNodesByPackage(packageKey: string, withConfiguration: boolean, limit: number, offset: number): Promise<NodeTransport[]>;
     findVersionedNodesByPackage(packageKey: string, version: string, withConfiguration: boolean, limit: number, offset: number): Promise<NodeTransport[]>;
 }

package/lib/commands/configuration-management/branch/api/branch.api.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "../../../../core/command/cli-context";
+import { BranchingSettingsTransport, BranchTransport, CreateBranchTransport, MergeBranchTransport, MergePreviewRequestTransport, MergePreviewTransport, PackageVersionCreatedTransport } from "../interfaces/branch.interfaces";
+export declare class BranchApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    configureBranchingSettings(packageKey: string, transport: BranchingSettingsTransport): Promise<BranchingSettingsTransport>;
+    createBranch(packageKey: string, transport: CreateBranchTransport, validate?: boolean): Promise<BranchTransport | void>;
+    listBranches(packageKey: string): Promise<BranchTransport[]>;
+    mergePreview(packageKey: string, transport: MergePreviewRequestTransport): Promise<MergePreviewTransport>;
+    merge(packageKey: string, transport: MergeBranchTransport): Promise<PackageVersionCreatedTransport>;
+    deleteBranch(branchPackageKey: string): Promise<void>;
+}

package/lib/commands/configuration-management/branch/branch-export-import.command.service.d.ts

@@ -0,0 +1,37 @@
+import { Context } from "../../../core/command/cli-context";
+export interface BranchExportOptions {
+    zip?: boolean;
+    gitEnabled?: boolean;
+    jsonResponse?: boolean;
+}
+export interface BranchImportOptions {
+    file?: string;
+    directory?: string;
+    overwrite?: boolean;
+    gitEnabled?: boolean;
+    jsonResponse?: boolean;
+}
+export declare class BranchExportImportCommandService {
+    private readonly singlePackageExportApi;
+    private readonly singlePackageImportApi;
+    private readonly branchApi;
+    private readonly gitService;
+    private readonly cuiFileService;
+    constructor(context: Context);
+    exportBranch(packageKey: string, branchKey: string, options?: BranchExportOptions): Promise<void>;
+    exportAll(packageKey: string, jsonResponse?: boolean): Promise<void>;
+    importBranch(packageKey: string, branchKey: string, options?: BranchImportOptions): Promise<void>;
+    private pushBranchToGit;
+    private pushMainPackage;
+    private exportRewrittenPackageDir;
+    private writeLocalArtifact;
+    private prepareLocalWorkingDir;
+    private importPackageSourceDir;
+    private normalizeToProjectKey;
+    private restoreBranchKey;
+    private replaceFieldValue;
+    private escapeRegExp;
+    private removeDir;
+    private static isExportableBranch;
+    private writeJson;
+}

package/lib/commands/configuration-management/branch/branch.command.service.d.ts

@@ -0,0 +1,19 @@
+import { Context } from "../../../core/command/cli-context";
+import { BranchTransport, BranchingSettingsTransport, MergeApplyOptions, MergePreviewTransport, PackageVersionCreatedTransport } from "./interfaces/branch.interfaces";
+export declare class BranchCommandService {
+    private readonly branchApi;
+    private readonly cuiFileService;
+    constructor(context: Context);
+    setBranchingEnabled(packageKey: string, enabled: boolean, jsonResponse: boolean): Promise<BranchingSettingsTransport>;
+    createBranch(packageKey: string, branchKey: string, sourceVersion: string, validate: boolean, jsonResponse: boolean): Promise<BranchTransport | void>;
+    listBranches(packageKey: string, jsonResponse: boolean): Promise<BranchTransport[]>;
+    deleteBranch(packageKey: string, branchKey: string): Promise<void>;
+    mergePreview(targetPackageKey: string, sourceKey: string, sourceVersion: string, jsonResponse: boolean): Promise<MergePreviewTransport>;
+    mergeApply(targetPackageKey: string, options: MergeApplyOptions): Promise<PackageVersionCreatedTransport>;
+    private static buildVersionCreate;
+    private writeJson;
+    private static printBranch;
+    private static printPreviewSummary;
+    private static countConflictPaths;
+    private static isInConflict;
+}

package/lib/commands/configuration-management/branch/interfaces/branch.interfaces.d.ts

@@ -0,0 +1,139 @@
+export declare enum MergeResolution {
+    CUSTOM = "CUSTOM",
+    ACCEPT_SOURCE = "ACCEPT_SOURCE",
+    ACCEPT_TARGET = "ACCEPT_TARGET"
+}
+export declare enum MergeStatus {
+    UNKNOWN = "UNKNOWN",
+    UNCHANGED = "UNCHANGED",
+    SOURCE_ONLY = "SOURCE_ONLY",
+    TARGET_ONLY = "TARGET_ONLY",
+    AUTO_MERGE = "AUTO_MERGE",
+    CONFLICT = "CONFLICT"
+}
+export declare enum ChangeType {
+    UNKNOWN = "UNKNOWN",
+    ADDED = "ADDED",
+    DELETED = "DELETED",
+    CHANGED = "CHANGED",
+    UNCHANGED = "UNCHANGED"
+}
+export declare enum VersionBumpOption {
+    NONE = "NONE",
+    PATCH = "PATCH"
+}
+export interface BranchingSettingsTransport {
+    branchingEnabled: boolean;
+}
+export interface CreateBranchTransport {
+    branchKey: string;
+    version: string;
+}
+export interface BranchTransport {
+    projectKey: string;
+    branchKey: string;
+    sourcePackageKey: string;
+    sourceVersion: string;
+    packageKey: string;
+    packageId?: string;
+}
+export interface ConfigurationChangeTransport {
+    op: string;
+    path: string;
+    from?: string;
+    value?: unknown;
+    fromValue?: unknown;
+}
+export interface MergePackageResolutionTransport {
+    resolution: MergeResolution;
+    customConfigurationChanges?: ConfigurationChangeTransport[];
+    customMetadataChanges?: ConfigurationChangeTransport[];
+}
+export interface MergeNodeResolutionTransport {
+    nodeKey: string;
+    resolution: MergeResolution;
+    customConfigurationChanges?: ConfigurationChangeTransport[];
+    customMetadataChanges?: ConfigurationChangeTransport[];
+}
+export interface NodeFilterTransport {
+    nodeKeys?: string[];
+}
+export interface SavePackageVersionTransport {
+    version?: string | null;
+    versionBumpOption?: VersionBumpOption;
+    summaryOfChanges?: string;
+    nodeFilter?: NodeFilterTransport | null;
+}
+export interface MergePreviewRequestTransport {
+    sourceKey: string;
+    sourceVersion: string;
+}
+export interface MergeBranchTransport {
+    sourceKey: string;
+    sourceVersion: string;
+    resolvedPackageConflict?: MergePackageResolutionTransport | null;
+    resolvedNodeConflicts?: MergeNodeResolutionTransport[];
+    versionCreate: SavePackageVersionTransport;
+}
+export interface MergePathConflictTransport {
+    path: string;
+    sourceChange: ConfigurationChangeTransport;
+    targetChange: ConfigurationChangeTransport;
+}
+export interface MergeDiffDetailTransport {
+    status: MergeStatus;
+    sourceChanges: ConfigurationChangeTransport[];
+    targetChanges: ConfigurationChangeTransport[];
+    conflicts: MergePathConflictTransport[];
+    autoMergedChanges: ConfigurationChangeTransport[];
+}
+export interface MergeDiffTransport {
+    configuration: MergeDiffDetailTransport;
+    metadata: MergeDiffDetailTransport;
+}
+export interface MergePreviewPackageTransport {
+    sourceChange: ChangeType;
+    targetChange: ChangeType;
+    changeDate: string;
+    updatedBy: string;
+    changes: MergeDiffTransport;
+}
+export interface MergePreviewNodeTransport {
+    nodeKey: string;
+    name: string;
+    type: string;
+    parentNodeKey?: string;
+    invalidContent: boolean;
+    sourceChange: ChangeType;
+    targetChange: ChangeType;
+    changeDate: string;
+    updatedBy: string;
+    changes: MergeDiffTransport;
+}
+export interface MergePreviewTransport {
+    commonPackageKey: string;
+    commonVersion: string;
+    packageChanges: MergePreviewPackageTransport;
+    nodeChanges: MergePreviewNodeTransport[];
+}
+export interface PackageVersionCreatedTransport {
+    packageKey: string;
+    version: string;
+    summaryOfChanges?: string;
+    creationDate: string;
+    createdBy: string;
+}
+export interface MergeApplyOptions {
+    sourceKey?: string;
+    sourceVersion?: string;
+    file?: string;
+    bump?: string;
+    version?: string;
+    summary?: string;
+    jsonResponse?: boolean;
+}
+export interface BranchSyncSummary {
+    packageKey: string;
+    branchName: string;
+    synced?: string[];
+}

package/lib/commands/configuration-management/interfaces/package-validation.interfaces.d.ts

@@ -1,5 +1,5 @@
 export interface PackageValidationRequest {
-    layers: string[];
+    layers?: string[];
     nodeKeys?: string[];
 }
 export interface SchemaValidationResponse {

package/lib/commands/configuration-management/metadata.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class MetadataService {
     private metadataApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
     private exportListOfPackagesMetadata;

package/lib/commands/configuration-management/module.d.ts

@@ -5,6 +5,14 @@ import { Configurator, IModule } from "../../core/command/module-handler";
 import { Context } from "../../core/command/cli-context";
 declare class Module extends IModule {
     register(context: Context, configurator: Configurator): void;
+    private setBranchSettings;
+    private createBranch;
+    private listBranches;
+    private deleteBranch;
+    private previewBranchMerge;
+    private applyBranchMerge;
+    private exportBranch;
+    private importBranch;
     private listPackages;
     private listStagingPackages;
     private batchExportPackages;

package/lib/commands/configuration-management/node-dependency.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class NodeDependencyService {
     private readonly nodeDependencyApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listNodeDependencies(packageKey: string, nodeKey: string, version: string, jsonResponse: boolean): Promise<void>;
 }

package/lib/commands/configuration-management/node-diff.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class NodeDiffService {
     private nodeDiffApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     diff(packageKey: string, nodeKey: string, baseVersion: string, compareVersion: string, jsonResponse: boolean): Promise<void>;
     diffWithFile(packageKey: string, nodeKey: string, baseVersion: string, file: string, jsonResponse: boolean): Promise<void>;

package/lib/commands/configuration-management/node.service.d.ts

@@ -1,9 +1,10 @@
 import { Context } from "../../core/command/cli-context";
 export declare class NodeService {
     private nodeApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     findNode(packageKey: string, nodeKey: string, withConfiguration: boolean, packageVersion: string | null, jsonResponse: boolean): Promise<void>;
-    listNodes(packageKey: string, packageVersion: string, limit: number, offset: number, withConfiguration: boolean, jsonResponse: boolean): Promise<void>;
+    listNodes(packageKey: string, packageVersion: string | null, limit: number, offset: number, withConfiguration: boolean, jsonResponse: boolean): Promise<void>;
     createNode(packageKey: string, body: string | undefined, file: string | undefined, validateOnly: boolean, jsonResponse: boolean): Promise<void>;
     updateNode(packageKey: string, nodeKey: string, body: string | undefined, file: string | undefined, validateOnly: boolean, jsonResponse: boolean): Promise<void>;
     archiveNode(packageKey: string, nodeKey: string, force: boolean): Promise<void>;

package/lib/commands/configuration-management/package-validation.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class PackageValidationService {
     private packageValidationApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     validatePackage(packageKey: string, layers: string[], nodeKeys: string[], jsonOutput: boolean): Promise<void>;
     private printValidationResult;

package/lib/commands/configuration-management/package-version.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class PackageVersionService {
     private packageVersionApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     findPackageVersion(packageKey: string, version: string, jsonResponse: boolean): Promise<void>;
     createPackageVersion(packageKey: string, version: string | undefined, versionBumpOption: string, summaryOfChanges: string | undefined, nodeFilterKeys: string[] | undefined, jsonResponse: boolean): Promise<void>;

package/lib/commands/configuration-management/single-package-export.service.d.ts

@@ -2,6 +2,7 @@ import { Context } from "../../core/command/cli-context";
 export declare class SinglePackageExportService {
     private readonly singlePackageExportApi;
     private readonly gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportPackage(packageKey: string, zip: boolean, gitBranch: string): Promise<void>;
     private exportToGitBranch;

package/lib/commands/configuration-management/single-package-import.service.d.ts

@@ -1,13 +1,16 @@
+import * as FormData from "form-data";
+import * as AdmZip from "adm-zip";
 import { Context } from "../../core/command/cli-context";
 export declare class SinglePackageImportService {
     private static readonly MAX_UNCOMPRESSED_ZIP_SIZE;
     private readonly singlePackageImportApi;
     private readonly gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     importPackage(file: string, directory: string, overwrite: boolean, jsonResponse: boolean, gitBranch: string): Promise<void>;
     private resolveSource;
-    private buildBodyForImport;
-    private assertUncompressedSizeWithinLimit;
-    private getReadableStream;
+    static buildBodyForImport(packageZip: AdmZip, sourcePath: string): FormData;
+    static assertUncompressedSizeWithinLimit(packageZip: AdmZip, sourcePath: string): void;
+    private static getReadableStream;
     private outputResult;
 }

package/lib/commands/configuration-management/staging-package.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class StagingPackageService {
     private stagingPackageApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listStagingPackages(flavors: string[], includeBranches: boolean, jsonResponse: boolean): Promise<void>;
     private exportListOfPackages;

package/lib/commands/configuration-management/variable.service.d.ts

@@ -3,6 +3,7 @@ export declare class VariableService {
     private variableApi;
     private variableAssignmentCandidatesApi;
     private readonly stagingPackageVariablesApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     listCandidateAssignments(type: string, params: string): Promise<void>;

package/lib/commands/data-pipeline/data-pool/data-pool-service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../../core/command/cli-context";
 export declare class DataPoolService {
     private dataPoolApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     batchImportDataPools(requestFilePath: string, outputToJsonFile: boolean): Promise<void>;
     exportDataPool(poolId: string, outputToJsonFile: boolean): Promise<void>;

package/lib/commands/deployment/deployment.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class DeploymentService {
     private deploymentApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     createDeployment(packageKey: string, packageVersion: string, deployableType: string, targetId: string, jsonResponse: boolean): Promise<void>;
     getDeployments(jsonResponse: boolean, packageKey?: string, targetId?: string, deployableType?: string, status?: string, createdBy?: string, limit?: string, offset?: string): Promise<void>;

package/lib/commands/studio/service/asset-service.d.ts

@@ -2,6 +2,7 @@ import { Context } from "../../../core/command/cli-context";
 export declare class AssetService {
     protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     private assetApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listAssets(assetType: string): Promise<void>;
     findAndExportAllAssets(assetType: string): Promise<void>;

package/lib/commands/studio/service/package.service.d.ts

@@ -7,6 +7,7 @@ export declare class PackageService {
     private packageDependenciesApi;
     private dataModelService;
     private variableService;
+    private readonly cuiFileService;
     constructor(context: Context);
     listPackages(): Promise<void>;
     findAndExportListOfAllPackages(includeDependencies: boolean, packageKeys: string[]): Promise<void>;

package/lib/commands/t2tc/diff.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class DiffService {
     private diffApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     diffPackages(file: string, hasChanges: boolean, baseVersion: string, jsonResponse: boolean): Promise<void>;
     private hasChanges;

package/lib/commands/t2tc/t2tc-package.service.d.ts

@@ -5,6 +5,7 @@ export declare class T2tcPackageService {
     private studioPackageApi;
     private studioService;
     private gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     listActivePackages(flavors: string[], includeBranches: boolean): Promise<void>;
     findAndExportListOfPackages(flavors: string[], packageKeys: string[], keysByVersion: string[], withDependencies: boolean, includeBranches: boolean): Promise<void>;

package/lib/core/command/module-handler.d.ts

@@ -24,8 +24,8 @@ type CommandHandler = (context: Context, command: Command, options: OptionValues
  * Allows the creation of root level commands.
  */
 export declare class Configurator {
-    private program;
-    private ctx;
+    private readonly program;
+    private readonly ctx;
     rootCommandMap: Map<string, CommandConfig>;
     constructor(program: Command, ctx: Context);
     /**
@@ -40,8 +40,8 @@ export declare class Configurator {
  * executed.
  */
 export declare class CommandConfig {
-    private cmd;
-    private ctx;
+    private readonly cmd;
+    private readonly ctx;
     private deprecationMessage;
     constructor(cmd: Command, ctx: Context);
     command(nameAndArgs: string, opts?: CommandOptions): CommandConfig;

package/lib/core/feature-flag/feature-disabled-error.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Recognizes the backend's "feature not enabled" response so the CLI can surface a
+ * clear message instead of a raw error. Enforcement stays entirely in the backend
+ * (pacman); the CLI only translates the response — it never decides entitlement.
+ *
+ * The backend rejects a flag-gated request with 403 and a machine-readable body:
+ * {"errorCode":"feature-disabled", ...} (pacman's standard ErrorTransport). Keying
+ * off the stable code (rather than a free-text message) keeps this robust.
+ */
+export declare const FEATURE_DISABLED_CODE = "feature-disabled";
+/**
+ * True when the given error represents a backend "feature disabled" rejection.
+ * HttpClient rejects with the stringified response body (often wrapped as
+ * "FatalError: {json}"), so we extract and parse the embedded JSON payload.
+ */
+export declare function isFeatureDisabledError(error: unknown): boolean;

package/lib/core/http/http-client.d.ts

@@ -9,6 +9,10 @@ export declare class HttpClient {
     private axios;
     constructor(context: Context);
     get(url: string): Promise<any>;
+    getStatusAndData(url: string): Promise<{
+        status: number;
+        data: any;
+    }>;
     getFile(url: string): Promise<any>;
     postFile(url: string, formData: FormData, parameters?: {}): Promise<any>;
     post(url: string, body: any): Promise<any>;