@strapi/strapi/dist/cli/utils/data-transfer.d.ts

An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite

import Table from 'cli-table3';
import { Command, Option } from 'commander';
import ora from 'ora';
import type { Core } from '@strapi/types';
import { engine as engineDataTransfer } from '@strapi/data-transfer';
declare const exitMessageText: (process: string, error?: boolean) => string;
declare const getDefaultExportName: () => string;
type ResultData = engineDataTransfer.ITransferResults<engineDataTransfer.ISourceProvider, engineDataTransfer.IDestinationProvider>['engine'];
declare const buildTransferTable: (resultData: ResultData) => Table.Table | undefined;
/** Media library content types — common target for `--exclude-content-types` (see issue #25008). */
declare const UPLOAD_CONTENT_TYPE_UIDS: readonly ["plugin::upload.file", "plugin::upload.folder"];
declare const isIgnoredContentType: (type: string) => boolean;
declare const abortTransfer: ({ engine, strapi, }: {
    engine: engineDataTransfer.TransferEngine;
    strapi: Core.Strapi;
}) => Promise<boolean>;
declare const setSignalHandler: (handler: (...args: unknown[]) => void, signals?: string[]) => Promise<void>;
declare const createStrapiInstance: (opts?: {
    logLevel?: string;
}) => Promise<Core.Strapi>;
declare const MEDIA_LIBRARY_PRESET = "media-library";
declare const throttleOption: Option;
declare const excludeOption: Option;
declare const onlyOption: Option;
declare const excludeContentTypesOption: Option;
declare const onlyContentTypesOption: Option;
type ContentTypeTransferOptions = {
    excludeContentTypes?: string[];
    onlyContentTypes?: string[];
};
type TransferExcludePreset = engineDataTransfer.TransferFilterPreset | typeof MEDIA_LIBRARY_PRESET;
type TransferCliFilterOptions = Partial<Omit<engineDataTransfer.ITransferEngineOptions, 'exclude' | 'only'>> & {
    exclude?: TransferExcludePreset[];
    only?: engineDataTransfer.TransferFilterPreset[];
} & ContentTypeTransferOptions & {
    /** Set when the files stage is auto-skipped because upload types are out of scope. */
    filesAutoExcluded?: boolean;
};
declare const validateExcludeOnly: (command: Command) => void;
declare const validateContentTypeTransferOptions: (command: Command) => void;
declare const validateContentTypeTransferOptionsForStrapi: (opts: ContentTypeTransferOptions, strapi: Core.Strapi) => void;
declare const createEntityFilter: (opts: TransferCliFilterOptions) => (entity: {
    type: string;
}) => boolean;
declare const createLinkFilter: (opts: TransferCliFilterOptions) => (link: {
    left: {
        type: string;
    };
    right: {
        type: string;
    };
}) => boolean;
declare const buildTransferTransforms: (opts: TransferCliFilterOptions) => {
    links: {
        filter: (link: {
            left: {
                type: string;
            };
            right: {
                type: string;
            };
        }) => boolean;
    }[];
    entities: {
        filter: (entity: {
            type: string;
        }) => boolean;
    }[];
};
declare const formatDiagnostic: (operation: string, verbose?: boolean) => Parameters<engineDataTransfer.TransferEngine["diagnostics"]["onDiagnostic"]>[0];
type Loaders = {
    [key in engineDataTransfer.TransferStage]: ora.Ora;
};
type Data = {
    [key in engineDataTransfer.TransferStage]?: {
        startTime?: number;
        endTime?: number;
        bytes?: number;
        count?: number;
        totalBytes?: number;
        totalCount?: number;
    };
};
declare const loadersFactory: (defaultLoaders?: Loaders) => {
    updateLoader: (stage: engineDataTransfer.TransferStage, data: Data) => ora.Ora;
    createLoader: (stage: engineDataTransfer.TransferStage) => ora.Ora;
    getLoader: (stage: engineDataTransfer.TransferStage) => ora.Ora;
};
/**
 * Get the telemetry data to be sent for a didDEITSProcess* event from an initialized transfer engine object
 */
declare const getTransferTelemetryPayload: (engine: engineDataTransfer.TransferEngine) => {
    eventProperties: {
        source: string;
        destination: string;
    };
};
/**
 * Get a transfer engine schema diff handler that confirms with the user before bypassing a schema check
 */
declare const getDiffHandler: (engine: engineDataTransfer.TransferEngine, { force, action, }: {
    force?: boolean;
    action: string;
}) => (context: engineDataTransfer.SchemaDiffHandlerContext, next: (ctx: engineDataTransfer.SchemaDiffHandlerContext) => void) => Promise<void>;
declare const getAssetsBackupHandler: (engine: engineDataTransfer.TransferEngine, { force, action, }: {
    force?: boolean;
    action: string;
}) => (context: engineDataTransfer.ErrorHandlerContext, next: (ctx: engineDataTransfer.ErrorHandlerContext) => void) => Promise<void>;
declare const shouldSkipStage: (opts: Pick<TransferCliFilterOptions, "exclude" | "only">, dataKind: engineDataTransfer.TransferFilterPreset) => boolean;
declare const areUploadContentTypesInTransferScope: (opts: TransferCliFilterOptions) => boolean;
declare const areAllUploadContentTypesOutOfTransferScope: (opts: TransferCliFilterOptions) => boolean;
declare const normalizeTransferFilterOptions: (opts: TransferCliFilterOptions) => TransferCliFilterOptions;
declare const normalizeTransferFilterOptionsHook: (command: Command) => void;
declare const logTransferFilterSummary: (opts: Partial<TransferCliFilterOptions>) => void;
declare const parseRestoreFromOptions: (opts: TransferCliFilterOptions, strapi: Core.Strapi) => import("@strapi/data-transfer/dist/strapi/providers/local-destination/strategies/restore").IRestoreOptions;
export { loadersFactory, buildTransferTable, getDefaultExportName, getTransferTelemetryPayload, isIgnoredContentType, createStrapiInstance, excludeOption, excludeContentTypesOption, onlyContentTypesOption, exitMessageText, onlyOption, throttleOption, validateExcludeOnly, validateContentTypeTransferOptions, validateContentTypeTransferOptionsForStrapi, normalizeTransferFilterOptions, normalizeTransferFilterOptionsHook, areUploadContentTypesInTransferScope, areAllUploadContentTypesOutOfTransferScope, buildTransferTransforms, createEntityFilter, createLinkFilter, formatDiagnostic, abortTransfer, setSignalHandler, getDiffHandler, getAssetsBackupHandler, shouldSkipStage, parseRestoreFromOptions, UPLOAD_CONTENT_TYPE_UIDS, logTransferFilterSummary, };
export type { ContentTypeTransferOptions, TransferCliFilterOptions };
//# sourceMappingURL=data-transfer.d.ts.map