@lifestreamdynamics/vault-cli 1.1.0 → 1.3.0

package/dist/commands/plugins.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerPluginCommands(program: Command): void;

package/dist/commands/plugins.js

@@ -0,0 +1,172 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerPluginCommands(program) {
+    const plugins = program.command('plugins').description('Plugin/extension marketplace management');
+    // ── list ──────────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('list')
+        .description('List all installed plugins'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading plugins...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.plugins.list();
+            out.stopSpinner();
+            if (list.length === 0 && flags.output !== 'json') {
+                out.raw('No plugins installed.\n');
+            }
+            else {
+                out.list(list.map((p) => ({
+                    pluginId: p.pluginId,
+                    version: p.version,
+                    enabled: p.enabled ? 'yes' : 'no',
+                    settings: Object.keys(p.settings).length > 0 ? JSON.stringify(p.settings) : '',
+                    installedAt: p.installedAt.slice(0, 10),
+                })), {
+                    columns: [
+                        { key: 'pluginId', header: 'Plugin ID' },
+                        { key: 'version', header: 'Version' },
+                        { key: 'enabled', header: 'Enabled' },
+                        { key: 'installedAt', header: 'Installed' },
+                    ],
+                    textFn: (p) => `${chalk.cyan(String(p.pluginId))}@${p.version} ${p.enabled === 'yes' ? chalk.green('enabled') : chalk.dim('disabled')} ${chalk.dim(String(p.installedAt))}`,
+                });
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to list plugins');
+        }
+    });
+    // ── install ───────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('install')
+        .description('Install a plugin from the marketplace')
+        .requiredOption('--plugin-id <pluginId>', 'Plugin marketplace identifier (e.g. org/plugin-name)')
+        .requiredOption('--version <version>', 'Version to install'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Installing plugin...');
+        try {
+            const client = await getClientAsync();
+            const installed = await client.plugins.install({
+                pluginId: _opts.pluginId,
+                version: _opts.version,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(installed, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`Plugin installed: ${installed.pluginId}@${installed.version}`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to install plugin');
+        }
+    });
+    // ── uninstall ─────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('uninstall')
+        .description('Uninstall a plugin')
+        .argument('<pluginId>', 'Plugin marketplace identifier')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.raw(chalk.yellow(`Pass --confirm to uninstall plugin ${pluginId}.`) + '\n');
+            return;
+        }
+        out.startSpinner('Uninstalling plugin...');
+        try {
+            const client = await getClientAsync();
+            await client.plugins.uninstall(pluginId);
+            out.stopSpinner();
+            out.raw(chalk.green(`Plugin ${pluginId} uninstalled.`) + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to uninstall plugin');
+        }
+    });
+    // ── enable ────────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('enable')
+        .description('Enable a plugin')
+        .argument('<pluginId>', 'Plugin marketplace identifier'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Enabling plugin...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.plugins.enable(pluginId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`Plugin ${updated.pluginId} enabled.`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to enable plugin');
+        }
+    });
+    // ── disable ───────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('disable')
+        .description('Disable a plugin')
+        .argument('<pluginId>', 'Plugin marketplace identifier'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Disabling plugin...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.plugins.disable(pluginId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.dim(`Plugin ${updated.pluginId} disabled.`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to disable plugin');
+        }
+    });
+    // ── update-settings ───────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('update-settings')
+        .description('Update plugin-specific settings')
+        .argument('<pluginId>', 'Plugin marketplace identifier')
+        .requiredOption('--settings <json>', 'Settings as a JSON string (e.g. \'{"theme":"dark"}\')'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        let settings;
+        try {
+            settings = JSON.parse(_opts.settings);
+        }
+        catch {
+            out.error('Invalid JSON for --settings. Provide a valid JSON object.');
+            process.exitCode = 2;
+            return;
+        }
+        out.startSpinner('Updating plugin settings...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.plugins.updateSettings(pluginId, settings);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`Settings updated for ${updated.pluginId}.`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update plugin settings');
+        }
+    });
+}

package/dist/commands/publish-vault.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerPublishVaultCommands(program: Command): void;

