@contentstack/cli-cm-import-setup 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Contentstack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+@contentstack/cli-cm-import
+
+It is Contentstack’s CLI plugin to import content in the stack. To learn how to export and import content in Contentstack, refer to the [Migration guide](https://www.contentstack.com/docs/developers/cli/migration/).
+
+[![License](https://img.shields.io/npm/l/@contentstack/cli)](https://github.com/contentstack/cli/blob/main/LICENSE)it -m
+
+<!-- toc -->
+* [Usage](#usage)
+* [Commands](#commands)
+<!-- tocstop -->
+
+For switching to EU region update the hosts at config/default.js
+
+```js
+{
+  host:'https://eu-api.contentstack.com/v3',
+  cdn: 'https://eu-cdn.contentstack.com/v3',
+ ...
+}
+```
+
+For switching to AZURE-NA region update the hosts at config/default.js
+
+```js
+{
+  host:'https://azure-na-api.contentstack.com/v3',
+  cdn: 'https://azure-na-cdn.contentstack.com/v3'
+ ...
+}
+```
+
+For switching to AZURE-EU region update the hosts at config/default.js
+
+```js
+{
+  host:'https://azure-eu-api.contentstack.com/v3',
+  cdn: 'https://azure-eu-cdn.contentstack.com/v3'
+ ...
+}
+```
+
+# Usage
+
+<!-- usage -->
+```sh-session
+$ npm install -g @contentstack/cli-cm-import-setup
+$ csdx COMMAND
+running command...
+$ csdx (--version)
+@contentstack/cli-cm-import-setup/1.0.0-beta.1 linux-x64 node-v18.20.5
+$ csdx --help [COMMAND]
+USAGE
+  $ csdx COMMAND
+...
+```
+<!-- usagestop -->
+
+# Commands
+
+<!-- commands -->
+* [`csdx cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]`](#csdx-cmstacksimport-setup--k-value--d-value--a-value---modules-valuevalue)
+* [`csdx cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]`](#csdx-cmstacksimport-setup--k-value--d-value--a-value---modules-valuevalue-1)
+
+## `csdx cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]`
+
+Import content from a stack
+
+```
+USAGE
+  $ csdx cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]
+
+FLAGS
+  -a, --alias=<value>          alias of the management token
+  -d, --data-dir=<value>       path and location where data is stored
+  -k, --stack-api-key=<value>  API key of the target stack
+  --modules=<option>           [optional] specific module name
+                               <options: content-types|entries|both>
+
+DESCRIPTION
+  Import content from a stack
+
+ALIASES
+  $ csdx cm:import-setup
+
+EXAMPLES
+  $ csdx cm:stacks:import-setup --stack-api-key <stack_api_key> --data-dir <path/of/export/destination/dir> --modules <module_name, module_name>
+```
+
+## `csdx cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]`
+
+Import content from a stack
+
+```
+USAGE
+  $ csdx cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]
+
+FLAGS
+  -a, --alias=<value>          alias of the management token
+  -d, --data-dir=<value>       path and location where data is stored
+  -k, --stack-api-key=<value>  API key of the target stack
+  --modules=<option>           [optional] specific module name
+                               <options: content-types|entries|both>
+
+DESCRIPTION
+  Import content from a stack
+
+ALIASES
+  $ csdx cm:import-setup
+
+EXAMPLES
+  $ csdx cm:stacks:import-setup --stack-api-key <stack_api_key> --data-dir <path/of/export/destination/dir> --modules <module_name, module_name>
+```
+
+_See code: [src/commands/cm/stacks/import-setup.ts](https://github.com/contentstack/cli/blob/main/packages/contentstack-import-setup/src/commands/cm/stacks/import-setup.ts)_
+<!-- commandsstop -->

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node_modules/.bin/ts-node
+// eslint-disable-next-line node/shebang, unicorn/prefer-top-level-await
+(async () => {
+  const oclif = await import('@oclif/core');
+  await oclif.execute({ development: true, dir: __dirname });
+})();

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// eslint-disable-next-line unicorn/prefer-top-level-await
+(async () => {
+  const oclif = await import('@oclif/core');
+  await oclif.execute({ development: false, dir: __dirname });
+})();

package/lib/commands/cm/stacks/import-setup.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@contentstack/cli-command';
+import { FlagInput } from '@contentstack/cli-utilities';
+export default class ImportSetupCommand extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: FlagInput;
+    static aliases: string[];
+    static usage: string;
+    run(): Promise<void>;
+}

package/lib/commands/cm/stacks/import-setup.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const cli_command_1 = require("@contentstack/cli-command");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../../../utils");
+const import_1 = require("../../../import");
+class ImportSetupCommand extends cli_command_1.Command {
+    async run() {
+        try {
+            const { flags } = await this.parse(ImportSetupCommand);
+            let importSetupConfig = await (0, utils_1.setupImportConfig)(flags);
+            // Note setting host to create cma client
+            importSetupConfig.host = this.cmaHost;
+            importSetupConfig.region = this.region;
+            importSetupConfig.developerHubBaseUrl = this.developerHubUrl;
+            const managementAPIClient = await (0, cli_utilities_1.managementSDKClient)(importSetupConfig);
+            const importSetup = new import_1.ImportSetup(importSetupConfig, managementAPIClient);
+            await importSetup.start();
+            (0, utils_1.log)(importSetupConfig, `Successfully created backup folder and mapper files for the stack with the API key ${importSetupConfig.apiKey}.`, 'success');
+            (0, utils_1.log)(importSetupConfig, `The backup folder created at '${(0, cli_utilities_1.pathValidator)(node_path_1.default.join(importSetupConfig.backupDir))}'`, 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)({ data: '' }, `Failed to create backup folder and mapper files - ${(0, cli_utilities_1.formatError)(error)}`, 'error');
+        }
+    }
+}
+exports.default = ImportSetupCommand;
+ImportSetupCommand.description = cli_utilities_1.messageHandler.parse('Import content from a stack');
+ImportSetupCommand.examples = [
+    `csdx cm:stacks:import-setup --stack-api-key <stack_api_key> --data-dir <path/of/export/destination/dir> --modules <module_name, module_name>`,
+];
+ImportSetupCommand.flags = {
+    'stack-api-key': cli_utilities_1.flags.string({
+        char: 'k',
+        description: 'API key of the target stack',
+    }),
+    'data-dir': cli_utilities_1.flags.string({
+        char: 'd',
+        description: 'path and location where data is stored',
+    }),
+    alias: cli_utilities_1.flags.string({
+        char: 'a',
+        description: 'alias of the management token',
+    }),
+    modules: cli_utilities_1.flags.string({
+        options: ['content-types', 'entries', 'both'],
+        description: '[optional] specific module name',
+    }),
+};
+ImportSetupCommand.aliases = ['cm:import-setup'];
+ImportSetupCommand.usage = 'cm:stacks:import-setup [-k <value>] [-d <value>] [-a <value>] [--modules <value,value>]';

package/lib/config/index.d.ts

@@ -0,0 +1,3 @@
+import { DefaultConfig } from '../types';
+declare const config: DefaultConfig;
+export default config;

package/lib/config/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    // use below hosts for eu region
+    // host:'https://eu-api.contentstack.com/v3',
+    // use below hosts for azure-na region
+    // host:'https://azure-na-api.contentstack.com/v3',
+    // use below hosts for azure-eu region
+    // host:'https://azure-eu-api.contentstack.com/v3',
+    // use below hosts for gcp-na region
+    // host:'https://gcp-na-api.contentstack.com',
+    // pass locale, only to migrate entries from that locale
+    // not passing `locale` will migrate all the locales present
+    // locales: ['fr-fr'],
+    host: 'https://api.contentstack.io/v3',
+    developerHubBaseUrl: '',
+    modules: {
+        'custom-roles': {
+            dirName: 'custom-roles',
+            fileName: 'custom-roles.json',
+            dependencies: ['environments', 'entries'],
+        },
+        environments: {
+            dirName: 'environments',
+            fileName: 'environments.json',
+        },
+        extensions: {
+            dirName: 'extensions',
+            fileName: 'extensions.json',
+        },
+        assets: {
+            dirName: 'assets',
+            fileName: 'assets.json',
+            fetchConcurrency: 5,
+        },
+        'content-types': {
+            dirName: 'content_types',
+            fileName: 'content_types.json',
+            dependencies: ['extensions', 'marketplace-apps', 'taxonomies'],
+        },
+        entries: {
+            dirName: 'entries',
+            fileName: 'entries.json',
+            dependencies: ['assets', 'marketplace-apps', 'taxonomies'],
+        },
+        'global-fields': {
+            dirName: 'global_fields',
+            fileName: 'globalfields.json',
+            dependencies: ['marketplace-apps'],
+        },
+        'marketplace-apps': {
+            dirName: 'marketplace_apps',
+            fileName: 'marketplace_apps.json',
+        },
+        taxonomies: {
+            dirName: 'taxonomies',
+            fileName: 'taxonomies.json',
+            invalidKeys: [
+                'updated_at',
+                'created_by',
+                'updated_by',
+                'stackHeaders',
+                'urlPath',
+                'created_at',
+                'ancestors',
+                'update',
+                'delete',
+                'fetch',
+                'descendants',
+                'move',
+                'search',
+            ],
+        },
+    },
+    fetchConcurrency: 5,
+};
+exports.default = config;

package/lib/import/import-setup.d.ts

@@ -0,0 +1,32 @@
+import { ImportConfig } from '../types';
+import { ContentstackClient } from '@contentstack/cli-utilities';
+export default class ImportSetup {
+    protected config: ImportConfig;
+    private managementAPIClient;
+    private importConfig;
+    private stackAPIClient;
+    dependencyTree: {
+        [key: string]: string[];
+    };
+    constructor(config: ImportConfig, managementAPIClient: ContentstackClient);
+    /**
+     * Generate mapper logic
+     * This method generates dependency tree based on the selected modules
+     * @returns {Promise<Array<void | string>>}
+     */
+    protected generateDependencyTree(): Promise<void>;
+    /**
+     * Run module imports based on the selected modules
+     * This method dynamically imports modules based on the selected modules
+     * and runs the start method of each module
+     * @returns {Promise<void>}
+     */
+    protected runModuleImports(): Promise<void>;
+    /**
+     * Start the import setup process
+     * This method generates mapper logic and runs module imports
+     * based on the selected modules
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+}

package/lib/import/import-setup.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+class ImportSetup {
+    constructor(config, managementAPIClient) {
+        this.dependencyTree = {};
+        this.config = config;
+        this.managementAPIClient = managementAPIClient;
+        this.stackAPIClient = this.managementAPIClient.stack({
+            api_key: this.config.apiKey,
+            management_token: this.config.management_token,
+        });
+    }
+    /**
+     * Generate mapper logic
+     * This method generates dependency tree based on the selected modules
+     * @returns {Promise<Array<void | string>>}
+     */
+    async generateDependencyTree() {
+        const getAllDependencies = (module, visited = new Set()) => {
+            var _a;
+            if (visited.has(module))
+                return [];
+            visited.add(module);
+            let dependencies = ((_a = this.config.modules[module]) === null || _a === void 0 ? void 0 : _a.dependencies) || [];
+            for (const dependency of dependencies) {
+                dependencies = dependencies.concat(getAllDependencies(dependency, visited));
+            }
+            return dependencies;
+        };
+        for (const module of this.config.selectedModules) {
+            const allDependencies = getAllDependencies(module);
+            this.dependencyTree[module] = Array.from(new Set(allDependencies));
+        }
+    }
+    /**
+     * Run module imports based on the selected modules
+     * This method dynamically imports modules based on the selected modules
+     * and runs the start method of each module
+     * @returns {Promise<void>}
+     */
+    async runModuleImports() {
+        var _a;
+        for (const moduleName in this.dependencyTree) {
+            try {
+                const modulePath = `./modules/${moduleName}`;
+                const { default: ModuleClass } = await (_a = modulePath, Promise.resolve().then(() => __importStar(require(_a))));
+                const modulePayload = {
+                    config: this.config,
+                    dependencies: this.dependencyTree[moduleName],
+                    stackAPIClient: this.stackAPIClient,
+                };
+                const moduleInstance = new ModuleClass(modulePayload);
+                await moduleInstance.start();
+            }
+            catch (error) {
+                (0, utils_1.log)(this.config, `Error importing '${moduleName}': ${(0, cli_utilities_1.formatError)(error)}`, 'error');
+                throw error;
+            }
+        }
+    }
+    /**
+     * Start the import setup process
+     * This method generates mapper logic and runs module imports
+     * based on the selected modules
+     * @returns {Promise<void>}
+     */
+    async start() {
+        try {
+            if (!this.config.management_token) {
+                const stackDetails = await this.stackAPIClient.fetch();
+                this.config.stackName = stackDetails.name;
+                this.config.org_uid = stackDetails.org_uid;
+            }
+            const backupDir = await (0, utils_1.backupHandler)(this.config);
+            if (backupDir) {
+                this.config.backupDir = backupDir;
+            }
+            await this.generateDependencyTree();
+            await this.runModuleImports();
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    }
+}
+exports.default = ImportSetup;

package/lib/import/index.d.ts

@@ -0,0 +1 @@
+export { default as ImportSetup } from './import-setup';

package/lib/import/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSetup = void 0;
+var import_setup_1 = require("./import-setup");
+Object.defineProperty(exports, "ImportSetup", { enumerable: true, get: function () { return __importDefault(import_setup_1).default; } });

package/lib/import/modules/assets.d.ts

@@ -0,0 +1,27 @@
+import { ModuleClassParams } from '../../types';
+import BaseImportSetup from './base-setup';
+export default class AssetImportSetup extends BaseImportSetup {
+    private assetsFilePath;
+    private assetUidMapper;
+    private assetUrlMapper;
+    private duplicateAssets;
+    private assetsConfig;
+    private mapperDirPath;
+    private assetsFolderPath;
+    private assetUidMapperPath;
+    private assetUrlMapperPath;
+    private duplicateAssetPath;
+    constructor({ config, stackAPIClient, dependencies }: ModuleClassParams);
+    /**
+     * Start the asset import setup
+     * This method reads the assets from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * @method importAssets
+     * @param {boolean} isVersion boolean
+     * @returns {Promise<void>} Promise<void>
+     */
+    fetchAndMapAssets(): Promise<void>;
+}

package/lib/import/modules/assets.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("../../utils");
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const base_setup_1 = tslib_1.__importDefault(require("./base-setup"));
+class AssetImportSetup extends base_setup_1.default {
+    constructor({ config, stackAPIClient, dependencies }) {
+        super({ config, stackAPIClient, dependencies });
+        this.assetsFolderPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'assets');
+        this.assetsFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'assets', 'assets.json');
+        this.assetsConfig = config.modules.assets;
+        this.mapperDirPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets');
+        this.assetUidMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'uid-mapping.json');
+        this.assetUrlMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'url-mapping.json');
+        this.duplicateAssetPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'duplicate-assets.json');
+        this.assetUidMapper = {};
+        this.assetUrlMapper = {};
+        this.duplicateAssets = {};
+    }
+    /**
+     * Start the asset import setup
+     * This method reads the assets from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    async start() {
+        try {
+            utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+            await this.fetchAndMapAssets();
+            (0, utils_1.log)(this.config, `Generated required setup files for asset`, 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, `Error generating asset mapper: ${(0, cli_utilities_1.formatError)(error)}`, 'error');
+        }
+    }
+    /**
+     * @method importAssets
+     * @param {boolean} isVersion boolean
+     * @returns {Promise<void>} Promise<void>
+     */
+    async fetchAndMapAssets() {
+        const processName = 'mapping assets';
+        const indexFileName = 'assets.json';
+        const basePath = this.assetsFolderPath;
+        const fs = new cli_utilities_1.FsUtility({ basePath, indexFileName });
+        const indexer = fs.indexFileContent;
+        const indexerCount = (0, lodash_1.values)(indexer).length;
+        const onSuccess = ({ response: { items = [] } = {}, apiData: { uid, url, title } = undefined, }) => {
+            if (items.length === 1) {
+                this.assetUidMapper[uid] = items[0].uid;
+                this.assetUrlMapper[url] = items[0].url;
+                (0, utils_1.log)(this.config, `Mapped asset: '${title}'`, 'info');
+            }
+            else if (items.length > 1) {
+                this.duplicateAssets[uid] = items.map((asset) => {
+                    return { uid: asset.uid, title: asset.title, url: asset.url };
+                });
+                (0, utils_1.log)(this.config, `Multiple assets found with title '${title}'`, 'info');
+            }
+            else {
+                (0, utils_1.log)(this.config, `Asset with title '${title}' not found in the stack!`, 'info');
+            }
+        };
+        const onReject = ({ error, apiData: { title } = undefined }) => {
+            (0, utils_1.log)(this.config, `${title} asset mapping failed.!`, 'error');
+            (0, utils_1.log)(this.config, (0, cli_utilities_1.formatError)(error), 'error');
+        };
+        /* eslint-disable @typescript-eslint/no-unused-vars, guard-for-in */
+        for (const index in indexer) {
+            const chunk = await fs.readChunkFiles.next().catch((error) => {
+                (0, utils_1.log)(this.config, error, 'error');
+            });
+            if (chunk) {
+                let apiContent = (0, lodash_1.orderBy)((0, lodash_1.values)(chunk), '_version');
+                await this.makeConcurrentCall({
+                    apiContent,
+                    processName,
+                    indexerCount,
+                    currentIndexer: +index,
+                    apiParams: {
+                        reject: onReject,
+                        resolve: onSuccess,
+                        entity: 'fetch-assets',
+                        includeParamOnCompletion: true,
+                    },
+                    concurrencyLimit: this.assetsConfig.fetchConcurrency,
+                }, undefined);
+            }
+        }
+        if (!(0, lodash_1.isEmpty)(this.assetUidMapper) || !(0, lodash_1.isEmpty)(this.assetUrlMapper)) {
+            utils_1.fsUtil.writeFile(this.assetUidMapperPath, this.assetUidMapper);
+            utils_1.fsUtil.writeFile(this.assetUrlMapperPath, this.assetUrlMapper);
+        }
+        if (!(0, lodash_1.isEmpty)(this.duplicateAssets)) {
+            utils_1.fsUtil.writeFile(this.duplicateAssetPath, this.duplicateAssets);
+            (0, utils_1.log)(this.config, `Duplicate asset files store here ${this.duplicateAssetPath}`, 'info');
+        }
+    }
+}
+exports.default = AssetImportSetup;

package/lib/import/modules/base-setup.d.ts

@@ -0,0 +1,37 @@
+import { ApiOptions, CustomPromiseHandler, EnvType, ImportConfig, ModuleClassParams } from '../../types';
+export default class BaseImportSetup {
+    config: ImportConfig;
+    stackAPIClient: ModuleClassParams['stackAPIClient'];
+    dependencies: ModuleClassParams['dependencies'];
+    constructor({ config, stackAPIClient, dependencies }: ModuleClassParams);
+    setupDependencies(): Promise<void>;
+    /**
+     * @method delay
+     * @param {number} ms number
+     * @returns {Promise} Promise<void>
+     */
+    delay(ms: number): Promise<void>;
+    /**
+     * @method makeConcurrentCall
+     * @param {Record<string, any>} env EnvType
+     * @param {CustomPromiseHandler} promisifyHandler CustomPromiseHandler
+     * @param {boolean} logBatchCompletionMsg boolean
+     * @returns {Promise} Promise<void>
+     */
+    makeConcurrentCall(env: EnvType, promisifyHandler?: CustomPromiseHandler, logBatchCompletionMsg?: boolean): Promise<void>;
+    /**
+     * @method logMsgAndWaitIfRequired
+     * @param {string} processName string
+     * @param {number} start number
+     * @param {number} batchNo - number
+     * @returns {Promise} Promise<void>
+     */
+    logMsgAndWaitIfRequired(processName: string, start: number, totelBatches: number, batchNo: number, logBatchCompletionMsg?: boolean, indexerCount?: number, currentIndexer?: number): Promise<void>;
+    /**
+     * @method makeAPICall
+     * @param {Record<string, any>} apiOptions - Api related params
+     * @param {Record<string, any>} isLastRequest - Boolean
+     * @return {Promise} Promise<void>
+     */
+    makeAPICall(apiOptions: ApiOptions, isLastRequest?: boolean): Promise<void>;
+}