import { IdObjectSkeletonInterface } from '../api/ApiTypes';
import { State } from '../shared/State';
import { ExportMetaData } from './OpsTypes';
export type Mapping = {
    /**
     * Create an empty mapping export template
     * @returns {MappingExportInterface} an empty mapping export template
     */
    createMappingExportTemplate(): MappingExportInterface;
    /**
     * Read mappings from sync.json (legacy)
     * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
     */
    readSyncMappings(): Promise<MappingSkeleton[]>;
    /**
     * Read mappings
     * @param {string} connectorId limit mappings to connector
     * @param {string} moType limit mappings to managed object type
     * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
     */
    readMappings(connectorId?: string, moType?: string): Promise<MappingSkeleton[]>;
    /**
     * Read mapping
     * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
     * @returns {Promise<MappingSkeleton>} a promise that resolves an mapping object
     */
    readMapping(mappingId: string): Promise<MappingSkeleton>;
    /**
     * Create mapping
     * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
     * @param {MappingSkeleton} mappingData mapping object
     * @returns {Promise<MappingSkeleton>} a promise that resolves to an mapping object
     */
    createMapping(mappingId: string, mappingData: MappingSkeleton): Promise<MappingSkeleton>;
    /**
     * Update or create mapping
     * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
     * @param {MappingSkeleton} mappingData mapping object
     * @returns {Promise<MappingSkeleton>} a promise that resolves to an mapping object
     */
    updateMapping(mappingId: string, mappingData: MappingSkeleton): Promise<MappingSkeleton>;
    /**
     * Update or create mappings in sync.json (legacy)
     * @param {MappingSkeleton} mappingData mapping object
     * @returns {Promise<MappingSkeleton>} a promise that resolves to an mapping object
     */
    updateSyncMappings(mappings: MappingSkeleton[]): Promise<MappingSkeleton[]>;
    /**
     * Delete all mappings
     * @param {string} connectorId limit mappings to connector
     * @param {string} moType limit mappings to managed object type
     * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
     */
    deleteMappings(connectorId?: string, moType?: string): Promise<MappingSkeleton[]>;
    /**
     * Delete mapping
     * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
     * @returns {Promise<MappingSkeleton>} a promise that resolves an mapping object
     */
    deleteMapping(mappingId: string): Promise<MappingSkeleton>;
    /**
     * Export mapping
     * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
     * @param {MappingExportOptions} options export options
     * @returns {Promise<MappingExportInterface>} a promise that resolves to a MappingExportInterface object
     */
    exportMapping(mappingId: string, options?: MappingExportOptions): Promise<MappingExportInterface>;
    /**
     * Export all mappings
     * @param {MappingExportOptions} options export options
     * @returns {Promise<MappingExportInterface>} a promise that resolves to a MappingExportInterface object
     */
    exportMappings(options?: MappingExportOptions): Promise<MappingExportInterface>;
    /**
     * Import mapping
     * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
     * @param {MappingExportInterface} importData import data
     * @param {MappingImportOptions} options import options
     * @returns {Promise<MappingSkeleton>} a promise resolving to a MappingSkeleton object
     */
    importMapping(mappingId: string, importData: MappingExportInterface, options?: MappingImportOptions): Promise<MappingSkeleton>;
    /**
     * Import first mapping
     * @param {MappingExportInterface} importData import data
     * @param {MappingImportOptions} options import options
     * @returns {Promise<MappingSkeleton>} a promise resolving to a MappingSkeleton object
     */
    importFirstMapping(importData: MappingExportInterface, options?: MappingImportOptions): Promise<MappingSkeleton>;
    /**
     * Import all mappings
     * @param {MappingExportInterface} importData import data
     * @param {MappingImportOptions} options import options
     * @returns {Promise<MappingSkeleton[]>} a promise resolving to an array of MappingSkeleton objects
     */
    importMappings(importData: MappingExportInterface, options?: MappingImportOptions): Promise<MappingSkeleton[]>;
    /**
     * Helper that returns a boolean indicating whether the mapping is a legacy mapping or not given the id
     * @param {string} mappingId the mapping id
     * @returns {boolean} true if the mapping is a legacy mapping, false otherwise
     * @throws {FrodoError} if the id is invalid
     */
    isLegacyMapping(mappingId: string): boolean;
};
declare const _default: (state: State) => Mapping;
export default _default;
export type MappingPolicy = {
    action: 'CREATE' | 'DELETE' | 'EXCEPTION' | 'IGNORE' | 'UPDATE';
    situation: 'ABSENT' | 'ALL_GONE' | 'AMBIGUOUS' | 'CONFIRMED' | 'FOUND' | 'FOUND_ALREADY_LINKED' | 'LINK_ONLY' | 'MISSING' | 'SOURCE_IGNORED' | 'SOURCE_MISSING' | 'TARGET_IGNORED' | 'UNASSIGNED' | 'UNQUALIFIED';
};
export type MappingProperty = {
    source?: string;
    target: string;
    transform?: {
        globals: any;
        source: string;
        type: string;
    };
};
export type MappingSkeleton = IdObjectSkeletonInterface & {
    name: string;
    displayName?: string;
    linkQualifiers?: string[];
    consentRequired?: boolean;
    policies?: MappingPolicy[];
    properties?: MappingProperty[];
    source?: string;
    target?: string;
    syncAfter?: string[];
};
export type SyncSkeleton = IdObjectSkeletonInterface & {
    mappings: MappingSkeleton[];
};
export interface MappingExportInterface {
    meta?: ExportMetaData;
    mapping: Record<string, MappingSkeleton>;
    sync: SyncSkeleton;
}
/**
 * Mapping export options
 */
