@pitcher/cli-scripts 2.2.2 → 2.4.0

package/dist/src/commands/dsrLanding.js

@@ -0,0 +1,150 @@
+import { Command } from 'commander';
+import { clientFor, toCliError } from '../core/http.js';
+import { ok, fail } from '../core/envelope.js';
+import { createCliError } from '../core/errors.js';
+import { emitEnvelope } from '../core/output.js';
+import { readTextFile } from '../core/readInput.js';
+import { parseJsonArray } from '../schema/content.js';
+import { withAuthFlags } from './withAuth.js';
+import { withInstanceFlag } from './withInstance.js';
+import { DSR_SCAFFOLD_HTML, emitScaffold } from './scaffolds.js';
+const DSR_ENDPOINT = '/core/api/protected/dsr-landing-templates';
+const REQUIRED_MARKER = 'data-pitcher-email-gate';
+const TOKEN_HELP = `
+Required marker (the platform injects the email-gate form here at render time):
+  data-pitcher-email-gate    must be present verbatim in --html-file, or create fails client-side
+
+Editable regions (optional, edited in the DSR landing editor without touching markup):
+  data-field-id="..."            unique id for the editable block
+  data-field-editable="true"     marks the block as editable
+  data-field-char-limit="N"      max character length enforced by the editor
+
+Tokens (resolved by the platform at render time; unknown tokens render blank):
+  {{recipient.firstName}}, {{recipient.lastName}}, {{recipient.email}}   recipient fields
+  {{customer.name}}                                                     recipient's company
+  {{organization.name}}                                                 sharing org's display name
+  {{rep.name}}                                                          sharing rep's display name
+  {{sharedLink.valid_until}}                                            share expiry, if set
+
+Run "p dsr-landing scaffold" for a full working example.`;
+export async function runDsrLandingCreate(opts, deps = {}) {
+    try {
+        if (!opts.name)
+            throw createCliError('VALIDATION', '--name is required for dsr-landing create');
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for dsr-landing create');
+        if (!opts.htmlFile)
+            throw createCliError('VALIDATION', '--html-file is required for dsr-landing create');
+        // readTextFile throws VALIDATION on a missing/unreadable file, before any request is made.
+        const html = readTextFile(opts.htmlFile);
+        if (!html.includes(REQUIRED_MARKER)) {
+            throw createCliError('VALIDATION', `landing HTML must contain the ${REQUIRED_MARKER} marker`);
+        }
+        if (opts.language && opts.language.length > 10) {
+            throw createCliError('VALIDATION', '--language must be at most 10 characters');
+        }
+        const body = { instance_id: opts.instanceId, name: opts.name, html };
+        if (opts.cssFile)
+            body.css = readTextFile(opts.cssFile);
+        if (opts.mergeSchema)
+            body.merge_schema = parseJsonArray(opts.mergeSchema, 'merge-schema');
+        if (opts.thumbnailUrl)
+            body.thumbnail_url = opts.thumbnailUrl;
+        if (opts.language)
+            body.language = opts.language;
+        const client = clientFor(opts, deps);
+        const res = await client.post(DSR_ENDPOINT, body, { params: { instance_id: opts.instanceId } });
+        const created = res.data;
+        if (opts.default) {
+            // The template was created, but --default asked for a compound operation:
+            // if set-default can't complete, the instance default is NOT this template.
+            // Report that as a failure (non-ok, non-zero exit) so an agent keying on the
+            // envelope doesn't believe the default changed. The created id is surfaced in
+            // the message so the caller can retry `set-default` without re-creating.
+            const id = created?.id;
+            if (!id) {
+                return fail(createCliError('UNKNOWN', 'template created, but --default could not be applied: server response had no id'));
+            }
+            try {
+                await client.post(`${DSR_ENDPOINT}/${encodeURIComponent(id)}/set-default`, undefined, {
+                    params: { instance_id: opts.instanceId },
+                });
+            }
+            catch (e) {
+                const err = toCliError(e);
+                return fail(createCliError(err.code, `template created (id ${id}), but set-default failed: ${err.message}. ` +
+                    `Retry with: p dsr-landing set-default --instance-id ${opts.instanceId} --id ${id}`));
+            }
+        }
+        return ok(created);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runDsrLandingSetDefault(opts, deps = {}) {
+    try {
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required for dsr-landing set-default');
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for dsr-landing set-default');
+        const client = clientFor(opts, deps);
+        const res = await client.post(`${DSR_ENDPOINT}/${encodeURIComponent(opts.id)}/set-default`, undefined, {
+            params: { instance_id: opts.instanceId },
+        });
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runDsrLandingList(opts, deps = {}) {
+    try {
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for dsr-landing list');
+        const client = clientFor(opts, deps);
+        const res = await client.get(DSR_ENDPOINT, { params: { instance_id: opts.instanceId } });
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runDsrLandingScaffold(opts, _deps = {}) {
+    return emitScaffold(DSR_SCAFFOLD_HTML, opts.out);
+}
+export function createDsrLandingCommand() {
+    const cmd = new Command('dsr-landing').description('create/list DSR (Digital Sales Room) landing-page templates, and set one as default');
+    withInstanceFlag(withAuthFlags(cmd.command('create')))
+        .requiredOption('--name <name>', 'Template name')
+        .requiredOption('--html-file <path>', `Path to the landing HTML (must contain ${REQUIRED_MARKER})`)
+        .option('--css-file <path>', 'Path to a CSS file for the template')
+        .option('--merge-schema <json>', 'Merge schema array as inline JSON')
+        .option('--language <lang>', 'Language code (max 10 chars)')
+        .option('--thumbnail-url <url>', 'Thumbnail image URL')
+        .option('--default', 'Also set this template as the instance-scope default after creating it')
+        .addHelpText('after', TOKEN_HELP)
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runDsrLandingCreate({ ...options, quiet: globals.quiet }), globals);
+    });
+    withInstanceFlag(withAuthFlags(cmd.command('set-default')))
+        .requiredOption('--id <id>', 'Template ID')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runDsrLandingSetDefault({ ...options, quiet: globals.quiet }), globals);
+    });
+    withInstanceFlag(withAuthFlags(cmd.command('list'))).action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runDsrLandingList({ ...options, quiet: globals.quiet }), globals);
+    });
+    withAuthFlags(cmd.command('scaffold'))
+        .description('generate a starter DSR landing page HTML with the required marker and tokens in context')
+        .option('--out <path>', 'Write the scaffold HTML to a file instead of returning it inline')
+        .addHelpText('after', TOKEN_HELP)
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runDsrLandingScaffold({ ...options, quiet: globals.quiet }), globals);
+    });
+    return cmd;
+}