package/dist/commands/publish-vault.js

@@ -0,0 +1,117 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerPublishVaultCommands(program) {
+    const pv = program.command('publish-vault').description('Manage whole-vault publishing (public sites)');
+    addGlobalFlags(pv.command('list')
+        .description('List your published vault sites'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching published vaults...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.publishVault.listMine();
+            out.stopSpinner();
+            out.list(list.map(pv => ({ slug: pv.slug, title: pv.title, isPublished: pv.isPublished ? 'yes' : 'no', createdAt: pv.createdAt })), {
+                emptyMessage: 'No published vault sites found.',
+                columns: [
+                    { key: 'slug', header: 'Slug' },
+                    { key: 'title', header: 'Title' },
+                    { key: 'isPublished', header: 'Published' },
+                    { key: 'createdAt', header: 'Created' },
+                ],
+                textFn: (pv) => `${chalk.cyan(String(pv.slug))} — ${String(pv.title)} [${pv.isPublished === 'yes' ? chalk.green('live') : chalk.dim('draft')}]`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch published vaults');
+        }
+    });
+    addGlobalFlags(pv.command('publish')
+        .description('Publish a vault as a public site')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--slug <slug>', 'URL slug for the site')
+        .requiredOption('--title <title>', 'Site title')
+        .option('--description <desc>', 'Site description')
+        .option('--show-sidebar', 'Show sidebar navigation')
+        .option('--enable-search', 'Enable search on the site')
+        .option('--theme <theme>', 'Site theme')
+        .option('--domain <domainId>', 'Custom domain ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Publishing vault...');
+        try {
+            const client = await getClientAsync();
+            const published = await client.publishVault.publish(vaultId, {
+                slug: _opts.slug,
+                title: _opts.title,
+                description: _opts.description,
+                showSidebar: _opts.showSidebar === true,
+                enableSearch: _opts.enableSearch === true,
+                theme: _opts.theme,
+                customDomainId: _opts.domain,
+            });
+            out.success(`Vault published at /${published.slug}`, { id: published.id, slug: published.slug, title: published.title });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to publish vault');
+        }
+    });
+    addGlobalFlags(pv.command('update')
+        .description('Update a published vault site')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--slug <slug>', 'URL slug')
+        .option('--title <title>', 'Site title')
+        .option('--description <desc>', 'Site description')
+        .option('--show-sidebar', 'Show sidebar')
+        .option('--enable-search', 'Enable search')
+        .option('--theme <theme>', 'Site theme')
+        .option('--domain <domainId>', 'Custom domain ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating published vault...');
+        try {
+            const client = await getClientAsync();
+            const params = {};
+            if (_opts.slug)
+                params.slug = _opts.slug;
+            if (_opts.title)
+                params.title = _opts.title;
+            if (_opts.description)
+                params.description = _opts.description;
+            if (_opts.showSidebar !== undefined)
+                params.showSidebar = _opts.showSidebar === true;
+            if (_opts.enableSearch !== undefined)
+                params.enableSearch = _opts.enableSearch === true;
+            if (_opts.theme)
+                params.theme = _opts.theme;
+            if (_opts.domain)
+                params.customDomainId = _opts.domain;
+            const published = await client.publishVault.update(vaultId, params);
+            out.success('Published vault updated', { id: published.id, slug: published.slug });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update published vault');
+        }
+    });
+    addGlobalFlags(pv.command('unpublish')
+        .description('Unpublish a vault site')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Unpublishing vault...');
+        try {
+            const client = await getClientAsync();
+            await client.publishVault.unpublish(vaultId);
+            out.success('Vault unpublished', { vaultId });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to unpublish vault');
+        }
+    });
+}

package/dist/commands/publish.js