export interface MappingExportOptions {
    /**
     * Use string arrays to store multi-line text in scripts.
     */
    useStringArrays: boolean;
    /**
     * Include any dependencies.
     */
    deps: boolean;
    /**
     * limit mappings to connector
     */
    connectorId?: string;
    /**
     * limit mappings to managed object type
     */
    moType?: string;
}
/**
 * Mapping import options
 */
export interface MappingImportOptions {
    /**
     * Include any dependencies.
     */
    deps: boolean;
}
export declare function createMappingExportTemplate({ state, }: {
    state: State;
}): MappingExportInterface;
/**
 * Read mappings from sync.json (legacy)
 * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
 */
export declare function readSyncMappings({ state, }: {
    state: State;
}): Promise<MappingSkeleton[]>;
/**
 * Read the new mappings that are not legacy (i.e. those not from sync.json)
 * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
 */
export declare function readNewMappings({ state, }: {
    state: State;
}): Promise<MappingSkeleton[]>;
/**
 * Read mappings in order of which they are synced.
 * @param {string} connectorId limit mappings to connector
 * @param {string} moType limit mappings to managed object type
 * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
 */
export declare function readMappings({ connectorId, moType, state, }: {
    connectorId?: string;
    moType?: string;
    state: State;
}): Promise<MappingSkeleton[]>;
/**
 * Read mapping
 * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
 * @returns {Promise<MappingSkeleton>} a promise that resolves an mapping object
 */
export declare function readMapping({ mappingId, state, }: {
    mappingId: string;
    state: State;
}): Promise<MappingSkeleton>;
/**
 * Create mapping
 * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
 * @param {MappingSkeleton} mappingData mapping object
 * @returns {Promise<MappingSkeleton>} a promise that resolves to an mapping object
 */
export declare function createMapping({ mappingId, mappingData, state, }: {
    mappingId: string;
    mappingData: MappingSkeleton;
    state: State;
}): Promise<MappingSkeleton>;
/**
 * Update or create mapping
 * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
 * @param {MappingSkeleton} mappingData mapping object
 * @returns {Promise<MappingSkeleton>} a promise that resolves to an mapping object
 */
export declare function updateMapping({ mappingId, mappingData, state, }: {
    mappingId: string;
    mappingData: MappingSkeleton;
    state: State;
}): Promise<MappingSkeleton>;
/**
 * Update or create multiple mappings
 * @param {MappingSkeleton[]} mappings array of mapping objects
 * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
 */
export declare function updateLegacyMappings({ mappings, state, }: {
    mappings: MappingSkeleton[];
    state: State;
}): Promise<MappingSkeleton[]>;
/**
 * Delete mappings
 * @param {string} connectorId limit mappings to connector
 * @param {string} moType limit mappings to managed object type
 * @returns {Promise<MappingSkeleton[]>} a promise that resolves to an array of mapping objects
 */
