import type { PaginationParams } from '../../../providers/database/pagination/schemas.js';
import type { EntityReadModelSchema, EntityRelationReadModelSchema } from '../schemas/read-model-schemas.js';
import type { CatalogFiltersParams } from './repositories/local/catalog-entities-local-read-repository.js';
import type { BffCatalogEntity, BffCatalogEntityList, BffCatalogRelatedEntityList } from '@redocly/theme/core/types';
import type { ServiceInstanceOptions } from '../../../providers/database/types.js';
import type { TransactionsManager } from '../../../providers/database/transactions-manager.js';
import type { CreateEntityParams } from './repositories/local/catalog-entities-local-write-repository.js';
import type { Filter } from '../../../providers/database/pagination/types.js';
import type { ScorecardsStatus } from '../entities/types.js';
import type { GetEntityByIdParams } from '../types/params.js';
import { type EntityDtoSchema, type EntityRelationDtoSchema } from '../schemas/dto-schemas.js';
import { CatalogEntitiesLocalRepository } from './repositories/local/catalog-entities-local-repository.js';
import { CatalogEntitiesRemoteRepository } from './repositories/remote/catalog-entities-remote-repository.js';
import { type ListResponseResult } from '../../../web-server/utils/prepare-list-response.js';
type BulkSyncResult<T> = Array<{
    status: 'ok';
    resource: T | null;
} | {
    key: string;
    status: 'error';
    error: string;
}>;
export declare class CatalogEntitiesService {
    #private;
    constructor(localRepository: CatalogEntitiesLocalRepository, remoteRepository: CatalogEntitiesRemoteRepository | null);
    static getInstance(options: ServiceInstanceOptions): Promise<CatalogEntitiesService>;
    transaction<T>(...args: Parameters<TransactionsManager['transaction']>): Promise<T>;
    remoteTransaction<T>(operation: () => Promise<T>): Promise<T>;
    getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
        paginationParams: PaginationParams;
        rbacTeams?: string[];
        excludedTypes?: string[];
        excludedEntities?: string[];
    }): Promise<ListResponseResult<EntityReadModelSchema>>;
    getEntityById(id: string, params?: GetEntityByIdParams): Promise<EntityReadModelSchema | null>;
    getEntityKeysAndVersionsBySourceFile(sourceFile: string): Promise<Set<string>>;
    getEntitiesCountByTypes(): Promise<{
        type: string;
        count: number;
    }[]>;
    getCatalogFilters(params: CatalogFiltersParams): Promise<Record<string, import("./repositories/local/catalog-entities-local-read-repository.js").FilterOption[]>>;
    createEntity(entity: EntityDtoSchema): Promise<EntityReadModelSchema | null>;
    createEntities(entities: EntityDtoSchema[]): Promise<BulkSyncResult<EntityReadModelSchema>>;
    getEntitySources(): Record<string, import("@redocly/theme").SidebarConnectedEntity>;
    /**
     * Use only internally, everything that is created via API should be created in the remote database.
     * @param entity - The entity to create.
     */
    createEntityInLocalDatabase(createEntityParams: CreateEntityParams): Promise<import("./repositories/local/catalog-entities-local-write-repository.js").CreateEntityResult>;
    /**
     * Use only internally, everything that is created via API should be created in the remote database.
     * @param entities - The entities to create.
     */
    createEntitiesInLocalDatabase(createEntitiesParams: CreateEntityParams[]): Promise<void>;
    /**
     * Use only internally, everything that is created via API should be created in the remote database.
     * @param relation - The entity to create.
     */
    createEntityRelationInLocalDatabase(relation: EntityRelationDtoSchema): Promise<void>;
    /**
     * Use only internally, everything that is created via API should be created in the remote database.
     * @param relations - The entity to create.
     */
    createEntityRelationsInLocalDatabase(relations: EntityRelationDtoSchema[]): Promise<void>;
    updateEntity(incomingEntity: Partial<EntityDtoSchema>, entityToBeUpdated: EntityReadModelSchema): Promise<EntityReadModelSchema | null | undefined>;
    deleteEntity(entityToBeRemoved: EntityReadModelSchema): Promise<string | null | undefined>;
    /**
     * Use only internally, everything that is created via API should be created in the remote database.
     * @param filter - The conditions used to select which entities to delete.
     */
    deleteEntitiesInLocalDatabase(filter: Filter): Promise<void>;
    getEntityRelationById(id: string): Promise<EntityRelationReadModelSchema | null>;
    getEntitiesRelations(paginationParams?: PaginationParams): Promise<ListResponseResult<EntityRelationReadModelSchema>>;
    createEntityRelation(relation: EntityRelationDtoSchema): Promise<EntityRelationReadModelSchema | null | undefined>;
    createEntitiesRelations(entities: EntityRelationDtoSchema[]): Promise<BulkSyncResult<EntityRelationReadModelSchema>>;
    updateEntityRelation(incomingRelationData: Partial<EntityRelationDtoSchema>, relationToBeUpdated: EntityRelationReadModelSchema): Promise<EntityRelationReadModelSchema | null | undefined>;
    deleteEntityRelation(id: string): Promise<string | null>;
    /**
     * Use only internally, everything that is created via API should be created in the remote database.
     * @param filter - The conditions used to select which entity relations to delete.
     */
    deleteEntityRelationsInLocalDatabase(filter: Filter): Promise<void>;
    getEntitiesWithRelations({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
        paginationParams: PaginationParams;
        rbacTeams?: string[];
        excludedTypes?: string[];
        excludedEntities?: string[];
    }): Promise<BffCatalogEntityList>;
    getEntityWithRelationsByKey({ entityKey, filter, rbacTeams, excludedTypes, excludedEntities, }: {
        entityKey: string;
        filter?: {
            revision?: string | null;
            version?: string | null;
        };
        rbacTeams?: string[];
        excludedTypes?: string[];
        excludedEntities?: string[];
    }): Promise<BffCatalogEntity | null>;
    getRelatedEntities({ entityKey, paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
        entityKey: string;
        paginationParams: PaginationParams;
        rbacTeams?: string[];
        excludedTypes?: string[];
        excludedEntities?: string[];
    }): Promise<BffCatalogRelatedEntityList>;
    softDeleteEntitiesInLocalDatabase({ filter, revision, fileHash, }: {
        filter: Filter;
        revision: string;
        fileHash: string;
    }): Promise<void>;
    listEntityRevisions(entityKey: string, version?: string | null): Promise<import("../schemas/read-model-schemas.js").EntityRevisionSummary[]>;
    updateEntityScorecardsStatus(entityId: string, status: ScorecardsStatus): Promise<boolean>;
    updateEntityScorecardsStatusIfCalculating(entityId: string, status: Extract<ScorecardsStatus, 'UP_TO_DATE' | 'OUTDATED'>): Promise<boolean>;
    getOutdatedEntities(filter?: Filter): Promise<EntityReadModelSchema[]>;
    setEntitiesAsOutdated(filter: Filter): Promise<void>;
    getEntitiesCount(source: 'file' | 'remote', addedEntities?: EntityReadModelSchema[], entitiesRemovedCount?: number): Promise<{
        total: number;
    }>;
    getDuplicatedEntitiesCount(addedEntities?: EntityReadModelSchema[], removedEntities?: EntityReadModelSchema[]): Promise<{
        total: number;
    }>;
}
export {};
//# sourceMappingURL=catalog-entities-service.d.ts.map