import type { z } from 'zod';
import type { FilesApi, FileScopes } from '../common/context-files';
import type { Extension } from './extension';
import type { OAuth2Props, OAuthBag } from './oauth/types';
import type { DictionaryRef } from './params';
import type { PollingTriggerProps } from './polling-triggers/types';
import type { RealtimeSetupProps, RealtimeTriggerProps } from './realtime-triggers/types';
export type { ZodIssue, ZodSchema } from './params';
import type { ZodSchema } from './params';
export type AnySchema = z.ZodType;
export type Infer<TSchema, TFallback = Record<string, unknown>> = TSchema extends z.ZodType ? (unknown extends z.infer<TSchema> ? TFallback : z.infer<TSchema>) : TFallback;
export interface Logger {
    debug: (...args: unknown[]) => void;
    info: (...args: unknown[]) => void;
    warn: (...args: unknown[]) => void;
    error: (...args: unknown[]) => void;
}
export type ApiRequestFn = (arg: never) => unknown;
export type ProviderPayload = any;
type InjectedApiRequestArgs = 'context' | 'logger';
export type BoundApiRequest<TApiRequest> = TApiRequest extends (arg: infer TArg) => infer TResult ? (arg: Omit<TArg, InjectedApiRequestArgs>) => TResult : (arg: Record<string, unknown>) => unknown;
export interface ExtensionShape {
    config: unknown;
    context: unknown;
    helpers: unknown;
    apiRequest: unknown;
}
export interface HandlerBag<TShape extends ExtensionShape = AnyShape> {
    config: TShape['config'];
    context: TShape['context'];
    helpers: TShape['helpers'];
    apiRequest: BoundApiRequest<TShape['apiRequest']>;
    oauth: OAuthBag;
    files: FilesApi;
    filesScope: FileScopes;
    logger: Logger;
}
export type BagWithParams<TShape extends ExtensionShape, TSchema> = HandlerBag<TShape> & {
    params: Infer<TSchema>;
};
export type SampleResult<TShape extends ExtensionShape, TSchema> = Record<string, unknown> | unknown[] | string | number | boolean | null | AnySchema | ((bag: BagWithParams<TShape, TSchema>) => unknown);
export interface ExtensionProps<TConfigSchema extends AnySchema = AnySchema, TContext = unknown, THelpers = Record<string, unknown>, TApiRequest extends ApiRequestFn = ApiRequestFn> {
    id: string;
    name: string;
    description: string;
    logo: string;
    appearanceColors?: [string, string];
    usesFileStorage?: boolean;
    configItems?: TConfigSchema;
    initContext?: (bag: {
        config: Infer<TConfigSchema>;
        oauth: OAuthBag;
    }) => TContext;
    apiRequest?: TApiRequest;
    helpers?: (bag: Omit<HandlerBag<{
        config: Infer<TConfigSchema>;
        context: TContext;
        helpers: never;
        apiRequest: TApiRequest;
    }>, 'helpers'>) => THelpers;
}
export type ShapeOf<TConfigSchema extends AnySchema, TContext, THelpers, TApiRequest extends ApiRequestFn> = {
    config: Infer<TConfigSchema>;
    context: TContext;
    helpers: THelpers;
    apiRequest: TApiRequest;
};
export interface DictionaryResultItem {
    value: string | number | boolean | null;
    label: string;
    note?: string;
}
export type DictionaryResultItems = DictionaryResultItem[];
export interface DictionaryResult {
    cursor?: string;
    items: DictionaryResultItems;
}
export interface DictionaryProps<TShape extends ExtensionShape = AnyShape, TCriteria extends AnySchema = AnySchema> {
    id: string;
    category?: string;
    label?: string;
    description?: string;
    criteria?: TCriteria;
    result?: unknown;
    oauth2Scopes?: string[];
    execute: (bag: HandlerBag<TShape> & {
        search?: string;
        cursor?: unknown;
        criteria: Infer<TCriteria>;
    }) => DictionaryResult | DictionaryResultItems | Promise<DictionaryResult | DictionaryResultItems>;
}
export interface DynamicParamsDef<TShape extends ExtensionShape = AnyShape, TCriteria extends AnySchema = AnySchema> {
    criteria: TCriteria;
    resolve: (bag: HandlerBag<TShape> & {
        criteria: Infer<TCriteria>;
    }) => AnySchema | Promise<AnySchema>;
}
export interface ActionProps<TShape extends ExtensionShape = AnyShape, TParams extends AnySchema = AnySchema, TDynamicCriteria extends AnySchema = AnySchema> {
    category: string;
    id: string;
    label: string;
    description: string;
    params?: TParams;
    dynamicParams?: DynamicParamsDef<TShape, TDynamicCriteria>;
    result: SampleResult<TShape, TParams>;
    logo?: string;
    appearanceColors?: [string, string];
    oauth2Scopes?: string[];
    execute: (bag: BagWithParams<TShape, TParams>) => unknown;
}
export interface ExtensionApi<TShape extends ExtensionShape = AnyShape> {
    dictionary<TCriteria extends AnySchema = AnySchema>(props: DictionaryProps<TShape, TCriteria>): DictionaryRef;
    addAction<TParams extends AnySchema = AnySchema, TDynamicCriteria extends AnySchema = AnySchema>(props: ActionProps<TShape, TParams, TDynamicCriteria>): void;
    addPollingTrigger<TParams extends AnySchema = AnySchema>(props: PollingTriggerProps<TShape, TParams>): void;
    setupRealtimeTriggers(props: RealtimeSetupProps<TShape>): void;
    addRealtimeTrigger<TParams extends AnySchema = AnySchema>(props: RealtimeTriggerProps<TShape, TParams>): void;
    setupOauth2<TToken = unknown>(props: OAuth2Props<TShape, TToken>): void;
    readonly extension: Extension;
}
export interface AnyShape extends ExtensionShape {
    config: Record<string, unknown>;
    context: any;
    helpers: any;
    apiRequest: (arg: Record<string, unknown>) => unknown;
}
export declare const asRuntimeSchema: (schema?: AnySchema) => ZodSchema | undefined;