export declare function deleteMappings({ connectorId, moType, state, }: {
    connectorId?: string;
    moType?: string;
    state: State;
}): Promise<MappingSkeleton[]>;
/**
 * Delete mapping
 * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
 * @returns {Promise<MappingSkeleton>} a promise that resolves an mapping object
 */
export declare function deleteMapping({ mappingId, state, }: {
    mappingId: string;
    state: State;
}): Promise<MappingSkeleton>;
/**
 * Export mapping
 * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
 * @param {MappingExportOptions} options export options
 * @returns {Promise<MappingExportInterface>} a promise that resolves to a MappingExportInterface object
 */
export declare function exportMapping({ mappingId, options, state, }: {
    mappingId: string;
    options?: MappingExportOptions;
    state: State;
}): Promise<MappingExportInterface>;
/**
 * Export all mappings
 * @param {MappingExportOptions} options export options
 * @returns {Promise<MappingExportInterface>} a promise that resolves to a MappingExportInterface object
 */
export declare function exportMappings({ options, state, }: {
    options?: MappingExportOptions;
    state: State;
}): Promise<MappingExportInterface>;
/**
 * Import mapping
 * @param {string} mappingId id of the mapping (new: 'mapping/\<name>', legacy: 'sync/\<name>')
 * @param {MappingExportInterface} importData import data
 * @param {MappingImportOptions} options import options
 * @returns {Promise<MappingSkeleton>} a promise resolving to a MappingSkeleton object
 */
export declare function importMapping({ mappingId, importData, options, state, }: {
    mappingId: string;
    importData: MappingExportInterface;
    options?: MappingImportOptions;
    state: State;
}): Promise<MappingSkeleton>;
/**
 * Import first mapping
 * @param {MappingExportInterface} importData import data
 * @param {MappingImportOptions} options import options
 * @returns {Promise<MappingSkeleton>} a promise resolving to a MappingSkeleton object
 */
export declare function importFirstMapping({ importData, options, state, }: {
    importData: MappingExportInterface;
    options?: MappingImportOptions;
    state: State;
}): Promise<MappingSkeleton>;
/**
 * Import all mappings
 * @param {MappingExportInterface} importData import data
 * @param {MappingImportOptions} options import options
 * @returns {Promise<MappingSkeleton[]>} a promise resolving to an array of MappingSkeleton objects
 */
export declare function importMappings({ importData, options, state, }: {
    importData: MappingExportInterface;
    options?: MappingImportOptions;
    state: State;
}): Promise<MappingSkeleton[]>;
/**
 * Helper that returns a boolean indicating whether the mapping is a legacy mapping or not given the id
 * @param {string} mappingId the mapping id
 * @returns {boolean} true if the mapping is a legacy mapping, false otherwise
 * @throws {FrodoError} if the id is invalid
 */
export declare function isLegacyMapping(mappingId: string): boolean;
/**
 * Helper that sorts an array of mappings in place and returns the sorted array. It sorts first by mapping type (legacy mappings come before non-legacy mappings), and then by the syncAfter property.
 * If syncAfter doesn't exist, it prioritizes mappings without the syncAfter property (note that the behavior that should happen in this instance is not specified in the documentation, at least as of July 9, 2024).
 *
 * See sync order documentation: https://backstage.forgerock.com/docs/idm/7.5/synchronization-guide/mappings.html
 *
 * Note: According to the documentation, then endpoint /openidm/sync/mappings?_queryFilter=true should return all mappings (legacy and new) in the correct order, which would make this method unnecessary when reading mappings. However, this doesn't
 * seem to always be the case. The endpoint prioritizes non-legacy mappings over legacy mappings which is opposite what the documentation says the correct sync order should be. Additionally, the endpoint does not always return all the mappings.
 * In the future, if the endpoint is fixed, we may instead want to use /openidm/sync/mappings?_queryFilter=true to determine correct ordering.
 *
 * @param {MappingSkeleton[]} mappings The list of mappings to sort in place
 * @returns The sorted list of mappings
 */
export declare function sortMappings(mappings: MappingSkeleton[]): MappingSkeleton[];
//# sourceMappingURL=MappingOps.d.ts.map