@unito/integration-cli 0.55.1

package/dist/src/commands/dev.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const integrations_1 = require("../resources/integrations");
+const configuration_1 = require("../resources/configuration");
+const decryption_1 = require("../resources/decryption");
+class Dev extends baseCommand_1.BaseCommand {
+    static description = 'Develop your integration';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    static flags = {
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+        verbose: core_1.Flags.boolean({
+            description: 'output more (debug) information',
+            default: false,
+        }),
+        crawlMode: core_1.Flags.string({
+            description: 'mode to use while crawling the integration graph',
+            options: Object.values(configuration_1.CrawlMode),
+            default: configuration_1.CrawlMode.FULL,
+        }),
+        checks: core_1.Flags.string({
+            description: 'checks to perform while crawling the integration graph',
+            multiple: true,
+            default: [],
+        }),
+        'config-path': core_1.Flags.string({
+            summary: 'relative path to a custom ".unito.json" file',
+            description: `Use a custom configuration file instead of the default '.unito.json' or other environment specific
+      ones.
+
+      If you want to force the CLI to use a specific configuration file, you can use this flag to specify the relative
+      path from your integration's root folder (with a leading '/').
+
+      Usage: <%= config.bin %> <%= command.id %> --config-path=/myCustomConfig.json`,
+        }),
+    };
+    async run() {
+        (0, integrations_1.validateIsIntegrationDirectory)();
+        const { flags } = await this.parse(Dev);
+        // Install NPM dependencies.
+        core_1.ux.action.start('Installing NPM dependencies');
+        child_process_1.default.execSync('npm install', {
+            env: { ...process.env, NODE_ENV: 'development' },
+            stdio: ['ignore', 'ignore', 'inherit'],
+        });
+        core_1.ux.action.stop();
+        // Resolve the configuration.
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        const configuration = await (0, configuration_1.getConfiguration)(environment, flags['config-path']);
+        const credentialPayload = await (0, decryption_1.decryptTestAccountCredentials)(configuration, environment, configuration_1.CredentialScope.DEVELOPMENT, this.config.configDir);
+        // Decrypt secrets, if necessary.
+        const secrets = await (0, decryption_1.decryptSecrets)(configuration, environment, this.config.configDir);
+        // Launch the debugger.
+        const commandArguments = [
+            `${process.env.NODE_MODULES_FOLDER}/@unito/integration-debugger/dist/src/index.js`,
+            '--integration-url=http://localhost:9200',
+            `--spawn-process=npm run dev`,
+            `--credential-payload=${JSON.stringify(credentialPayload)}`,
+            `--secrets-payload=${JSON.stringify(secrets)}`,
+        ];
+        if (configuration.graphRelativeUrl) {
+            commandArguments.push(`--graph-relative-url=${configuration.graphRelativeUrl}`);
+        }
+        if (configuration.credentialAccountRelativeUrl) {
+            commandArguments.push(`--credential-account-relative-url=${configuration.credentialAccountRelativeUrl}`);
+        }
+        if (configuration.webhookParsingRelativeUrl) {
+            commandArguments.push(`--webhook-parsing-relative-url=${configuration.webhookParsingRelativeUrl}`);
+        }
+        if (configuration.webhookSubscriptionsRelativeUrl) {
+            commandArguments.push(`--webhook-subscriptions-relative-url=${configuration.webhookSubscriptionsRelativeUrl}`);
+        }
+        if (configuration.webhookAcknowledgeRelativeUrl) {
+            commandArguments.push(`--webhook-acknowledge-relative-url=${configuration.webhookAcknowledgeRelativeUrl}`);
+        }
+        if (flags.checks?.length) {
+            commandArguments.push(`--checks=${flags.checks.join(',')}`);
+        }
+        if (flags.verbose) {
+            commandArguments.push('--verbose');
+        }
+        if (flags['crawlMode'] === configuration_1.CrawlMode.SAMPLE) {
+            commandArguments.push('--operation-collection-items-per-page=10');
+            commandArguments.push('--operation-collection-follow-next-pages=false');
+        }
+        if (flags['crawlMode'] === configuration_1.CrawlMode.SINGLE) {
+            commandArguments.push('--operation-collection-items-per-page=1');
+            commandArguments.push('--operation-collection-follow-next-pages=false');
+        }
+        core_1.ux.log(`Launching... node ${commandArguments.join(' ')}`);
+        const child = child_process_1.default.spawn('node', commandArguments, {
+            detached: true,
+            stdio: 'inherit',
+            env: { ...process.env, NODE_ENV: 'development', PORT: '9200' },
+        });
+        // istanbul ignore next
+        child.on('exit', (code) => {
+            process.exit(code);
+        });
+        // Window change (ex: resize) signal.
+        // istanbul ignore next
+        process.on('SIGWINCH', () => {
+            child.kill('SIGWINCH');
+        });
+    }
+}
+exports.default = Dev;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../baseCommand';
+import * as GlobalConfiguration from '../resources/globalConfiguration';
+export default class Encrypt extends BaseCommand<typeof Encrypt> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<GlobalConfiguration.Environment | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/encrypt.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const integrations_1 = require("../resources/integrations");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../services/integrationsPlatform"));
+const IntegrationConfiguration = tslib_1.__importStar(require("../resources/configuration"));
+const integrationsPlatform_1 = require("../resources/integrationsPlatform");
+class Encrypt extends baseCommand_1.BaseCommand {
+    static description = 'Encrypt data';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        (0, integrations_1.validateIsIntegrationDirectory)();
+        const { flags } = await this.parse(Encrypt);
+        // Read the configurations.
+        const globalConfiguration = await GlobalConfiguration.read(this.config.configDir);
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        const integrationConfiguration = await IntegrationConfiguration.getConfiguration(environment);
+        await (0, integrationsPlatform_1.validateAuthenticated)(globalConfiguration, environment);
+        const { data } = await inquirer_1.default.prompt({
+            name: 'data',
+            message: 'Enter text to encrypt',
+            type: 'input',
+        });
+        core_1.ux.action.start('Encrypting data');
+        const { encryptedData } = await IntegrationsPlatform.encryptData(integrationConfiguration.name, data);
+        core_1.ux.action.stop();
+        core_1.ux.log(`Encrypted Data: ${chalk_1.default.greenBright(encryptedData)}`);
+    }
+}
+exports.default = Encrypt;

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

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../baseCommand';
+export default class Init extends BaseCommand<typeof Init> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/init.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const Configuration = tslib_1.__importStar(require("../resources/configuration"));
+const integrationGenerator_1 = require("../../integrationGenerator");
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+class Init extends baseCommand_1.BaseCommand {
+    static description = 'Initialize a new integration';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --name pokemon'];
+    static flags = {
+        name: core_1.Flags.string({ char: 'n', description: 'Name of the integration' }),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        const { flags: { name: nameFromFlag }, } = await this.parse(Init);
+        const name = nameFromFlag ??
+            (await inquirer_1.default.prompt([
+                {
+                    name: 'name',
+                    prefix: [
+                        chalk_1.default.gray('Choose a name for your integration.'),
+                        chalk_1.default.gray('A folder will be created with the value provided.'),
+                        chalk_1.default.gray('Note that "My Integration" will become "my_integration".'),
+                        chalk_1.default.greenBright('?'),
+                    ].join('\n'),
+                    message: chalk_1.default.yellowBright('What is the name of your integration?'),
+                    filter: name => name
+                        .toLowerCase()
+                        .replace(/ /g, '_')
+                        .replace(/[^a-z0-9_-]*/g, ''),
+                },
+            ])).name;
+        core_1.ux.action.start('\nInitializing integration');
+        const generatedPath = await integrationGenerator_1.Resources.Integration.generateIntegrationSkeleton(name, process.cwd());
+        process.chdir(generatedPath);
+        await Configuration.writeConfiguration({ name });
+        core_1.ux.action.stop();
+        core_1.ux.log(`Your integration is available at: ${chalk_1.default.greenBright(generatedPath)}`);
+    }
+}
+exports.default = Init;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../baseCommand';
+import * as GlobalConfiguration from '../resources/globalConfiguration';
+export default class Invite extends BaseCommand<typeof Invite> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<GlobalConfiguration.Environment | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/invite.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const integrations_1 = require("../resources/integrations");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../services/integrationsPlatform"));
+const IntegrationConfiguration = tslib_1.__importStar(require("../resources/configuration"));
+class Invite extends baseCommand_1.BaseCommand {
+    static description = 'Invite a user to become a developer of your integration';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        (0, integrations_1.validateIsIntegrationDirectory)();
+        const { flags } = await this.parse(Invite);
+        // Read the configurations.
+        const globalConfiguration = await GlobalConfiguration.read(this.config.configDir);
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        const integrationConfiguration = await IntegrationConfiguration.getConfiguration(environment);
+        // Choose the right API key for the environment.
+        let apiKey = undefined;
+        if (environment === GlobalConfiguration.Environment.Local) {
+            apiKey = globalConfiguration.apiKeyLocal;
+        }
+        else if (environment === GlobalConfiguration.Environment.Staging) {
+            apiKey = globalConfiguration.apiKeyStaging;
+        }
+        else {
+            apiKey = globalConfiguration.apiKey;
+        }
+        // Setup the platform client.
+        IntegrationsPlatform.setApiKey(apiKey);
+        IntegrationsPlatform.setEnvironment(environment);
+        const { email } = await inquirer_1.default.prompt([
+            {
+                name: 'email',
+                message: 'Type the email of the user you wish to invite:',
+                type: 'input',
+            },
+        ]);
+        core_1.ux.action.start('Finding the integration');
+        const integration = await IntegrationsPlatform.getIntegrationByName(integrationConfiguration.name);
+        if (!integration) {
+            core_1.ux.log(chalk_1.default.redBright(`Integration not found! You can only invite users to a published integration.`));
+            this.exit(-1);
+        }
+        core_1.ux.action.stop();
+        core_1.ux.action.start('Inviting user');
+        await IntegrationsPlatform.inviteUserToIntegration(integration.id, email);
+        core_1.ux.action.stop();
+        core_1.ux.log(`User successfully added! They should now be able to update and publish this integration.`);
+    }
+}
+exports.default = Invite;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../baseCommand';
+import * as GlobalConfiguration from '../resources/globalConfiguration';
+export default class Login extends BaseCommand<typeof Login> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<GlobalConfiguration.Environment | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/login.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const gradient = tslib_1.__importStar(require("gradient-string"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../services/integrationsPlatform"));
+class Login extends baseCommand_1.BaseCommand {
+    static description = 'Login to the Integrations Platform';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        const { flags } = await this.parse(Login);
+        // Read the current global configuration.
+        const configuration = await GlobalConfiguration.read(this.config.configDir);
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        // Inquire for the API key.
+        let apiKey = undefined;
+        try {
+            apiKey = (await inquirer_1.default.prompt([
+                {
+                    name: 'apiKey',
+                    message: 'Enter your API key:',
+                },
+            ])).apiKey;
+        }
+        catch (err) {
+            core_1.ux.log(chalk_1.default.redBright(`failed because: ${(err ?? {}).message}`));
+            this.exit(-1);
+        }
+        // Retrieve the user's profile.
+        core_1.ux.action.start('Log in...');
+        let profile = undefined;
+        IntegrationsPlatform.setEnvironment(environment);
+        IntegrationsPlatform.setApiKey(apiKey);
+        try {
+            profile = await IntegrationsPlatform.getProfile();
+        }
+        catch (err) {
+            core_1.ux.action.stop(chalk_1.default.redBright(`failed because: ${(err ?? {}).message}`));
+            this.exit(-1);
+        }
+        core_1.ux.action.stop();
+        core_1.ux.log([chalk_1.default.greenBright('Hello'), gradient.fruit(profile?.email ?? ''), chalk_1.default.greenBright('!')].join(' '));
+        // Set the API key in the global configuration.
+        if (environment === GlobalConfiguration.Environment.Local) {
+            configuration.apiKeyLocal = apiKey;
+        }
+        else if (environment === GlobalConfiguration.Environment.Staging) {
+            configuration.apiKeyStaging = apiKey;
+        }
+        else {
+            configuration.apiKey = apiKey;
+        }
+        // Write the new global configuration.
+        await GlobalConfiguration.write(this.config.configDir, configuration);
+    }
+}
+exports.default = Login;

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Oauth2 extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        accountName: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/oauth2.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const configuration_1 = require("../resources/configuration");
+const Oauth2Helper = tslib_1.__importStar(require("../services/oauth2Helper"));
+const configurationTypes_1 = require("../configurationTypes");
+const errors_1 = require("../errors");
+const globalConfiguration_1 = require("../resources/globalConfiguration");
+class Oauth2 extends core_1.Command {
+    static description = 'Perform an OAuth2 workflow locally';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        accountName: core_1.Flags.string({ description: 'Name of the account used to perfom oauth2 actions' }),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        const { flags } = await this.parse(Oauth2);
+        const accountName = flags.accountName ?? 'development';
+        // Might want to expose Environment flag, but for now we'll default to Production
+        const configuration = await (0, configuration_1.getConfiguration)(globalConfiguration_1.Environment.Production);
+        let oauth2 = configuration.authorizations?.find(authorization => authorization.method === configurationTypes_1.Method.OAUTH2 && authorization.name === accountName && authorization.development)?.oauth2;
+        if (!oauth2) {
+            const { oauth2Information } = await inquirer_1.default.prompt([
+                {
+                    name: 'oauth2Information',
+                    type: 'editor',
+                    message: `${chalk_1.default.yellowBright('OAuth2 credentials')} that will be used to authenticate to the API`,
+                    validate: (value) => {
+                        try {
+                            JSON.parse(value);
+                        }
+                        catch (e) {
+                            return false;
+                        }
+                        return true;
+                    },
+                    default: JSON.stringify({
+                        clientId: '',
+                        clientSecret: '',
+                        tokenUrl: '',
+                        authorizationUrl: '',
+                        scopes: [{ name: '', help: '' }],
+                        requestContentType: 'application/x-www-form-urlencoded',
+                        responseContentType: 'application/json',
+                        grantType: 'authorization_code',
+                    }, null, 2),
+                },
+            ]);
+            oauth2 = JSON.parse(oauth2Information);
+            if (!configuration.authorizations) {
+                configuration.authorizations = [];
+            }
+            configuration.authorizations.push({
+                name: 'development',
+                method: configurationTypes_1.Method.OAUTH2,
+                development: true,
+                oauth2,
+            });
+            core_1.ux.action.start('Saving configuration');
+            await (0, configuration_1.writeConfiguration)(configuration);
+            core_1.ux.action.stop();
+        }
+        if (!oauth2) {
+            throw new Error('No oauth2 information found');
+        }
+        const account = accountName === 'development' ? configuration.testAccounts?.development : configuration.testAccounts?.compliance;
+        let credentials;
+        if (Object.keys(account || {}).length === 0) {
+            core_1.ux.action.start(`Starting Oauth2 flow for account: ${accountName}`);
+            credentials = await Oauth2Helper.performOAuth2Flow(oauth2);
+            core_1.ux.action.stop();
+        }
+        else {
+            if (!account?.refreshToken) {
+                core_1.ux.log('No refresh token found, aborting refresh token flow');
+            }
+            core_1.ux.action.start(`Refreshing test account ${accountName}`);
+            credentials = await Oauth2Helper.updateToken({ ...oauth2, refreshToken: account?.refreshToken });
+            if (!credentials.refreshToken) {
+                credentials.refreshToken = account?.refreshToken;
+            }
+            core_1.ux.action.stop();
+        }
+        core_1.ux.action.start(`Saving credentials for account: ${accountName}`);
+        await (0, configuration_1.writeTestAccount)(configuration, credentials, accountName);
+        core_1.ux.action.stop();
+        return;
+    }
+}
+exports.default = Oauth2;

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

@@ -0,0 +1,28 @@
+import { BaseCommand } from '../baseCommand';
+import * as GlobalConfiguration from '../resources/globalConfiguration';
+export default class Publish extends BaseCommand<typeof Publish> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<GlobalConfiguration.Environment | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'registry-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        preview: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'live-preview': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'config-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+    private livePreviewIntegration;
+    private updateRegistry;
+    private copyAndMoveToTmpDir;
+    private previewIntegration;
+    private publishIntegration;
+    private indent;
+    private archiveIntegration;
+    private hashEmail;
+    private generateNewSecrets;
+    private reencryptData;
+    private getInstructionsImage;
+    private getInstructionsMarkdown;
+}