import { Table } from '@botpress/client';
import { SchemaTransformOptions } from '../common/types';
import { IntegrationPackage, PluginPackage } from '../package';
import { PluginInterfaceExtension, PluginIntegrationExtension } from '../plugin';
import { SchemaDefinition } from '../schema';
import { ValueOf, Merge, StringKeys } from '../utils/type-utils';
import { z } from '../zui';
type BaseConfig = z.ZuiObjectSchema;
type BaseStates = Record<string, z.ZuiObjectOrRefSchema>;
type BaseEvents = Record<string, z.ZuiObjectOrRefSchema>;
type BaseActions = Record<string, z.ZuiObjectOrRefSchema>;
type BaseTables = Record<string, z.ZuiObjectOrRefSchema>;
type BaseWorkflows = Record<string, z.ZuiObjectSchema>;
export type TagDefinition = {
    title?: string;
    description?: string;
};
export type StateType = 'conversation' | 'user' | 'bot' | 'workflow';
export type StateDefinition<TState extends BaseStates[string] = BaseStates[string]> = SchemaDefinition<TState> & {
    type: StateType;
    expiry?: number;
};
export type RecurringEventDefinition<TEvents extends BaseEvents = BaseEvents> = {
    [K in keyof TEvents]: {
        type: K;
        payload: z.infer<TEvents[K]>;
        schedule: {
            cron: string;
        };
    };
}[keyof TEvents];
export type EventDefinition<TEvent extends BaseEvents[string] = BaseEvents[string]> = SchemaDefinition<TEvent> & {
    attributes?: Record<string, string>;
};
export type ConfigurationDefinition<TConfig extends BaseConfig = BaseConfig> = SchemaDefinition<TConfig>;
export type UserDefinition = {
    tags?: Record<string, TagDefinition>;
};
export type ConversationDefinition = {
    tags?: Record<string, TagDefinition>;
};
export type MessageDefinition = {
    tags?: Record<string, TagDefinition>;
};
export type SecretDefinition = {
    optional?: boolean;
    description?: string;
};
export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = {
    title?: string;
    description?: string;
    input: SchemaDefinition<TAction>;
    output: SchemaDefinition<z.ZuiObjectOrRefSchema>;
    attributes?: Record<string, string>;
};
export type WorkflowDefinition<TWorkflow extends BaseWorkflows[string] = BaseWorkflows[string]> = {
    title?: string;
    description?: string;
    input: SchemaDefinition<TWorkflow>;
    output: SchemaDefinition<z.ZuiObjectSchema>;
    tags?: Record<string, TagDefinition>;
};
export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = Merge<Omit<Table, 'id' | 'createdAt' | 'updatedAt' | 'name'>, {
    schema: TTable;
}>;
export type ResolvedIntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = {
    enabled?: boolean;
    alias: string;
    disabledChannels?: StringKeys<NonNullable<I['definition']['channels']>>[];
} & ({
    configurationType?: null;
    configuration: z.input<NonNullable<I['definition']['configuration']>['schema']>;
} | ValueOf<{
    [K in StringKeys<NonNullable<I['definition']['configurations']>>]: {
        configurationType: K;
        configuration: z.input<NonNullable<I['definition']['configurations']>[K]['schema']>;
    };
}>);
type IntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = Omit<ResolvedIntegrationConfigInstance<I>, 'alias'> & {
    alias?: string;
};
type _ResolvedPluginConfigInstance<P extends PluginPackage = PluginPackage> = {
    alias: string;
    configuration: z.input<NonNullable<P['definition']['configuration']>['schema']>;
    interfaces: {
        [I in keyof NonNullable<P['definition']['interfaces']>]: PluginInterfaceExtension;
    };
    integrations: {
        [I in keyof NonNullable<P['definition']['integrations']>]: PluginIntegrationExtension;
    };
};
type PluginConfigInstance<P extends PluginPackage = PluginPackage> = Omit<_ResolvedPluginConfigInstance<P>, 'alias' | 'integrations' | 'interfaces'> & {
    alias?: string;
    /** Backing integrations for the plugin's dependencies */
    dependencies: {
        [K in StringKeys<NonNullable<P['definition']['interfaces']>>]: {
            /**
             * Alias of the integration to use to fullfil this dependency.
             *
             * This is the alias given when adding the integration to the bot
             * via `addIntegration()`.
             */
            integrationAlias: string;
            /**
             * Alias of the interface within the integration.
             *
             * This is the alias defined by the integration package for the
             * interface it implements.
             */
            integrationInterfaceAlias: string;
        };
    } & {
        [K in StringKeys<NonNullable<P['definition']['integrations']>>]: {
            /**
             * Alias of the integration to use to fullfil this dependency.
             *
             * This is the alias given when adding the integration to the bot
             * via `addIntegration()`.
             */
            integrationAlias: string;
        };
    };
};
export type IntegrationInstance = IntegrationPackage & ResolvedIntegrationConfigInstance;
export type PluginInstance = PluginPackage & _ResolvedPluginConfigInstance;
export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> = {
    integrations?: {
        [K: string]: IntegrationInstance;
    };
    plugins?: {
        [K: string]: PluginInstance;
    };
    user?: UserDefinition;
    conversation?: ConversationDefinition;
    message?: MessageDefinition;
    states?: {
        [K in keyof TStates]: StateDefinition<TStates[K]>;
    };
    configuration?: ConfigurationDefinition;
    events?: {
        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
    };
    recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
    actions?: {
        [K in keyof TActions]: ActionDefinition<TActions[K]>;
    };
    tables?: {
        [K in keyof TTables]: TableDefinition<TTables[K]>;
    };
    secrets?: Record<string, SecretDefinition>;
    /**
     * # EXPERIMENTAL
     * This API is experimental and may change in the future.
     */
    workflows?: {
        [K in keyof TWorkflows]: WorkflowDefinition<TWorkflows[K]>;
    };
    attributes?: Record<string, string>;
    __advanced?: SchemaTransformOptions;
};
export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> {
    readonly props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>;
    readonly integrations: this['props']['integrations'];
    readonly plugins: this['props']['plugins'];
    readonly user: this['props']['user'];
    readonly conversation: this['props']['conversation'];
    readonly message: this['props']['message'];
    readonly states: this['props']['states'];
    readonly configuration: this['props']['configuration'];
    readonly events: this['props']['events'];
    readonly recurringEvents: this['props']['recurringEvents'];
    readonly actions: this['props']['actions'];
    readonly tables: this['props']['tables'];
    readonly secrets: this['props']['secrets'];
    readonly workflows: this['props']['workflows'];
    readonly attributes: this['props']['attributes'];
    readonly __advanced: this['props']['__advanced'];
    /** Bot definition with plugins merged into it */
    readonly withPlugins: Pick<this['props'], 'user' | 'conversation' | 'message' | 'states' | 'events' | 'recurringEvents' | 'actions' | 'tables' | 'workflows'>;
    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>);
    get metadata(): {
        readonly sdkVersion: string;
    };
    addIntegration<I extends IntegrationPackage>(integrationPkg: I, config?: IntegrationConfigInstance<I>): this;
    addPlugin<P extends PluginPackage>(pluginPkg: P, config: PluginConfigInstance<P>): this;
    private _mergeUser;
    private _mergeConversation;
    private _mergeMessage;
    private _mergeStates;
    private _mergeEvents;
    private _mergeRecurringEvents;
    private _mergeActions;
    private _mergeTables;
    private _mergeWorkflows;
    private _prefixKeysWithPluginAlias;
    /**
     * Returns a copy of the bot definition where all interface entity references
     * are resolved to the base entity schema as extended by the backing
     * integration.
     */
    dereferencePluginEntities(): this;
    private _buildZuiReferenceMap;
    private _dereferenceZuiSchema;
    private _dereferenceDefinitionSchemas;
    private _dereferenceDefinitionSchema;
    private _dereferenceActionDefinitionSchemas;
}
export {};