package/dist/src/commands/emailTemplate.d.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import type { AxiosInstance } from 'axios';
+import { type CommonOpts } from '../core/http.js';
+import { type Envelope } from '../core/envelope.js';
+export interface EmailTemplateDeps {
+    client?: AxiosInstance;
+}
+export declare function runEmailTemplateCreate(opts: CommonOpts & {
+    instanceId?: string;
+    name?: string;
+    bodyFile?: string;
+    subject?: string;
+    tags?: string;
+    metadata?: string;
+}, deps?: EmailTemplateDeps): Promise<Envelope<unknown>>;
+export declare function runEmailTemplateList(opts: CommonOpts & {
+    instanceId?: string;
+    name?: string;
+    status?: string;
+    category?: string;
+    target?: string;
+    limit?: number;
+    offset?: number;
+}, deps?: EmailTemplateDeps): Promise<Envelope<unknown>>;
+export declare function runEmailTemplateGet(opts: CommonOpts & {
+    instanceId?: string;
+    id?: string;
+}, deps?: EmailTemplateDeps): Promise<Envelope<unknown>>;
+export declare function runEmailTemplateScaffold(opts: CommonOpts & {
+    out?: string;
+}, _deps?: EmailTemplateDeps): Promise<Envelope<unknown>>;
+export declare function createEmailTemplateCommand(): Command;

package/dist/src/commands/emailTemplate.js

