import type { AppCatalogBootstrap, AppCatalogEntry, IdentityCatalogEntry, CatalogDescriptor, CatalogItemReference, CatalogItemValidationReport, CatalogGetItemResult, CatalogGetItemResultWithOutcome, CatalogGetItemByFieldResult, CatalogGetItemByFieldResultWithOutcome, CatalogListResult, CatalogListResultWithOutcome, CatalogNativeItemOptions, CatalogQueryOptions, MoveNativeCatalogItemScopeInput, CatalogValidationReport, CreateCatalogInput, UpsertCatalogDescriptorInput, ExportInventoryData, ExportInventoryInput, CatalogSnapshotExportInput, CataloxExportV1, InventoryReportData, InventoryReportInput, UpsertCatalogItemRelationInput, DeleteCatalogItemRelationInput, UpsertAppInput, ListCatalogBindingsInput, UpdateCatalogBindingInput, UpsertIdentityBindingInput, ListIdentityBindingsInput, CatalogManagementDetail, ItemId, StoreId, StoreAppBindingRecord, ListAppCatalogsInput, ListCatalogsForIdentityInput, UnifiedCatalogItem, UpdateCatalogInput, StoreCatalogBootstrap, ListAllCatalogsInput, FindCatalogsInput, CatalogSummary, SearchCatalogItemsInput, CatalogTypeScope, CatalogTypeRegistryRecord, DomainRegistryScope, DomainRegistryRecord, AgentRegistryScope, AgentRegistryRecord } from "@x12i/catalox-contracts/index.js";
import type { NativeCatalogItemRecord } from "@x12i/catalox-contracts/items.js";
import type { AppId, CatalogId } from "@x12i/catalox-contracts/ids.js";
import type { AppRecord } from "@x12i/catalox-contracts/apps.js";
import type { CatalogBindingRecord, IdentityCatalogBindingRecord } from "@x12i/catalox-contracts/bindings.js";
import type { CatalogRecord } from "@x12i/catalox-contracts/catalogs.js";
import type { PayloadSchemaRegistry } from "../validation/payload-schema-registry.js";
import { type ResolvedPayloadSchema } from "../validation/payload-schema.js";
import { ApiCatalogAdapter } from "../adapters/api/api-adapter.js";
import { MongoCatalogAdapter } from "../adapters/mongo/mongo-adapter.js";
import { AuthorizationService } from "./authorization.js";
import type { CataloxContext } from "@x12i/catalox-contracts/context.js";
import type { CatalogListRenderMap, CatalogItemRenderMap } from "@x12i/catalox-contracts/render-map.js";
import type { CatalogDesignObjectRecord, CatalogDesignScope } from "@x12i/catalox-contracts/design-objects.js";
import type { CatalogPresentationProfileRecord, ResolvedCatalogPresentationBinding } from "@x12i/catalox-contracts/presentation-binding.js";
import { type BackfillCatalogModelInput, type BackfillCatalogModelResult } from "../migrations/backfill-catalog-model.js";
import { AppStore } from "../firebase/app-store.js";
import { AdapterStore } from "../firebase/adapter-store.js";
import { BindingStore } from "../firebase/binding-store.js";
import { CatalogStore } from "../firebase/catalog-store.js";
import { CatalogDataIndexStore } from "../firebase/catalog-data-index-store.js";
import { CatalogTypeStore } from "../firebase/catalog-type-store.js";
import { DomainStore } from "../firebase/domain-store.js";
import { AgentStore } from "../firebase/agent-store.js";
import { DefinitionStore } from "../firebase/definition-store.js";
import { DescriptorStore } from "../firebase/descriptor-store.js";
import { FirestoreStore } from "../firebase/firestore-store.js";
import { MappingStore } from "../firebase/mapping-store.js";
import { NativeItemStore } from "../firebase/native-item-store.js";
import { ReferenceStore } from "../firebase/reference-store.js";
import { RendererSnippetStore } from "../firebase/renderer-snippet-store.js";
import { SnapshotStore } from "../firebase/snapshot-store.js";
import { StoreAppBindingStore } from "../firebase/store-app-binding-store.js";
import { IdentityBindingStore } from "../firebase/identity-binding-store.js";
import type { BackupDataInput, BackupDataResult } from "@x12i/catalox-contracts/backup.js";
import type { ExportAllFirestoreCollectionsToGcsInput, ExportAllFirestoreCollectionsToGcsResult, ExportFirestoreCollectionToGcsInput, ExportFirestoreCollectionToGcsResult, RestoreAllFirestoreCollectionsFromGcsInput, RestoreAllFirestoreCollectionsFromGcsResult, RestoreFirestoreCollectionFromGcsInput, RestoreFirestoreCollectionFromGcsResult } from "@x12i/catalox-contracts/gcs-firestore-transfer.js";
import type { CompareAllFirestoreCollectionsWithGcsManifestInput, CompareAllFirestoreCollectionsWithGcsResult, CompareFirestoreCollectionWithGcsInput, CompareFirestoreCollectionWithGcsResult } from "@x12i/catalox-contracts/gcs-firestore-compare.js";
import type { RestoreFirestoreBackupFromGcsInput, RestoreFirestoreBackupFromGcsResult, PruneGcsBackupRunsInput, PruneGcsBackupRunsResult, UndoFirestoreRestoreInput, UndoFirestoreRestoreResult } from "@x12i/catalox-contracts/restore.js";
import type { CataloxGcsBackupManifestV1, FirestoreGcsExportManifestV1 } from "@x12i/catalox-contracts/gcs-firestore-transfer.js";
import { runDeleteCataloxGcsBackupRun } from "./restore-firestore-backup-from-gcs.js";
import { type MigrateNativeCatalogLayoutInput, type MigrateNativeCatalogLayoutResult } from "../migrations/migrate-native-catalog-layout.js";
import { type MigrateNativeItemScopeInput, type MigrateNativeItemScopeResult } from "../migrations/migrate-native-item-scope.js";
import { type NativeCatalogLayoutDiagnosticRow } from "./native-catalog-layout-diagnostics.js";
import { CataloxBound } from "./catalox-bound.js";
import { type RecordHistoryDeps } from "./record-history.js";
import type { CatalogItemHistoryEventV1, CatalogItemHistoryIndexRecord, ListCatalogItemHistoryInput, ListCatalogItemHistoryResult, ListCatalogItemFieldHistoryInput, ListCatalogItemFieldHistoryResult, RestoreCatalogItemFromHistoryInput, RestoreCatalogItemFieldFromHistoryInput, ReplayCatalogToPointInTimeInput } from "@x12i/catalox-contracts/record-history.js";
import type { DeleteCatalogInput, DeleteCatalogResult, RenameCatalogInput, RenameCatalogResult, RestoreDeletedCatalogInput, RestoreDeletedCatalogResult } from "@x12i/catalox-contracts/catalog-lifecycle.js";
export type CataloxDependencies = {
    apps: AppStore;
    catalogs: CatalogStore;
    catalogTypes?: CatalogTypeStore;
    domains?: DomainStore;
    agents?: AgentStore;
    bindings: BindingStore;
    storeAppBindings?: StoreAppBindingStore;
    identityBindings?: IdentityBindingStore;
    definitions: DefinitionStore;
    mappings: MappingStore;
    descriptors: DescriptorStore;
    rendererSnippets?: RendererSnippetStore;
    /** Optional store for presentation profile records (catalogId/catalogType scoped). */
    presentationProfiles?: import("../firebase/presentation-profile-store.js").PresentationProfileStore;
    /** Optional store for scoped design objects (store/app/account/agent). */
    designObjects?: import("../firebase/design-object-store.js").DesignObjectStore;
    references: ReferenceStore;
    nativeItems: NativeItemStore;
    snapshots: SnapshotStore;
    adapters: AdapterStore;
    /**
     * Legacy Firestore handle for retired operator tooling (backup/GCS transfer/migrations).
     * Mongo-primary mode injects {@link UnavailableFirestoreStore}; prefer {@link mongoStore}.
     */
    firestoreStore: FirestoreStore;
    /** Primary Mongo persistence (set in Mongo mode). */
    mongoStore?: import("../mongo/mongo-store.js").MongoStore;
    catalogDataIndex: CatalogDataIndexStore;
    authz: AuthorizationService;
    mongoAdapter?: MongoCatalogAdapter;
    apiAdapter?: ApiCatalogAdapter;
    /** When set, native writes emit per-record history to GCS + `catalogItemHistory`. */
    recordHistory?: RecordHistoryDeps;
    /** Versioned native `item.data` JSON Schemas (defaults to bundled `schemas/`). */
    payloadSchemas?: PayloadSchemaRegistry;
    /** Native row source tag on reads (default mongo). */
    nativeSourceType?: UnifiedCatalogItem["sourceType"];
};
export declare class Catalox {
    private readonly deps;
    private readonly payloadSchemaRegistry;
    constructor(deps: CataloxDependencies);
    private getPayloadSchemaRegistry;
    private nativeItemSourceType;
    private resolveCatalogTypeRegistry;
    resolvePayloadSchemaForCatalog(catalog: CatalogRecord, catalogTypeRegistry?: CatalogTypeRegistryRecord | null): ResolvedPayloadSchema | null;
    validateNativeItemData(data: unknown, catalog: CatalogRecord, catalogTypeRegistry?: CatalogTypeRegistryRecord | null): CatalogItemValidationReport;
    private assertNativeItemPayloadValid;
    private encodeRefSegment;
    private buildReferenceId;
    private normalizeRelationWrites;
    private validateRelationsAgainstDescriptor;
    private validateCatalogTypeForContext;
    private catalogLifecycleDeps;
    private emitNativeItemHistory;
    private resolveActorId;
    private stableStringify;
    private fingerprint;
    private resolveEffectiveAppIds;
    private resolveAppIdForCatalogAccess;
    private readPath;
    private gatherDescriptorSources;
    private resolveFieldSourceOptions;
    buildCatalogListRenderMap(context: CataloxContext, catalogId: CatalogId, options?: {
        limit?: number;
        resolveSources?: boolean;
        maxSourceOptions?: number;
        displayContext?: "grid" | "list" | "cards";
    }): Promise<CatalogListRenderMap>;
    getDesignObject(context: CataloxContext, designId: string): Promise<CatalogDesignObjectRecord | null>;
    listDesignObjects(context: CataloxContext, scope: CatalogDesignScope): Promise<CatalogDesignObjectRecord[]>;
    getCatalogPresentationBinding(context: CataloxContext, catalogId: CatalogId, role: Exclude<import("@x12i/catalox-contracts/renderer-snippets.js").CatalogRendererRole, "core">, options?: {
        mode?: import("@x12i/catalox-contracts/renderer-snippets.js").CatalogRendererMode;
        displayContext?: "grid" | "list" | "cards" | "form";
        /**
         * If provided, these profiles are used instead of querying a backing store.
         */
        profiles?: CatalogPresentationProfileRecord[];
        /**
         * If true, attempts to fetch a snippet record when the resolved customRenderer uses snippetRef.
         */
        includeSnippet?: boolean;
        /**
         * Optional design object inputs. If omitted and includeDesignObjects=true, a backing store is required.
         */
        designObjects?: CatalogDesignObjectRecord[];
        /**
         * If true, include merged design payload when designs are available.
         */
        includeDesignObjects?: boolean;
        designScope?: CatalogDesignScope;
    }): Promise<ResolvedCatalogPresentationBinding>;
    buildCatalogListPresentationSurface(context: CataloxContext, catalogId: CatalogId, options?: {
        limit?: number;
        resolveSources?: boolean;
        maxSourceOptions?: number;
        displayContext?: "grid" | "list" | "cards";
        mode?: import("@x12i/catalox-contracts/renderer-snippets.js").CatalogRendererMode;
        includeSnippet?: boolean;
        includeDesignObjects?: boolean;
        designScope?: CatalogDesignScope;
        profiles?: CatalogPresentationProfileRecord[];
        designObjects?: CatalogDesignObjectRecord[];
    }): Promise<{
        map: CatalogListRenderMap;
        binding: ResolvedCatalogPresentationBinding;
    }>;
    buildCatalogItemPresentationSurface(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: {
        includeReferences?: boolean;
        resolveSources?: boolean;
        maxSourceOptions?: number;
        displayContext?: "form" | "card" | "grid-row" | "list-row";
        mode?: import("@x12i/catalox-contracts/renderer-snippets.js").CatalogRendererMode;
        includeSnippet?: boolean;
        includeDesignObjects?: boolean;
        designScope?: CatalogDesignScope;
        profiles?: CatalogPresentationProfileRecord[];
        designObjects?: CatalogDesignObjectRecord[];
    }): Promise<{
        map: CatalogItemRenderMap;
        binding: ResolvedCatalogPresentationBinding;
    }>;
    buildCatalogItemRenderMap(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: {
        includeReferences?: boolean;
        resolveSources?: boolean;
        maxSourceOptions?: number;
        displayContext?: "form" | "card" | "grid-row" | "list-row";
    }): Promise<CatalogItemRenderMap>;
    private deriveIndexed;
    private withAuditIndexed;
    private filterSoftDeletedRows;
    private smartPropertyDeps;
    private assertNativeCatalogRecordEnvelope;
    private buildReplaceNativeRecord;
    private stripReservedWriteFields;
    private filterNativeCatalogRows;
    private decorateItem;
    listAppCatalogs(context: CataloxContext, input?: ListAppCatalogsInput): Promise<AppCatalogEntry[]>;
    private identityBindingMatches;
    /**
     * vNext: identity-first discovery, backed by `catalogIdentityBindings`.
     * This does not replace app bindings; host policy may intersect/union them.
     */
    listCatalogsForIdentity(context: CataloxContext, input: ListCatalogsForIdentityInput): Promise<IdentityCatalogEntry[]>;
    /**
     * App-agnostic discovery: list catalog metadata across all apps.
     * Visibility default: hide hidden catalogs unless `context.superAdmin`.
     */
    listAllCatalogs(context: CataloxContext, input?: ListAllCatalogsInput): Promise<CatalogSummary[]>;
    findCatalogs(context: CataloxContext, input: FindCatalogsInput): Promise<CatalogSummary[]>;
    getCatalogDescriptor(context: CataloxContext, catalogId: CatalogId): Promise<CatalogDescriptor | null>;
    /**
     * Writes or replaces the global descriptor for `catalogId` (same document as {@link DescriptorStore}).
     * Requires {@link CataloxContext.superAdmin} because descriptors affect identity and behavior for all apps bound to the catalog.
     */
    upsertCatalogDescriptor(context: CataloxContext, catalogId: CatalogId, input: UpsertCatalogDescriptorInput): Promise<void>;
    getCatalogRendererSnippet(context: CataloxContext, catalogId: CatalogId, role: "core" | "list" | "grid" | "item" | "report" | "dashboard", mode?: "readonly" | "editable"): Promise<import("@x12i/catalox-contracts/renderer-snippets.js").CatalogRendererSnippetRecord | null>;
    getAppCatalogBootstrap(context: CataloxContext, appId?: AppId): Promise<AppCatalogBootstrap>;
    /** vNext: store-first bootstrap (store -> apps -> catalog descriptors). */
    getStoreCatalogBootstrap(context: CataloxContext, storeId: StoreId): Promise<StoreCatalogBootstrap>;
    listCatalogItems(context: CataloxContext, catalogId: CatalogId, options?: CatalogQueryOptions): Promise<CatalogListResult>;
    /**
     * vNext: same as `listCatalogItems` but returns a semantic outcome wrapper instead of throwing for common cases.
     * This is intended for embedders/BFFs that need to distinguish empty vs denied vs misconfigured.
     */
    listCatalogItemsWithOutcome(context: CataloxContext, catalogId: CatalogId, options?: CatalogQueryOptions): Promise<CatalogListResultWithOutcome>;
    getCatalogItem(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: CatalogNativeItemOptions): Promise<CatalogGetItemResult>;
    /**
     * Authenticated native read returning the stored {@link NativeCatalogItemRecord} envelope
     * (not the unified list/get projection). Resolves by logical `itemId`.
     */
    getNativeCatalogItem(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: CatalogNativeItemOptions): Promise<NativeCatalogItemRecord | null>;
    /** vNext: `getCatalogItem` wrapper with `CataloxOutcome` semantics. */
    getCatalogItemWithOutcome(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: CatalogNativeItemOptions): Promise<CatalogGetItemResultWithOutcome>;
    /**
     * Resolve a catalog item by an indexed logical field (e.g. `data.code` → descriptor key `code`).
     * Requires the field to be declared with `indexed: true` on the catalog descriptor.
     */
    getCatalogItemByField(context: CataloxContext, catalogId: CatalogId, fieldPath: string, value: unknown, options?: CatalogNativeItemOptions): Promise<CatalogGetItemByFieldResult>;
    /** vNext: `getCatalogItemByField` wrapper with `CataloxOutcome` semantics. */
    getCatalogItemByFieldWithOutcome(context: CataloxContext, catalogId: CatalogId, fieldPath: string, value: unknown, options?: CatalogNativeItemOptions): Promise<CatalogGetItemByFieldResultWithOutcome>;
    validateCatalog(context: CataloxContext, catalogId: CatalogId): Promise<CatalogValidationReport>;
    validateCatalogItem(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: {
        noAutoCreate?: boolean;
    }): Promise<CatalogItemValidationReport>;
    getCatalogItemReferences(context: CataloxContext, catalogId: CatalogId, itemId: ItemId): Promise<CatalogItemReference[]>;
    listCatalogReferences(context: CataloxContext, catalogId: CatalogId): Promise<CatalogItemReference[]>;
    upsertCatalogItemRelation(context: CataloxContext, input: UpsertCatalogItemRelationInput): Promise<{
        referenceId: string;
    }>;
    deleteCatalogItemRelation(context: CataloxContext, input: DeleteCatalogItemRelationInput): Promise<void>;
    listCatalogItemRelationsToItem(context: CataloxContext, catalogId: CatalogId, itemId: ItemId): Promise<CatalogItemReference[]>;
    getApp(_context: CataloxContext, appId?: AppId): Promise<AppRecord | null>;
    listApps(_context: CataloxContext): Promise<AppRecord[]>;
    upsertApp(context: CataloxContext, appId: AppId, input: UpsertAppInput): Promise<AppRecord>;
    listCatalogBindings(_context: CataloxContext, input?: ListCatalogBindingsInput): Promise<CatalogBindingRecord[]>;
    updateCatalogBinding(context: CataloxContext, input: UpdateCatalogBindingInput): Promise<CatalogBindingRecord>;
    getCatalogManagementDetail(_context: CataloxContext, catalogId: CatalogId): Promise<CatalogManagementDetail | null>;
    listIdentityBindings(_context: CataloxContext, input?: ListIdentityBindingsInput): Promise<IdentityCatalogBindingRecord[]>;
    upsertIdentityBinding(context: CataloxContext, input: UpsertIdentityBindingInput): Promise<IdentityCatalogBindingRecord>;
    deleteIdentityBinding(context: CataloxContext, bindingId: string): Promise<void>;
    createCatalog(_context: CataloxContext, _input: CreateCatalogInput): Promise<CatalogRecord>;
    updateCatalog(_context: CataloxContext, _catalogId: CatalogId, _patch: UpdateCatalogInput): Promise<CatalogRecord>;
    getCatalog(_context: CataloxContext, catalogId: CatalogId): Promise<CatalogRecord | null>;
    listCatalogs(_context: CataloxContext, _options?: CatalogQueryOptions): Promise<CatalogRecord[]>;
    searchCatalogItems(context: CataloxContext, catalogId: CatalogId, input: SearchCatalogItemsInput): Promise<CatalogListResult>;
    bindCatalogToApp(_context: CataloxContext, _input: import("@x12i/catalox-contracts/bindings.js").BindCatalogInput): Promise<any>;
    unbindCatalogFromApp(_context: CataloxContext, _appId: AppId, _catalogId: CatalogId): Promise<void>;
    bindAppToStore(context: CataloxContext, input: {
        storeId: StoreId;
        appId: AppId;
        metadata?: Record<string, unknown>;
    }): Promise<StoreAppBindingRecord>;
    unbindAppFromStore(context: CataloxContext, storeId: StoreId, appId: AppId): Promise<void>;
    listAppsForStore(context: CataloxContext, storeId: StoreId): Promise<StoreAppBindingRecord[]>;
    ensureCatalog(context: CataloxContext, catalog: {
        catalogId: CatalogId;
        name: string;
        status?: "active" | "disabled" | "draft";
    }): Promise<void>;
    resolveAllowedCatalogTypes(context: CataloxContext): Promise<CatalogTypeRegistryRecord | null>;
    upsertCatalogTypeRegistry(context: CataloxContext, scope: CatalogTypeScope, input: {
        types: string[];
        metadata?: Record<string, unknown>;
    }): Promise<void>;
    resolveAllowedDomains(context: CataloxContext): Promise<DomainRegistryRecord | null>;
    upsertDomainRegistry(context: CataloxContext, scope: DomainRegistryScope, input: {
        domains: string[];
        metadata?: Record<string, unknown>;
    }): Promise<void>;
    resolveAllowedAgents(context: CataloxContext): Promise<AgentRegistryRecord | null>;
    upsertAgentRegistry(context: CataloxContext, scope: AgentRegistryScope, input: {
        agents: string[];
        metadata?: Record<string, unknown>;
    }): Promise<void>;
    backfillCatalogModel(context: CataloxContext, input?: BackfillCatalogModelInput): Promise<BackfillCatalogModelResult>;
    ensureBinding(context: CataloxContext, input: {
        appId: AppId;
        catalogId: CatalogId;
        access?: {
            canRead?: boolean;
            canWrite?: boolean;
            canAdmin?: boolean;
        };
    }): Promise<void>;
    createNativeCatalogItem(_context: CataloxContext, _catalogId: CatalogId, _input: Record<string, unknown>): Promise<UnifiedCatalogItem>;
    updateNativeCatalogItem(_context: CataloxContext, _catalogId: CatalogId, _itemId: ItemId, _patch: Record<string, unknown>, _options?: CatalogNativeItemOptions): Promise<UnifiedCatalogItem>;
    deleteNativeCatalogItem(_context: CataloxContext, _catalogId: CatalogId, _itemId: ItemId, _options?: CatalogNativeItemOptions): Promise<void>;
    restoreNativeCatalogItem(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, options?: CatalogNativeItemOptions): Promise<UnifiedCatalogItem>;
    moveNativeCatalogItemScope(context: CataloxContext, catalogId: CatalogId, itemId: ItemId, input: MoveNativeCatalogItemScopeInput): Promise<void>;
    upsertNativeCatalogItem(context: CataloxContext, catalogId: CatalogId, input: Record<string, unknown>): Promise<UnifiedCatalogItem>;
    batchUpsertNativeCatalogItems(context: CataloxContext, catalogId: CatalogId, items: Array<Record<string, unknown>>): Promise<void>;
    /**
     * Full-document native replace (no field-level merge). Omitted keys in `data`, `indexed`, and
     * `metadata` are removed from the stored document. Use {@link upsertNativeCatalogItem} for
     * merge/patch persistence.
     */
    replaceNativeCatalogItem(context: CataloxContext, catalogId: CatalogId, record: NativeCatalogItemRecord): Promise<void>;
    /**
     * Batch variant of {@link replaceNativeCatalogItem}. When `options.atomic` is true, all rows
     * are validated before any write; each Firestore batch chunk (≤450 rows) commits atomically.
     */
    replaceNativeCatalogItems(context: CataloxContext, catalogId: CatalogId, records: NativeCatalogItemRecord[], options?: {
        atomic?: boolean;
    }): Promise<void>;
    importCatalogItemsFromJson<T = unknown>(json: string): T;
    exportCatalogItemsToJson(value: unknown, pretty?: boolean): string;
    exportInventory(context: CataloxContext, input?: ExportInventoryInput): Promise<ExportInventoryData>;
    exportInventoryToJson(context: CataloxContext, input?: ExportInventoryInput, pretty?: boolean): Promise<string>;
    /**
     * Versioned full-catalog snapshot (`catalox-export/v1`) for backup and drift detection.
     * Paginates all items per catalog; catalogs and items are sorted deterministically.
     */
    exportCatalogSnapshot(context: CataloxContext, input?: CatalogSnapshotExportInput): Promise<CataloxExportV1>;
    exportCatalogSnapshotToJson(context: CataloxContext, input?: CatalogSnapshotExportInput, pretty?: boolean): Promise<string>;
    generateInventoryReport(context: CataloxContext, input?: InventoryReportInput): Promise<{
        markdown: string;
        data: InventoryReportData;
    }>;
    syncMappedCatalog(_context: CataloxContext, _catalogId: CatalogId): Promise<{
        syncStatus: "idle";
        lastSyncedAt?: never;
    } | {
        syncStatus: "success";
        lastSyncedAt: string;
    }>;
    backupData(_context: CataloxContext, input: BackupDataInput): Promise<BackupDataResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    undoFirestoreRestore(_context: CataloxContext, _input: UndoFirestoreRestoreInput): Promise<UndoFirestoreRestoreResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    restoreFirestoreBackupFromGcs(_context: CataloxContext, _input: RestoreFirestoreBackupFromGcsInput): Promise<RestoreFirestoreBackupFromGcsResult>;
    /** Delete oldest GCS Catalox backup run folders (GCS-only; does not require Firestore). */
    pruneGcsBackupRuns(_context: CataloxContext, input: PruneGcsBackupRunsInput): Promise<PruneGcsBackupRunsResult>;
    /** Delete every object under one GCS backup run folder (operator cleanup). */
    deleteCataloxGcsBackupRun(_context: CataloxContext, input: {
        gcsBucket: string;
        gcsRunFolder: string;
    }): Promise<Awaited<ReturnType<typeof runDeleteCataloxGcsBackupRun>>>;
    /**
     * Map a catalox-backup-manifest.json payload into the export-manifest shape.
     * @deprecated Firestore migration helper.
     */
    cataloxGcsBackupManifestToExportManifest(manifest: CataloxGcsBackupManifestV1, gcsRunFolder: string): FirestoreGcsExportManifestV1;
    /** @deprecated Alias — prefer cataloxGcsBackupManifestToExportManifest. */
    cataloxGcsBackupManifestToFirestoreExportManifest(manifest: CataloxGcsBackupManifestV1, gcsRunFolder: string): FirestoreGcsExportManifestV1;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    reportNativeCatalogLayoutDiagnostics(_context: CataloxContext, _input?: {
        catalogIds?: CatalogId[];
    }): Promise<NativeCatalogLayoutDiagnosticRow[]>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    migrateNativeCatalogLayout(_context: CataloxContext, _input: MigrateNativeCatalogLayoutInput): Promise<MigrateNativeCatalogLayoutResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    migrateNativeItemScope(_context: CataloxContext, _input: MigrateNativeItemScopeInput): Promise<MigrateNativeItemScopeResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    exportFirestoreCollectionToGcs(_context: CataloxContext, _input: Omit<ExportFirestoreCollectionToGcsInput, "firestore">): Promise<ExportFirestoreCollectionToGcsResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    exportAllFirestoreCollectionsToGcs(_context: CataloxContext, _input: Omit<ExportAllFirestoreCollectionsToGcsInput, "firestore">): Promise<ExportAllFirestoreCollectionsToGcsResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    restoreFirestoreCollectionFromGcs(_context: CataloxContext, _input: Omit<RestoreFirestoreCollectionFromGcsInput, "firestore">): Promise<RestoreFirestoreCollectionFromGcsResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    restoreAllFirestoreCollectionsFromGcsManifest(_context: CataloxContext, _input: Omit<RestoreAllFirestoreCollectionsFromGcsInput, "firestore">): Promise<RestoreAllFirestoreCollectionsFromGcsResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    compareFirestoreCollectionWithGcsNdjson(_context: CataloxContext, _input: Omit<CompareFirestoreCollectionWithGcsInput, "firestore">): Promise<CompareFirestoreCollectionWithGcsResult>;
    /** @deprecated Firestore-only — throws on Mongo-primary Catalox. */
    compareAllFirestoreCollectionsWithGcsManifest(_context: CataloxContext, _input: Omit<CompareAllFirestoreCollectionsWithGcsManifestInput, "firestore">): Promise<CompareAllFirestoreCollectionsWithGcsResult>;
    listCatalogItemHistory(context: CataloxContext, catalogId: CatalogId, input?: ListCatalogItemHistoryInput): Promise<ListCatalogItemHistoryResult>;
    getCatalogItemHistoryEvent(context: CataloxContext, eventId: string): Promise<{
        index: CatalogItemHistoryIndexRecord;
        payload: CatalogItemHistoryEventV1;
    } | null>;
    restoreCatalogItemFromHistory(context: CataloxContext, eventId: string, input: RestoreCatalogItemFromHistoryInput): Promise<UnifiedCatalogItem>;
    /**
     * List changes to one field on a native item by diffing row-level history snapshots.
     * Bare field names (e.g. `instructions`) resolve under `item.data`.
     */
    listCatalogItemFieldHistory(context: CataloxContext, catalogId: CatalogId, input: ListCatalogItemFieldHistoryInput): Promise<ListCatalogItemFieldHistoryResult>;
    /**
     * Restore one field on a live native item from a history event (`before` or `after` snapshot).
     * Supports `data.*` and `indexed.*` paths; other roots require full-row restore.
     */
    restoreCatalogItemFieldFromHistory(context: CataloxContext, eventId: string, input: RestoreCatalogItemFieldFromHistoryInput): Promise<UnifiedCatalogItem>;
    replayCatalogToPointInTime(context: CataloxContext, catalogId: CatalogId, input: ReplayCatalogToPointInTimeInput): Promise<{
        upserted: number;
        deleted: number;
    }>;
    deleteCatalog(context: CataloxContext, catalogId: CatalogId, input: DeleteCatalogInput): Promise<DeleteCatalogResult>;
    restoreDeletedCatalog(context: CataloxContext, input: RestoreDeletedCatalogInput): Promise<RestoreDeletedCatalogResult>;
    renameCatalog(context: CataloxContext, fromCatalogId: CatalogId, toCatalogId: CatalogId, input?: RenameCatalogInput): Promise<RenameCatalogResult>;
    /**
     * Fix {@link CataloxContext} for subsequent calls so embedders omit it on each method (no globals).
     */
    withContext(context: CataloxContext): CataloxBound;
}
//# sourceMappingURL=catalox.d.ts.map