import type * as esbuild from 'esbuild';
import { SchemaTransformOptions } from '../../common/types';
import { InterfacePackage } from '../../package';
import * as utils from '../../utils';
import { z } from '../../zui';
import { SchemaStore, BrandedSchema } from './branded-schema';
import { BaseConfig, BaseEvents, BaseActions, BaseChannels, BaseStates, BaseEntities, BaseConfigs } from './generic';
import { ConfigurationDefinition, EventDefinition, ChannelDefinition, ActionDefinition, StateDefinition, UserDefinition, SecretDefinition, EntityDefinition, AdditionalConfigurationDefinition, InterfaceExtension } from './types';
export * from './types';
export type IntegrationDefinitionProps<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TConfigs extends BaseConfigs = BaseConfigs, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TChannels extends BaseChannels = BaseChannels, TStates extends BaseStates = BaseStates, TEntities extends BaseEntities = BaseEntities> = {
    name: TName;
    version: TVersion;
    title?: string;
    description?: string;
    icon?: string;
    readme?: string;
    attributes?: Record<string, string>;
    identifier?: {
        extractScript?: string;
        fallbackHandlerScript?: string;
    };
    configuration?: ConfigurationDefinition<TConfig>;
    configurations?: {
        [K in keyof TConfigs]: AdditionalConfigurationDefinition<TConfigs[K]>;
    };
    events?: {
        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
    };
    actions?: {
        [K in keyof TActions]: ActionDefinition<TActions[K]>;
    };
    channels?: {
        [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
    };
    states?: {
        [K in keyof TStates]: StateDefinition<TStates[K]>;
    };
    user?: UserDefinition;
    secrets?: Record<string, SecretDefinition>;
    entities?: {
        [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
    };
    interfaces?: Record<string, InterfaceExtension>;
    __advanced?: SchemaTransformOptions & {
        esbuild?: Partial<esbuild.BuildOptions>;
        extraOperations?: Record<string, {
            enabled: boolean;
        }>;
    };
};
type EntitiesOfPackage<TPackage extends InterfacePackage> = {
    [K in keyof TPackage['definition']['entities']]: NonNullable<TPackage['definition']['entities']>[K]['schema'];
};
type ActionsOfPackage<TPackage extends InterfacePackage> = {
    [K in keyof TPackage['definition']['actions']]: NonNullable<TPackage['definition']['actions']>[K]['input']['schema'];
};
type EventsOfPackage<TPackage extends InterfacePackage> = {
    [K in keyof TPackage['definition']['events']]: NonNullable<TPackage['definition']['events']>[K]['schema'];
};
type ChannelsOfPackage<TPackage extends InterfacePackage> = {
    [K in keyof TPackage['definition']['channels']]: {
        [M in keyof NonNullable<TPackage['definition']['channels']>[K]['messages']]: NonNullable<NonNullable<TPackage['definition']['channels']>[K]['messages']>[M]['schema'];
    };
};
export type ActionOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<ActionDefinition>, 'title' | 'description' | 'billable' | 'cacheable' | 'attributes'> & {
    name: string;
}>;
export type EventOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<EventDefinition>, 'title' | 'description' | 'attributes'> & {
    name: string;
}>;
export type ChannelOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<ChannelDefinition>, 'title' | 'description'> & {
    name: string;
    message: {
        tags: Required<Required<ChannelDefinition>['message']>['tags'];
    };
    conversation: {
        tags: Required<Required<ChannelDefinition>['conversation']>['tags'];
    };
}>;
type ActionOverrides<TInterfaceActionNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceActionNames, ActionOverrideProps>>;
type EventOverrides<TInterfaceEventNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceEventNames, EventOverrideProps>>;
type ChannelOverrides<TInterfaceChannelNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceChannelNames, ChannelOverrideProps>>;
type ExtensionBuilderInput<TIntegrationEntities extends BaseEntities, _TIntegrationActions extends BaseActions, _TIntegrationEvents extends BaseEvents, _TIntegrationChannels extends BaseChannels> = {
    entities: SchemaStore<TIntegrationEntities>;
};
type ExtensionBuilderOutput<TInterfaceEntities extends BaseEntities, TInterfaceActions extends BaseActions, TInterfaceEvents extends BaseEvents, TInterfaceChannels extends BaseChannels> = {
    entities: {
        [K in keyof TInterfaceEntities]: BrandedSchema<z.ZodSchema<z.infer<TInterfaceEntities[K]>>>;
    };
    actions?: ActionOverrides<Extract<keyof TInterfaceActions, string>>;
    events?: EventOverrides<Extract<keyof TInterfaceEvents, string>>;
    channels?: ChannelOverrides<Extract<keyof TInterfaceChannels, string>>;
};
type ExtensionBuilder<TIntegrationEntities extends BaseEntities, TIntegrationActions extends BaseActions, TIntegrationEvents extends BaseEvents, TIntegrationChannels extends BaseChannels, TInterfaceEntities extends BaseEntities, TInterfaceActions extends BaseActions, TInterfaceEvents extends BaseEvents, TInterfaceChannels extends BaseChannels> = (input: ExtensionBuilderInput<TIntegrationEntities, TIntegrationActions, TIntegrationEvents, TIntegrationChannels>) => ExtensionBuilderOutput<TInterfaceEntities, TInterfaceActions, TInterfaceEvents, TInterfaceChannels>;
export declare class IntegrationDefinition<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TConfigs extends BaseConfigs = BaseConfigs, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TChannels extends BaseChannels = BaseChannels, TStates extends BaseStates = BaseStates, TEntities extends BaseEntities = BaseEntities> {
    readonly props: IntegrationDefinitionProps<TName, TVersion, TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>;
    readonly name: this['props']['name'];
    readonly version: this['props']['version'];
    readonly title: this['props']['title'];
    readonly description: this['props']['description'];
    readonly icon: this['props']['icon'];
    readonly readme: this['props']['readme'];
    readonly configuration: this['props']['configuration'];
    readonly configurations: this['props']['configurations'];
    readonly events: this['props']['events'];
    readonly actions: this['props']['actions'];
    readonly channels: this['props']['channels'];
    readonly states: this['props']['states'];
    readonly user: this['props']['user'];
    readonly secrets: this['props']['secrets'];
    readonly identifier: this['props']['identifier'];
    readonly entities: this['props']['entities'];
    readonly interfaces: this['props']['interfaces'];
    readonly __advanced: this['props']['__advanced'];
    readonly attributes: this['props']['attributes'];
    constructor(props: IntegrationDefinitionProps<TName, TVersion, TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>);
    get metadata(): {
        readonly sdkVersion: string;
    };
    extend<P extends InterfacePackage>(interfacePkg: P, builder: ExtensionBuilder<TEntities, TActions, TEvents, TChannels, EntitiesOfPackage<P>, ActionsOfPackage<P>, EventsOfPackage<P>, ChannelsOfPackage<P>>): this;
    private _callBuilder;
    private _mergeActions;
    private _mergeEvents;
    private _mergeChannels;
    private _mergeMessage;
    private _mergeObjectSchemas;
}