@@ -0,0 +1,124 @@
+import { Command } from 'commander';
+import { clientFor, toCliError } from '../core/http.js';
+import { ok, fail } from '../core/envelope.js';
+import { createCliError } from '../core/errors.js';
+import { emitEnvelope } from '../core/output.js';
+import { readTextFile } from '../core/readInput.js';
+import { listLimitOffsetParams } from '../core/pagination.js';
+import { assertIntFlags, parseJsonObject } from '../schema/content.js';
+import { withAuthFlags } from './withAuth.js';
+import { withInstanceFlag } from './withInstance.js';
+import { EMAIL_SCAFFOLD_HTML, emitScaffold } from './scaffolds.js';
+const TEMPLATES_ENDPOINT = '/core/api/protected/emails/templates';
+const TOKEN_HELP = `
+Tokens (resolved by the emails app at send time; unknown tokens render blank):
+  {{recipient.firstName}}   recipient's first name
+  {{recipient.lastName}}    recipient's last name
+  {{recipient.email}}       recipient's email address
+
+Run "p email-template scaffold" for a full working example.`;
+export async function runEmailTemplateCreate(opts, deps = {}) {
+    try {
+        if (!opts.name)
+            throw createCliError('VALIDATION', '--name is required for email-template create');
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for email-template create');
+        const body = { name: opts.name };
+        if (opts.subject)
+            body.subject = opts.subject;
+        // readTextFile throws VALIDATION on a missing/unreadable file, before any request is made.
+        if (opts.bodyFile)
+            body.body = readTextFile(opts.bodyFile);
+        if (opts.tags)
+            body.tags = parseJsonObject(opts.tags, 'tags');
+        if (opts.metadata)
+            body.metadata = parseJsonObject(opts.metadata, 'metadata');
+        const client = clientFor(opts, deps);
+        const res = await client.post(TEMPLATES_ENDPOINT, body, { headers: { 'x-instance-id': opts.instanceId } });
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runEmailTemplateList(opts, deps = {}) {
+    try {
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for email-template list');
+        assertIntFlags(opts);
+        const client = clientFor(opts, deps);
+        const params = { ...listLimitOffsetParams(opts) };
+        if (opts.name)
+            params.name = opts.name;
+        if (opts.status)
+            params.status = opts.status;
+        if (opts.category)
+            params.category = opts.category;
+        if (opts.target)
+            params.target = opts.target;
+        const res = await client.get(TEMPLATES_ENDPOINT, { params, headers: { 'x-instance-id': opts.instanceId } });
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runEmailTemplateGet(opts, deps = {}) {
+    try {
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for email-template get');
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required for email-template get');
+        const client = clientFor(opts, deps);
+        const res = await client.get(`${TEMPLATES_ENDPOINT}/${encodeURIComponent(opts.id)}`, {
+            headers: { 'x-instance-id': opts.instanceId },
+        });
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runEmailTemplateScaffold(opts, _deps = {}) {
+    return emitScaffold(EMAIL_SCAFFOLD_HTML, opts.out);
+}
+export function createEmailTemplateCommand() {
+    const cmd = new Command('email-template').description('create/list/get HTML email templates for the emails app');
+    withInstanceFlag(withAuthFlags(cmd.command('create')))
+        .requiredOption('--name <name>', 'Template name')
+        .option('--body-file <path>', 'Path to an HTML file (inline CSS) used as the template body')
+        .option('--subject <text>', 'Email subject (supports {{tokens}})')
+        .option('--tags <json>', 'Tags object as inline JSON')
+        .option('--metadata <json>', 'Metadata object as inline JSON')
+        .addHelpText('after', TOKEN_HELP)
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runEmailTemplateCreate({ ...options, quiet: globals.quiet }), globals);
+    });
+    withInstanceFlag(withAuthFlags(cmd.command('list')))
+        .option('--name <name>', 'Case-insensitive substring filter, matched against name OR subject (not exact match)')
+        .option('--status <status>', 'Status filter')
+        .option('--category <category>', 'Category filter')
+        .option('--target <target>', 'Target filter')
+        .option('--limit <n>', 'Limit', (v) => parseInt(v, 10))
+        .option('--offset <n>', 'Offset', (v) => parseInt(v, 10))
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runEmailTemplateList({ ...options, quiet: globals.quiet }), globals);
+    });
+    withInstanceFlag(withAuthFlags(cmd.command('get')))
+        .requiredOption('--id <id>', 'Template ID')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runEmailTemplateGet({ ...options, quiet: globals.quiet }), globals);
+    });
+    withAuthFlags(cmd.command('scaffold'))
+        .description('generate a starter HTML email template with tokens in context')
+        .option('--out <path>', 'Write the scaffold HTML to a file instead of returning it inline')
+        .addHelpText('after', TOKEN_HELP)
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runEmailTemplateScaffold({ ...options, quiet: globals.quiet }), globals);
+    });
+    return cmd;
+}

