import { AutoBeRealizeCollectorReference } from "@autobe/interface";
import { IAutoBePreliminaryComplete } from "../../common/structures/IAutoBePreliminaryComplete";
import { IAutoBePreliminaryGetAnalysisSections } from "../../common/structures/IAutoBePreliminaryGetAnalysisSections";
import { IAutoBePreliminaryGetDatabaseSchemas } from "../../common/structures/IAutoBePreliminaryGetDatabaseSchemas";
import { IAutoBePreliminaryGetInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetInterfaceOperations";
import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
/**
 * Plans whether a single DTO needs a collector. Sets databaseSchemaName to null
 * for non-collectable DTOs.
 *
 * **Key Decisions**: Not all DTOs require collectors. Distinguish collectable
 * DTOs (Create DTO + DB-backed + direct mapping) from non-collectable DTOs
 * (read-only DTOs, computed types).
 */
export interface IAutoBeRealizeCollectorPlanApplication {
    /**
     * Analyzes the given DTO type and generates a plan entry determining whether
     * a collector is needed. Returns exactly ONE plan entry.
     *
     * @param props Preliminary data request, write submission, or completion
     *   confirmation
     */
    process(props: IAutoBeRealizeCollectorPlanApplication.IProps): void;
}
export declare namespace IAutoBeRealizeCollectorPlanApplication {
    interface IProps {
        /**
         * Think before you act.
         *
         * For preliminary requests: what schemas (database, DTO, operations) are
         * missing?
         *
         * For write: is this DTO collectable or non-collectable? What database
         * table does it map to (if collectable)?
         *
         * For complete: why you consider the decision final.
         */
        thinking: string;
        /**
         * Action to perform. Exhausted preliminary types are removed from the
         * union, physically preventing repeated calls.
         */
        request: IWrite | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetInterfaceOperations | IAutoBePreliminaryGetInterfaceSchemas | IAutoBePreliminaryComplete;
    }
    /**
     * Generates exactly ONE plan entry indicating collectable (has DB schema
     * name) or not (null).
     */
    interface IWrite {
        /** Type discriminator for write submission. */
        type: "write";
        /**
         * Exactly ONE entry. databaseSchemaName non-null = collectable, null = no
         * collector needed.
         */
        plans: IPlan[];
    }
    /** Planning decision for one DTO. */
    interface IPlan {
        /**
         * TypeScript interface type from the operation request body (e.g.,
         * "IShoppingSale.ICreate").
         */
        dtoTypeName: string;
        /**
         * Reasoning for this DTO's planning decision.
         *
         * Collectable: "Collects IShoppingSale.ICreate to shopping_sales with
         * nested category".
         *
         * Non-collectable: "IShoppingSale is read-only response DTO, not for
         * creation".
         */
        thinking: string;
        /**
         * Database table name if collectable (e.g., "shopping_sales"), null if
         * non-collectable (read-only DTO, computed type).
         */
        databaseSchemaName: string | null;
        /**
         * Referenced entities from path parameters or auth context.
         *
         * Each reference contains `databaseSchemaName` and `source` (e.g., "from
         * path parameter {id}", "from authorized actor"). Empty array means the
         * Create DTO contains all necessary references.
         */
        references: AutoBeRealizeCollectorReference[];
    }
}