import { ExtendProcedureContextFunction, Procedure } from '../models/procedure.model';
import { AppSchema, DataSource, Stage, Page, PartialTablePageConfig, PartialDashboardPageConfig, IdentityProviderUserWithRoles, MainJsonSchema } from '@kottster/common';
import { DataSourceRegistry } from './dataSourceRegistry';
import { Request, Response, NextFunction } from 'express';
import { IdentityProvider, PostAuthMiddleware } from './identityProvider';
import { Exporter } from '../services/exporter.service';
import type { Express } from 'express';
import { ExternalIdentityProvider } from './externalIdentityProvider';
type RequestHandler = (req: Request, res: Response, next: NextFunction) => void;
export interface KottsterAppOptions {
    /**
     * The secret key used to sign JWT tokens
     */
    secretKey?: string;
    /**
     * The Kottster API token for the appen.
     * If not provided, some features that require server-side requests to Kottster API will not work (e.g. sql query generation, AI features, etc.)
     */
    kottsterApiToken?: string;
    /**
     * The identity provider configuration
     */
    identityProvider?: IdentityProvider | ExternalIdentityProvider;
    /**
     * Custom validation middleware.
     * This middleware will be called after the JWT token is validated. You can use it to perform additional checks or modify the request object.
     * @example https://kottster.app/docs/security/authentication#custom-validation-middleware
     */
    postAuthMiddleware?: PostAuthMiddleware;
    /**
     * Activates the Professional license features.
     */
    professional?: Function;
    /**
     * Enable read-only mode
     * @hidden
     */
    __readOnlyMode?: boolean;
    /**
     * Custom token validation function
     * @hidden
     */
    __ensureValidToken?: (request: Request) => Promise<EnsureValidTokenResponse>;
    /**
     * @deprecated Do not pass schema here anymore. The schema is now read from the kottster-app.json file automatically.
     * @hidden
     */
    schema?: MainJsonSchema | Record<string, never>;
    /**
     * Allows developers to customize the Express app instance.
     *
     * Useful for:
     *   • adding custom middleware
     *   • modifying server settings
     *   • enabling CORS, proxies, cookies
     *   • registering additional routes
     *
     * @param app The Express application instance
     */
    configureExpressApp?: (app: Express) => void;
}
interface EnsureValidTokenResponse {
    isTokenValid: boolean;
    user: IdentityProviderUserWithRoles | null;
    invalidTokenErrorMessage?: string;
}
/**
 * The main app class
 */
export declare class KottsterApp {
    readonly appId: string;
    private readonly secretKey;
    private readonly kottsterApiToken?;
    readonly usingTsc: boolean;
    readonly readOnlyMode: boolean;
    readonly stage: Stage;
    readonly basePath: string;
    private dataSources;
    license?: string;
    licenseActivationObj?: Record<string, any>;
    licenseData?: Record<string, any>;
    identityProvider?: IdentityProvider;
    externalIdentityProvider?: ExternalIdentityProvider;
    exporter: Exporter;
    schema: AppSchema;
    private customEnsureValidToken?;
    private postAuthMiddleware?;
    configureExpressApp?: (app: Express) => void;
    loadedPageConfigs: Page[];
    loadPageConfigs(): Page[];
    extendProcedureContext: ExtendProcedureContextFunction;
    getServerPackageVersion(): string;
    getSecretKey(): string;
    getKottsterApiToken(): string | undefined;
    constructor(options: KottsterAppOptions);
    initialize(): Promise<void>;
    /**
     * Load from a data source registry
     * @param registry The data source registry
     */
    loadFromDataSourceRegistry(registry: DataSourceRegistry<{}>): void;
    /**
     * Register a context middleware
     * @param fn The function to extend the context
     */
    registerContextMiddleware(fn: ExtendProcedureContextFunction): void;
    executeAction(action: string, data: any, user?: IdentityProviderUserWithRoles, req?: Request): Promise<any>;
    /**
     * Get the middleware for the app
     * @param req The request object
     * @returns The middleware function
     */
    getInternalApiRoute(): (req: Request, res: Response, next: NextFunction) => Promise<void>;
    getIdpRoute(): (req: Request, res: Response) => Promise<void>;
    getDownloadRoute(): (req: Request, res: Response) => Promise<void>;
    private handleInternalApiRequest;
    /**
     * Define a custom controller
     * @param procedures The procedures
     * @returns The express request handler
     */
    defineCustomController<T extends Record<string, Procedure>>(procedures: T): RequestHandler & {
        procedures: T;
    };
    /**
     * Define a dashboard controller
     * @param dashboardPageConfig The dashboard page config
     * @returns The express request handler
     */
    defineDashboardController(partialDashboardPageConfig: PartialDashboardPageConfig): RequestHandler;
    /**
     * Define a table controller
     * @param dataSource The data source
     * @param pageSettings The page settings
     * @returns The express request handler
     */
    defineTableController<T extends Record<string, Procedure>>(partialTablePageConfig: PartialTablePageConfig, procedures?: T): RequestHandler & {
        procedures: T;
    };
    private ensureValidToken;
    getDataSources(): DataSource<any>[];
    listen(): Promise<import("./server").KottsterServer>;
}
export {};