package/dist/src/commands/files.d.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import axios, { type AxiosInstance } from 'axios';
+import { type CommonOpts } from '../core/http.js';
+import { type Envelope } from '../core/envelope.js';
+export interface FilesDeps {
+    client?: AxiosInstance;
+    put?: typeof axios.put;
+    readFile?: (p: string) => Buffer;
+}
+export declare function runFilesList(opts: CommonOpts & {
+    instanceId?: string;
+    tags?: string;
+    idIn?: string;
+    page?: number;
+    pageSize?: number;
+}, deps?: FilesDeps): Promise<Envelope<{
+    results: unknown[];
+    pagination: Record<string, unknown>;
+}>>;
+export declare function runFilesGet(opts: CommonOpts & {
+    id?: string;
+}, deps?: FilesDeps): Promise<Envelope<unknown>>;
+export declare function runFilesCreate(opts: CommonOpts & {
+    instanceId?: string;
+    name?: string;
+    folderId?: string;
+    filePath?: string;
+    sourceUrl?: string;
+    accessType?: string;
+    tags?: string;
+    metadata?: string;
+    appMetadata?: string;
+}, deps?: FilesDeps): Promise<Envelope<unknown>>;
+export declare function runFilesUpdate(opts: CommonOpts & {
+    id?: string;
+    instanceId?: string;
+    name?: string;
+    folderId?: string;
+    filePath?: string;
+    sourceUrl?: string;
+    accessType?: string;
+    tags?: string;
+    metadata?: string;
+    appMetadata?: string;
+}, deps?: FilesDeps): Promise<Envelope<unknown>>;
+export declare function createFilesCommand(): Command;

package/dist/src/commands/files.js