@@ -1,7 +1,7 @@
+import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
-import chalk from 'chalk';
 export function registerPublishCommands(program) {
     const publish = program.command('publish').description('Publish documents to public profile pages');
     addGlobalFlags(publish.command('list')
@@ -121,10 +121,15 @@ export function registerPublishCommands(program) {
     addGlobalFlags(publish.command('delete')
         .description('Unpublish a document')
         .argument('<vaultId>', 'Vault ID')
-        .argument('<docPath>', 'Document path (e.g., blog/post.md)'))
+        .argument('<docPath>', 'Document path (e.g., blog/post.md)')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (vaultId, docPath, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to unpublish document ${docPath}.`));
+            return;
+        }
         out.startSpinner('Unpublishing document...');
         try {
             const client = await getClientAsync();
@@ -135,4 +140,60 @@ export function registerPublishCommands(program) {
             handleError(out, err, 'Failed to unpublish document');
         }
     });
+    const subdomain = publish.command('subdomain').description('Subdomain management for published vaults');
+    addGlobalFlags(subdomain.command('get')
+        .description('Get the subdomain for a published vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching subdomain...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.publish.getSubdomain(vaultId);
+            out.stopSpinner();
+            out.record({ subdomain: result.subdomain });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch subdomain');
+        }
+    });
+    addGlobalFlags(subdomain.command('set')
+        .description('Set a subdomain for a published vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<subdomain>', 'Subdomain to assign'))
+        .action(async (vaultId, subdomainArg, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Setting subdomain...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.publish.setSubdomain(vaultId, subdomainArg);
+            out.success(`Subdomain set: ${result.subdomain}`, { subdomain: result.subdomain });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to set subdomain');
+        }
+    });
+    addGlobalFlags(subdomain.command('delete')
+        .description('Remove the subdomain for a published vault')
+        .argument('<vaultId>', 'Vault ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to remove the subdomain for vault ${vaultId}.`));
+            return;
+        }
+        out.startSpinner('Removing subdomain...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.publish.deleteSubdomain(vaultId);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete subdomain');
+        }
+    });
 }

package/dist/commands/saml.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerSamlCommands(program: Command): void;

package/dist/commands/saml.js

