@contentstack/cli-cm-export-query 1.0.0-beta.1

package/lib/core/query-executor.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryExporter = void 0;
+const tslib_1 = require("tslib");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const path = tslib_1.__importStar(require("path"));
+const query_parser_1 = require("../utils/query-parser");
+const module_exporter_1 = require("./module-exporter");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("../utils");
+const utils_4 = require("../utils");
+class QueryExporter {
+    constructor(managementAPIClient, exportQueryConfig) {
+        this.exportQueryConfig = exportQueryConfig;
+        this.stackAPIClient = managementAPIClient.stack({
+            api_key: exportQueryConfig.stackApiKey,
+            management_token: exportQueryConfig.managementToken,
+        });
+        // Initialize components
+        this.queryParser = new query_parser_1.QueryParser(this.exportQueryConfig);
+        this.moduleExporter = new module_exporter_1.ModuleExporter(exportQueryConfig);
+    }
+    async execute() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Starting query-based export...', 'info');
+        // Step 1: Parse and validate query
+        const parsedQuery = await this.queryParser.parse(this.exportQueryConfig.query);
+        (0, logger_1.log)(this.exportQueryConfig, 'Query parsed and validated successfully', 'success');
+        // Step 2: Always export general modules
+        await this.exportGeneralModules();
+        // Step 4: Export queried modules
+        await this.exportQueriedModule(parsedQuery);
+        // Step 1: Read initial content types and mark them as exported
+        const contentTypesFilePath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types', 'schema.json');
+        const contentTypes = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath)) || [];
+        if (contentTypes.length === 0) {
+            (0, logger_1.log)(this.exportQueryConfig, 'No content types found, skipping export', 'info');
+            process.exit(0);
+        }
+        // Step 5: export other content types which are referenced in previous step
+        await this.exportReferencedContentTypes();
+        // Step 6: export dependent modules global fields, extensions, taxonomies
+        await this.exportDependentModules();
+        // Step 7: export content modules entries, assets
+        await this.exportContentModules();
+        // Step 9: export all other modules
+        (0, logger_1.log)(this.exportQueryConfig, 'Query-based export completed successfully!', 'success');
+    }
+    // export general modules
+    async exportGeneralModules() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Exporting general modules...', 'info');
+        for (const module of this.exportQueryConfig.modules.general) {
+            await this.moduleExporter.exportModule(module);
+        }
+    }
+    async exportQueriedModule(parsedQuery) {
+        for (const [moduleName] of Object.entries(parsedQuery.modules)) {
+            const module = moduleName;
+            if (!this.exportQueryConfig.modules.queryable.includes(module)) {
+                (0, logger_1.log)(this.exportQueryConfig, `Module "${module}" is not queryable`, 'error');
+                continue;
+            }
+            (0, logger_1.log)(this.exportQueryConfig, `Exporting ${moduleName} with query...`, 'info');
+            // Export the queried module
+            await this.moduleExporter.exportModule(module, { query: parsedQuery });
+        }
+    }
+    async exportReferencedContentTypes() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of referenced content types...', 'info');
+        try {
+            const referencedHandler = new utils_1.ReferencedContentTypesHandler(this.exportQueryConfig);
+            const exportedContentTypeUIDs = new Set();
+            // Step 1: Read initial content types and mark them as exported
+            const contentTypesFilePath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types', 'schema.json');
+            const contentTypes = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath)) || [];
+            if (contentTypes.length === 0) {
+                (0, logger_1.log)(this.exportQueryConfig, 'No content types found, skipping referenced content types export', 'info');
+                return;
+            }
+            // Step 2: Start with initial batch (all currently exported content types)
+            let currentBatch = [...contentTypes];
+            (0, logger_1.log)(this.exportQueryConfig, `Starting with ${currentBatch.length} initial content types`, 'info');
+            // track reference depth
+            let iterationCount = 0;
+            // Step 3: Process batches until no new references are found
+            while (currentBatch.length > 0 && iterationCount < this.exportQueryConfig.maxCTReferenceDepth) {
+                iterationCount++;
+                currentBatch.forEach((ct) => exportedContentTypeUIDs.add(ct.uid));
+                // Extract referenced content types from current batch
+                const referencedUIDs = await referencedHandler.extractReferencedContentTypes(currentBatch);
+                // Filter out already exported content types
+                const newReferencedUIDs = referencedUIDs.filter((uid) => !exportedContentTypeUIDs.has(uid));
+                if (newReferencedUIDs.length > 0) {
+                    (0, logger_1.log)(this.exportQueryConfig, `Found ${newReferencedUIDs.length} new referenced content types to fetch`, 'info');
+                    // // Add to exported set to avoid duplicates in future iterations
+                    // newReferencedUIDs.forEach((uid) => exportedContentTypeUIDs.add(uid));
+                    // Step 4: Fetch new content types using moduleExporter
+                    const query = {
+                        modules: {
+                            'content-types': {
+                                uid: {
+                                    $in: newReferencedUIDs,
+                                },
+                            },
+                        },
+                    };
+                    await this.moduleExporter.exportModule('content-types', { query });
+                    const newContentTypes = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath));
+                    currentBatch = [...newContentTypes];
+                    // Push new content types to main array
+                    contentTypes.push(...newContentTypes);
+                    (0, logger_1.log)(this.exportQueryConfig, `Fetched ${currentBatch.length} new content types for next iteration`, 'info');
+                }
+                else {
+                    (0, logger_1.log)(this.exportQueryConfig, 'No new referenced content types found, stopping recursion', 'info');
+                    break;
+                }
+            }
+            utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath), contentTypes);
+            (0, logger_1.log)(this.exportQueryConfig, 'Referenced content types export completed successfully', 'success');
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error exporting referenced content types: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    async exportDependentModules() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of dependent modules...', 'info');
+        try {
+            const dependenciesHandler = new utils_3.ContentTypeDependenciesHandler(this.stackAPIClient, this.exportQueryConfig);
+            // Extract dependencies from all exported content types
+            const dependencies = await dependenciesHandler.extractDependencies();
+            // Export Global Fields
+            if (dependencies.globalFields.size > 0) {
+                const globalFieldUIDs = Array.from(dependencies.globalFields);
+                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${globalFieldUIDs.length} global fields...`, 'info');
+                const query = {
+                    modules: {
+                        'global-fields': {
+                            uid: { $in: globalFieldUIDs },
+                        },
+                    },
+                };
+                await this.moduleExporter.exportModule('global-fields', { query });
+            }
+            // Export Extensions
+            if (dependencies.extensions.size > 0) {
+                const extensionUIDs = Array.from(dependencies.extensions);
+                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${extensionUIDs.length} extensions...`, 'info');
+                const query = {
+                    modules: {
+                        extensions: {
+                            uid: { $in: extensionUIDs },
+                        },
+                    },
+                };
+                await this.moduleExporter.exportModule('extensions', { query });
+            }
+            // export marketplace apps
+            if (dependencies.marketplaceApps.size > 0) {
+                const marketplaceAppInstallationUIDs = Array.from(dependencies.marketplaceApps);
+                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${marketplaceAppInstallationUIDs.length} marketplace apps...`, 'info');
+                const query = {
+                    modules: {
+                        'marketplace-apps': {
+                            installation_uid: { $in: marketplaceAppInstallationUIDs },
+                        },
+                    },
+                };
+                await this.moduleExporter.exportModule('marketplace-apps', { query });
+            }
+            // Export Taxonomies
+            if (dependencies.taxonomies.size > 0) {
+                const taxonomyUIDs = Array.from(dependencies.taxonomies);
+                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${taxonomyUIDs.length} taxonomies...`, 'info');
+                const query = {
+                    modules: {
+                        taxonomies: {
+                            uid: { $in: taxonomyUIDs },
+                        },
+                    },
+                };
+                await this.moduleExporter.exportModule('taxonomies', { query });
+            }
+            // export personalize
+            await this.moduleExporter.exportModule('personalize');
+            (0, logger_1.log)(this.exportQueryConfig, 'Dependent modules export completed successfully', 'success');
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error exporting dependent modules: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    async exportContentModules() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of content modules...', 'info');
+        try {
+            // Step 1: Export entries for all exported content types
+            await this.exportEntries();
+            // Step 2: Export referenced assets from entries
+            // add a delay of 5 seconds
+            const delay = this.exportQueryConfig.exportDelayMs || 5000;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            await this.exportReferencedAssets();
+            (0, logger_1.log)(this.exportQueryConfig, 'Content modules export completed successfully', 'success');
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error exporting content modules: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    async exportEntries() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Exporting entries...', 'info');
+        try {
+            // Export entries - module exporter will automatically read exported content types
+            // and export entries for all of them
+            await this.moduleExporter.exportModule('entries');
+            (0, logger_1.log)(this.exportQueryConfig, 'Entries export completed successfully', 'success');
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error exporting entries: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    async exportReferencedAssets() {
+        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of referenced assets...', 'info');
+        try {
+            const assetHandler = new utils_4.AssetReferenceHandler(this.exportQueryConfig);
+            // Extract referenced asset UIDs from all entries
+            const assetUIDs = assetHandler.extractReferencedAssets();
+            if (assetUIDs.length > 0) {
+                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${assetUIDs.length} referenced assets...`, 'info');
+                const query = {
+                    modules: {
+                        assets: {
+                            uid: { $in: assetUIDs },
+                        },
+                    },
+                };
+                await this.moduleExporter.exportModule('assets', { query });
+                (0, logger_1.log)(this.exportQueryConfig, 'Referenced assets exported successfully', 'success');
+            }
+            else {
+                (0, logger_1.log)(this.exportQueryConfig, 'No referenced assets found in entries', 'info');
+            }
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error exporting referenced assets: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+}
+exports.QueryExporter = QueryExporter;

package/lib/types/index.d.ts

@@ -0,0 +1,161 @@
+export interface AuthOptions {
+    contentstackClient: any;
+}
+export interface ContentStackManagementClient {
+    contentstackClient: object;
+}
+export interface PrintOptions {
+    color?: string;
+}
+export interface InquirePayload {
+    type: string;
+    name: string;
+    message: string;
+    choices?: Array<any>;
+    transformer?: Function;
+}
+export interface User {
+    email: string;
+    authtoken: string;
+}
+export interface Region {
+    name: string;
+    cma: string;
+    cda: string;
+    uiHost: string;
+}
+export type Modules = 'stack' | 'locales' | 'environments' | 'content-types' | 'global-fields' | 'extensions' | 'taxonomies' | 'entries' | 'assets' | 'webhooks' | 'workflows' | 'custom-roles' | 'labels' | 'marketplace-apps' | 'personalize';
+export interface ModuleQueryConfig {
+    supportedFields: string[];
+    supportedOperators: string[];
+    defaultLimit: number;
+    includeGlobalFieldSchema?: boolean;
+    includePublishDetails?: boolean;
+    includeDimension?: boolean;
+}
+export interface DependencyAnalysisConfig {
+    enabled: boolean;
+    fields?: string[];
+    extractors?: string[];
+}
+export interface ModuleDefinition {
+    dirName: string;
+    fileName: string;
+    apiEndpoint: string;
+    queryable: boolean;
+    dependencies: Modules[];
+    queryConfig?: ModuleQueryConfig;
+    dependencyAnalysis?: DependencyAnalysisConfig;
+    limit?: number;
+    batchLimit?: number;
+}
+export interface DependencyExtractor {
+    fieldType: string;
+    extract: (data: any) => string[];
+    targetModule: Modules;
+}
+export interface ExportOptions {
+    query?: any;
+    alias?: string;
+    directory?: string;
+    branch?: string;
+    skipReferences?: boolean;
+    skipDependencies?: boolean;
+    securedAssets?: boolean;
+    includeGlobalFieldSchema?: boolean;
+    includePublishDetails?: boolean;
+    includeDimension?: boolean;
+    contentTypes?: string[];
+    uids?: string[];
+    configPath?: string;
+    fetchConcurrency?: number;
+    writeConcurrency?: number;
+    batchSize?: number;
+    [key: string]: any;
+}
+export interface DefaultConfig {
+    contentVersion: number;
+    host: string;
+    exportDir?: string;
+    stackApiKey?: string;
+    managementToken?: string;
+    region?: Region;
+    branchName?: string;
+    securedAssets?: boolean;
+    query?: string;
+    queryInput?: string;
+    skipReferences?: boolean;
+    skipDependencies?: boolean;
+    isQueryBasedExport?: boolean;
+    modules: {
+        general: Modules[];
+        queryable: Modules[];
+        dependent: Modules[];
+        content: Modules[];
+        exportOrder: Modules[];
+        definitions?: Record<Modules, ModuleDefinition>;
+    };
+    queryConfig: {
+        maxRecursionDepth?: number;
+        batchSize?: number;
+        metadataFileName?: string;
+        validation: {
+            maxQueryDepth?: number;
+            maxArraySize?: number;
+            allowedDateFormats?: string[];
+        };
+    };
+    dependencyExtractors?: Record<string, DependencyExtractor>;
+    fetchConcurrency: number;
+    writeConcurrency: number;
+    developerHubBaseUrl?: string;
+    branches?: Array<{
+        uid: string;
+        source: string;
+    }>;
+    branchEnabled?: boolean;
+    branchDir?: string;
+    apis: {
+        stacks: string;
+        locales: string;
+        environments: string;
+        content_types: string;
+        global_fields: string;
+        extensions: string;
+        taxonomies: string;
+        entries: string;
+        assets: string;
+    };
+    externalConfigPath?: string;
+    maxCTReferenceDepth: number;
+}
+export interface QueryExportConfig extends DefaultConfig {
+    query: string;
+    skipReferences: boolean;
+    skipDependencies: boolean;
+    stackApiKey: string;
+    managementToken?: string;
+    branchName: string;
+    securedAssets: boolean;
+    logsPath: string;
+    dataPath: string;
+    exportDelayMs?: number;
+}
+export interface QueryMetadata {
+    query: any;
+    flags: {
+        skipReferences: boolean;
+        skipDependencies: boolean;
+    };
+    timestamp: string;
+    cliVersion: string;
+    exportedModules: string[];
+    contentTypes: Array<{
+        uid: string;
+        title: string;
+    }>;
+    summary: {
+        totalContentTypes: number;
+        totalModules: number;
+    };
+}

package/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/common-helper.d.ts

@@ -0,0 +1 @@
+export declare const askAPIKey: () => Promise<string>;

package/lib/utils/common-helper.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askAPIKey = void 0;
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const askAPIKey = async () => {
+    return await cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'Enter the stack api key',
+        name: 'apiKey',
+    });
+};
+exports.askAPIKey = askAPIKey;

package/lib/utils/config-handler.d.ts

@@ -0,0 +1,2 @@
+import { QueryExportConfig } from '../types';
+export declare function setupQueryExportConfig(flags: any): Promise<QueryExportConfig>;

package/lib/utils/config-handler.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupQueryExportConfig = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../config"));
+const common_helper_1 = require("./common-helper");
+async function setupQueryExportConfig(flags) {
+    var _a;
+    const exportDir = (0, cli_utilities_1.sanitizePath)(flags['data-dir'] || (0, cli_utilities_1.pathValidator)('export'));
+    const exportQueryConfig = Object.assign(Object.assign({}, config_1.default), { exportDir, stackApiKey: flags['stack-api-key'] || '', managementToken: flags.alias ? (_a = cli_utilities_1.configHandler.get(`tokens.${flags.alias}`)) === null || _a === void 0 ? void 0 : _a.token : undefined, query: flags.query, skipReferences: flags['skip-references'] || false, skipDependencies: flags['skip-dependencies'] || false, branchName: flags.branch, securedAssets: flags['secured-assets'] || false, isQueryBasedExport: true, logsPath: exportDir, dataPath: exportDir, 
+        // Todo: accept the path of the config file from the user
+        externalConfigPath: path.join(__dirname, '../config/export-config.json') });
+    // Handle authentication
+    if (flags.alias) {
+        const { token, apiKey } = cli_utilities_1.configHandler.get(`tokens.${flags.alias}`) || {};
+        config_1.default.managementToken = token;
+        config_1.default.stackApiKey = apiKey;
+        if (!config_1.default.managementToken) {
+            throw new Error(`No management token found on given alias ${flags.alias}`);
+        }
+    }
+    if (!config_1.default.managementToken) {
+        if (!(0, cli_utilities_1.isAuthenticated)()) {
+            throw new Error('Please login or provide an alias for the management token');
+        }
+        else {
+            config_1.default.stackApiKey = flags['stack-api-key'] || (await (0, common_helper_1.askAPIKey)());
+            if (typeof config_1.default.stackApiKey !== 'string') {
+                throw new Error('Invalid API key received');
+            }
+        }
+    }
+    return exportQueryConfig;
+}
+exports.setupQueryExportConfig = setupQueryExportConfig;

package/lib/utils/content-type-helper.d.ts

@@ -0,0 +1,19 @@
+import { QueryExportConfig } from '../types';
+export declare class ReferencedContentTypesHandler {
+    private exportQueryConfig;
+    constructor(exportQueryConfig: QueryExportConfig);
+    /**
+     * Extract referenced content types from a batch of content types
+     * This method only processes the given batch, doesn't orchestrate the entire process
+     */
+    extractReferencedContentTypes(contentTypeBatch: any[]): Promise<string[]>;
+    /**
+     * Filter content types to get only newly fetched ones based on UIDs
+     */
+    filterNewlyFetchedContentTypes(allContentTypes: any[], previousUIDs: Set<string>): any[];
+    /**
+     * Extract referenced content types from a content type schema
+     * Moved from content-type-helper.ts for better encapsulation
+     */
+    private getReferencedContentTypes;
+}

package/lib/utils/content-type-helper.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferencedContentTypesHandler = void 0;
+const logger_1 = require("./logger");
+class ReferencedContentTypesHandler {
+    constructor(exportQueryConfig) {
+        this.exportQueryConfig = exportQueryConfig;
+    }
+    /**
+     * Extract referenced content types from a batch of content types
+     * This method only processes the given batch, doesn't orchestrate the entire process
+     */
+    async extractReferencedContentTypes(contentTypeBatch) {
+        const allReferencedTypes = new Set();
+        (0, logger_1.log)(this.exportQueryConfig, `Extracting references from ${contentTypeBatch.length} content types`, 'info');
+        for (const contentType of contentTypeBatch) {
+            if (contentType.schema) {
+                const referencedTypes = this.getReferencedContentTypes(contentType.schema);
+                referencedTypes.forEach((type) => allReferencedTypes.add(type));
+            }
+        }
+        const result = Array.from(allReferencedTypes);
+        (0, logger_1.log)(this.exportQueryConfig, `Found ${result.length} referenced content types`, 'info');
+        return result;
+    }
+    /**
+     * Filter content types to get only newly fetched ones based on UIDs
+     */
+    filterNewlyFetchedContentTypes(allContentTypes, previousUIDs) {
+        return allContentTypes.filter((ct) => !previousUIDs.has(ct.uid));
+    }
+    /**
+     * Extract referenced content types from a content type schema
+     * Moved from content-type-helper.ts for better encapsulation
+     */
+    getReferencedContentTypes(schema) {
+        const referencedTypes = new Set();
+        const traverseSchema = (schemaArray) => {
+            var _a, _b, _c, _d;
+            for (const field of schemaArray) {
+                if (field.data_type === 'group' || field.data_type === 'global_field') {
+                    // Recursively traverse group and global field schemas
+                    traverseSchema(field.schema);
+                }
+                else if (field.data_type === 'blocks') {
+                    // Traverse each block's schema
+                    for (const blockKey in field.blocks) {
+                        traverseSchema(field.blocks[blockKey].schema);
+                    }
+                }
+                else if (field.data_type === 'reference' && field.reference_to) {
+                    // Add reference field targets
+                    field.reference_to.forEach((ref) => {
+                        if (ref !== 'sys_assets') {
+                            // Exclude system assets
+                            referencedTypes.add(ref);
+                        }
+                    });
+                }
+                else if (
+                // Handle JSON RTE with embedded entries
+                field.data_type === 'json' &&
+                    ((_a = field.field_metadata) === null || _a === void 0 ? void 0 : _a.rich_text_type) &&
+                    ((_b = field.field_metadata) === null || _b === void 0 ? void 0 : _b.embed_entry) &&
+                    field.reference_to) {
+                    field.reference_to.forEach((ref) => {
+                        if (ref !== 'sys_assets') {
+                            referencedTypes.add(ref);
+                        }
+                    });
+                }
+                else if (
+                // Handle Text RTE with embedded entries
+                field.data_type === 'text' &&
+                    ((_c = field.field_metadata) === null || _c === void 0 ? void 0 : _c.rich_text_type) &&
+                    ((_d = field.field_metadata) === null || _d === void 0 ? void 0 : _d.embed_entry) &&
+                    field.reference_to) {
+                    field.reference_to.forEach((ref) => {
+                        if (ref !== 'sys_assets') {
+                            referencedTypes.add(ref);
+                        }
+                    });
+                }
+            }
+        };
+        traverseSchema(schema);
+        return Array.from(referencedTypes);
+    }
+}
+exports.ReferencedContentTypesHandler = ReferencedContentTypesHandler;

package/lib/utils/dependency-resolver.d.ts

@@ -0,0 +1,17 @@
+import { QueryExportConfig } from '../types';
+export declare class ContentTypeDependenciesHandler {
+    private exportQueryConfig;
+    private stackAPIClient;
+    constructor(stackAPIClient: any, exportQueryConfig: QueryExportConfig);
+    extractDependencies(): Promise<{
+        globalFields: Set<string>;
+        extensions: Set<string>;
+        taxonomies: Set<string>;
+        marketplaceApps: Set<string>;
+    }>;
+    fetchExtensionsAndMarketplaceApps(extensionUIDs: string[]): Promise<{
+        extensions: string[];
+        marketplaceApps: string[];
+    }>;
+    private traverseSchemaForDependencies;
+}