@@ -0,0 +1,167 @@
+import { Command } from 'commander';
+import { clientFor, toCliError } from '../core/http.js';
+import { ok, fail } from '../core/envelope.js';
+import { createCliError } from '../core/errors.js';
+import { emitEnvelope } from '../core/output.js';
+import { uploadFile } from '../core/upload.js';
+import { listPageParams, listPaginationEcho } from '../core/pagination.js';
+import { parseTags, parseJsonObject, validateAccessType, deepMerge, assertIntFlags } from '../schema/content.js';
+import { withAuthFlags } from './withAuth.js';
+export async function runFilesList(
+// NOTE: no folderId — the Django files list has no folder filter (listing a
+// folder's files is a folders-retrieve concern). tags filters via `tags__in`.
+opts, deps = {}) {
+    try {
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for files list');
+        assertIntFlags(opts);
+        const client = clientFor(opts, deps);
+        const params = { instance_id: opts.instanceId, ...listPageParams(opts) };
+        if (opts.idIn)
+            params.id__in = opts.idIn;
+        if (opts.tags)
+            params.tags__in = opts.tags;
+        const res = await client.get('/api/v1/files/', { params });
+        return ok({ results: res.data.results, pagination: listPaginationEcho(opts, res.data) });
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runFilesGet(opts, deps = {}) {
+    try {
+        if (!opts.id)
+            throw createCliError('VALIDATION', 'file id is required');
+        const client = clientFor(opts, deps);
+        const res = await client.get(`/api/v1/files/${opts.id}`);
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runFilesCreate(opts, deps = {}) {
+    try {
+        if (!opts.instanceId)
+            throw createCliError('VALIDATION', '--instance-id is required for files create');
+        const client = clientFor(opts, deps);
+        const body = { instance_id: opts.instanceId };
+        if (opts.name)
+            body.name = opts.name;
+        if (opts.folderId)
+            body.folder_id = opts.folderId;
+        const accessType = validateAccessType(opts.accessType);
+        if (accessType)
+            body.access_type = accessType;
+        if (opts.tags)
+            body.tags = parseTags(opts.tags);
+        if (opts.metadata)
+            body.metadata = parseJsonObject(opts.metadata, 'metadata');
+        if (opts.appMetadata)
+            body.app_metadata = parseJsonObject(opts.appMetadata, 'app-metadata');
+        if (opts.filePath && opts.sourceUrl)
+            throw createCliError('VALIDATION', 'pass either --file or --source-url, not both');
+        if (opts.filePath) {
+            body.content_upload_id = await uploadFile(client, { instanceId: opts.instanceId, filePath: opts.filePath }, deps);
+        }
+        else if (opts.sourceUrl) {
+            body.url = opts.sourceUrl;
+        }
+        const res = await client.post('/api/v1/files/', body);
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runFilesUpdate(opts, deps = {}) {
+    try {
+        if (!opts.id)
+            throw createCliError('VALIDATION', 'file id is required');
+        const client = clientFor(opts, deps);
+        const body = {};
+        if (opts.name)
+            body.name = opts.name;
+        if (opts.folderId)
+            body.folder_id = opts.folderId;
+        const accessType = validateAccessType(opts.accessType);
+        if (accessType)
+            body.access_type = accessType;
+        if (opts.tags)
+            body.tags = parseTags(opts.tags);
+        // Metadata is a JSONField the PATCH replaces wholesale — read-merge-write.
+        const metaPatch = opts.metadata ? parseJsonObject(opts.metadata, 'metadata') : undefined;
+        const appMetaPatch = opts.appMetadata ? parseJsonObject(opts.appMetadata, 'app-metadata') : undefined;
+        if (metaPatch || appMetaPatch) {
+            const cur = (await client.get(`/api/v1/files/${opts.id}`)).data;
+            if (metaPatch)
+                body.metadata = deepMerge(cur.metadata, metaPatch);
+            if (appMetaPatch)
+                body.app_metadata = deepMerge(cur.app_metadata, appMetaPatch);
+        }
+        if (opts.filePath && opts.sourceUrl)
+            throw createCliError('VALIDATION', 'pass either --file or --source-url, not both');
+        if (opts.filePath) {
+            if (!opts.instanceId)
+                throw createCliError('VALIDATION', '--instance-id is required with --file');
+            body.content_upload_id = await uploadFile(client, { instanceId: opts.instanceId, filePath: opts.filePath }, deps);
+        }
+        else if (opts.sourceUrl) {
+            body.url = opts.sourceUrl;
+        }
+        const res = await client.patch(`/api/v1/files/${opts.id}`, body);
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export function createFilesCommand() {
+    const cmd = new Command('files').description('manage Pitcher content files');
+    withAuthFlags(cmd.command('list'))
+        .requiredOption('--instance-id <id>', 'Instance ID')
+        .option('--id-in <ids>', 'Comma-separated file IDs')
+        .option('--tags <tags>', 'Comma-separated tags (filters via tags__in)')
+        .option('--page <n>', 'Page number', (v) => parseInt(v, 10))
+        .option('--page-size <n>', 'Page size (max 500)', (v) => parseInt(v, 10))
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runFilesList({ ...options, quiet: globals.quiet }), globals);
+    });
+    withAuthFlags(cmd.command('get'))
+        .argument('<id>', 'File ID')
+        .action(async (id, options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runFilesGet({ ...options, id, quiet: globals.quiet }), globals);
+    });
+    withAuthFlags(cmd.command('create'))
+        .requiredOption('--instance-id <id>', 'Instance ID')
+        .option('--name <name>', 'File name')
+        .option('--folder-id <id>', 'Destination folder')
+        .option('--file <path>', 'Local file to upload')
+        .option('--source-url <url>', 'Link/WEB file source URL')
+        .option('--access-type <type>', 'public | restricted | personal')
+        .option('--tags <tags>', 'Comma-separated tags')
+        .option('--metadata <json>', 'metadata JSON object')
+        .option('--app-metadata <json>', 'app_metadata JSON object')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runFilesCreate({ ...options, filePath: options.file, quiet: globals.quiet }), globals);
+    });
+    withAuthFlags(cmd.command('update'))
+        .argument('<id>', 'File ID')
+        .option('--instance-id <id>', 'Instance ID (required only with --file)')
+        .option('--name <name>', 'File name')
+        .option('--folder-id <id>', 'Move to folder')
+        .option('--file <path>', 'Replace binary with local file')
+        .option('--source-url <url>', 'Replace with link/WEB source URL')
+        .option('--access-type <type>', 'public | restricted | personal')
+        .option('--tags <tags>', 'Comma-separated tags')
+        .option('--metadata <json>', 'metadata JSON object (deep-merged)')
+        .option('--app-metadata <json>', 'app_metadata JSON object (deep-merged)')
+        .action(async (id, options, command) => {
+        const globals = command.optsWithGlobals();
+        emitEnvelope(await runFilesUpdate({ ...options, id, filePath: options.file, quiet: globals.quiet }), globals);
+    });
+    return cmd;
+}

package/dist/src/commands/folders.d.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import type { AxiosInstance } from 'axios';
+import { type CommonOpts } from '../core/http.js';
+import { type Envelope } from '../core/envelope.js';
+export interface FoldersDeps {
+    client?: AxiosInstance;
+}
+export declare function runFoldersList(opts: CommonOpts & {
+    instanceId?: string;
+    page?: number;
+    pageSize?: number;
+}, deps?: FoldersDeps): Promise<Envelope<{
+    results: unknown[];
+    pagination: Record<string, unknown>;
+}>>;
+export declare function runFoldersGet(opts: CommonOpts & {
+    id?: string;
+    root?: boolean;
+    instanceId?: string;
+}, deps?: FoldersDeps): Promise<Envelope<unknown>>;
+export declare function runFoldersCreate(opts: CommonOpts & {
+    name?: string;
+    parentFolderId?: string;
+    accessType?: string;
+    rules?: string;
+}, deps?: FoldersDeps): Promise<Envelope<unknown>>;
+export declare function runFoldersUpdate(opts: CommonOpts & {
+    id?: string;
+    name?: string;
+    accessType?: string;
+    rules?: string;
+}, deps?: FoldersDeps): Promise<Envelope<unknown>>;
+export declare function createFoldersCommand(): Command;