@@ -0,0 +1,220 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerSamlCommands(program) {
+    const saml = program.command('saml').description('SAML SSO configuration management (requires admin role)');
+    // ── list-configs ─────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('list-configs')
+        .description('List all SSO configurations'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching SSO configs...');
+        try {
+            const client = await getClientAsync();
+            const configs = await client.saml.listConfigs();
+            out.stopSpinner();
+            if (configs.length === 0 && flags.output !== 'json') {
+                out.raw('No SSO configurations found.\n');
+            }
+            else {
+                out.list(configs.map((c) => ({
+                    id: c.id,
+                    domain: c.domain,
+                    slug: c.slug,
+                    entityId: c.entityId,
+                    ssoUrl: c.ssoUrl,
+                })), {
+                    columns: [
+                        { key: 'id', header: 'ID' },
+                        { key: 'domain', header: 'Domain' },
+                        { key: 'slug', header: 'Slug' },
+                        { key: 'entityId', header: 'Entity ID' },
+                        { key: 'ssoUrl', header: 'SSO URL' },
+                    ],
+                    textFn: (c) => `${chalk.cyan(String(c.domain))} ${chalk.dim(`[${String(c.slug)}]`)} — ${chalk.dim(String(c.ssoUrl))}`,
+                });
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch SSO configs');
+        }
+    });
+    // ── get-config ───────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('get-config')
+        .description('Get a single SSO configuration by ID')
+        .argument('<id>', 'SSO config ID'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching SSO config...');
+        try {
+            const client = await getClientAsync();
+            const config = await client.saml.getConfig(id);
+            out.stopSpinner();
+            out.record({
+                id: config.id,
+                domain: config.domain,
+                slug: config.slug,
+                entityId: config.entityId,
+                ssoUrl: config.ssoUrl,
+                spEntityId: config.spEntityId,
+                createdAt: config.createdAt,
+                updatedAt: config.updatedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch SSO config');
+        }
+    });
+    // ── create-config ─────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('create-config')
+        .description('Create a new SSO configuration')
+        .requiredOption('--domain <domain>', 'Customer/tenant domain (e.g. acmecorp.com)')
+        .requiredOption('--slug <slug>', 'URL slug for SAML endpoints (e.g. acmecorp)')
+        .requiredOption('--entity-id <entityId>', 'Identity Provider entity ID URI')
+        .requiredOption('--sso-url <ssoUrl>', 'Identity Provider Single Sign-On URL')
+        .requiredOption('--certificate <cert>', 'X.509 certificate (PEM-encoded)')
+        .option('--sp-entity-id <spEntityId>', 'Optional Service Provider entity ID override'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating SSO config...');
+        try {
+            const client = await getClientAsync();
+            const created = await client.saml.createConfig({
+                domain: _opts.domain,
+                slug: _opts.slug,
+                entityId: _opts.entityId,
+                ssoUrl: _opts.ssoUrl,
+                certificate: _opts.certificate,
+                spEntityId: _opts.spEntityId,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(created, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`SSO config created for ${created.domain} (${created.id})`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create SSO config');
+        }
+    });
+    // ── update-config ─────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('update-config')
+        .description('Update an existing SSO configuration')
+        .argument('<id>', 'SSO config ID')
+        .option('--domain <domain>', 'Updated customer domain')
+        .option('--slug <slug>', 'Updated URL slug')
+        .option('--entity-id <entityId>', 'Updated Identity Provider entity ID')
+        .option('--sso-url <ssoUrl>', 'Updated Identity Provider SSO URL')
+        .option('--certificate <cert>', 'Updated X.509 certificate')
+        .option('--sp-entity-id <spEntityId>', 'Updated Service Provider entity ID'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        const data = {};
+        if (_opts.domain)
+            data.domain = _opts.domain;
+        if (_opts.slug)
+            data.slug = _opts.slug;
+        if (_opts.entityId)
+            data.entityId = _opts.entityId;
+        if (_opts.ssoUrl)
+            data.ssoUrl = _opts.ssoUrl;
+        if (_opts.certificate)
+            data.certificate = _opts.certificate;
+        if (_opts.spEntityId)
+            data.spEntityId = _opts.spEntityId;
+        if (Object.keys(data).length === 0) {
+            out.error('No updates specified. Use --domain, --slug, --entity-id, --sso-url, --certificate, or --sp-entity-id.');
+            process.exitCode = 2;
+            return;
+        }
+        out.startSpinner('Updating SSO config...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.saml.updateConfig(id, data);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`SSO config updated: ${updated.domain} (${updated.id})`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update SSO config');
+        }
+    });
+    // ── delete-config ─────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('delete-config')
+        .description('Delete an SSO configuration')
+        .argument('<id>', 'SSO config ID')
+        .option('--force', 'Skip confirmation prompt'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.force) {
+            out.raw(chalk.yellow(`Pass --force to delete SSO config ${id}.`) + '\n');
+            return;
+        }
+        out.startSpinner('Deleting SSO config...');
+        try {
+            const client = await getClientAsync();
+            await client.saml.deleteConfig(id);
+            out.stopSpinner();
+            out.raw(chalk.green(`SSO config ${id} deleted.`) + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete SSO config');
+        }
+    });
+    // ── metadata ──────────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('metadata')
+        .description('Show Service Provider metadata XML for an IdP slug')
+        .argument('<slug>', 'IdP slug'))
+        .action(async (slug, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching SP metadata...');
+        try {
+            const client = await getClientAsync();
+            const xml = await client.saml.getMetadata(slug);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify({ xml }, null, 2) + '\n');
+            }
+            else {
+                out.raw(xml + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch SP metadata');
+        }
+    });
+    // ── login-url ─────────────────────────────────────────────────────────────
+    addGlobalFlags(saml.command('login-url')
+        .description('Show the IdP login redirect URL for a slug')
+        .argument('<slug>', 'IdP slug'))
+        .action(async (slug, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        try {
+            const client = await getClientAsync();
+            const url = client.saml.getLoginUrl(slug);
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify({ url }, null, 2) + '\n');
+            }
+            else {
+                out.raw(url + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to build login URL');
+        }
+    });
+}

package/dist/commands/scim.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerScimCommands(program: Command): void;