import { JSONSchema7 } from 'json-schema';

type MaybePromise<T> = T | Promise<T>;
type DataRegion = 'eu' | 'us' | 'apac';

/**
 * Provider-neutral multi-modal content parts. A single `Message.content`
 * is a string (classic path); multi-modal messages populate `parts`
 * alongside — adapters that understand parts read them, the rest fall
 * back to `content` (which we keep as a text projection via
 * `partsToText`).
 */
interface TextPart {
    type: 'text';
    text: string;
}
interface ImagePart {
    type: 'image';
    /** Data URL, http(s) URL, or provider-hosted reference id. */
    source: string;
    mimeType?: string;
    /** Provider-neutral hint, e.g. 'low' / 'high'. */
    detail?: 'low' | 'high' | 'auto';
}
interface AudioPart {
    type: 'audio';
    source: string;
    mimeType?: string;
    /** Duration in seconds, if known. */
    durationSec?: number;
}
interface VideoPart {
    type: 'video';
    source: string;
    mimeType?: string;
    durationSec?: number;
}
interface FilePart {
    type: 'file';
    source: string;
    mimeType?: string;
    /** Original filename, when available. */
    filename?: string;
}
type ContentPart = TextPart | ImagePart | AudioPart | VideoPart | FilePart;
type PartKind = ContentPart['type'];
/** Build a text part. */
declare function textPart(text: string): TextPart;
/** Build an image part from a URL / data URI / hosted id. */
declare function imagePart(source: string, opts?: Omit<ImagePart, 'type' | 'source'>): ImagePart;
declare function audioPart(source: string, opts?: Omit<AudioPart, 'type' | 'source'>): AudioPart;
declare function videoPart(source: string, opts?: Omit<VideoPart, 'type' | 'source'>): VideoPart;
declare function filePart(source: string, opts?: Omit<FilePart, 'type' | 'source'>): FilePart;
/**
 * Collapse a parts array into a text-only projection. Non-text parts
 * are rendered as `[image: url]` / `[audio: url]` etc. so plain-text
 * adapters see *something* meaningful.
 */
declare function partsToText(parts: ContentPart[]): string;
/**
 * Normalize any of (string | ContentPart[] | undefined) into
 * `{ text, parts }`. Callers that have both the legacy `content`
 * string and the new `parts` array use this to pick the right one.
 */
declare function normalizeContent(content: string | undefined, parts: ContentPart[] | undefined): {
    text: string;
    parts: ContentPart[];
};
/** Filter parts by kind. */
declare function filterParts<T extends PartKind>(parts: ContentPart[], kind: T): Extract<ContentPart, {
    type: T;
}>[];

type ToolCallStatus = 'pending' | 'running' | 'complete' | 'error' | 'requires_confirmation';
interface ToolCall {
    id: string;
    name: string;
    args: Record<string, unknown>;
    result?: string;
    error?: string;
    status: ToolCallStatus;
}
interface ToolExecutionContext {
    messages: Message[];
    call: ToolCall;
}
interface ArgsValidationError {
    /** JSON pointer / dotted path to the offending field, or '' for root. */
    path: string;
    message: string;
}
interface ArgsValidationResult {
    valid: boolean;
    errors?: ArgsValidationError[];
    /** Optional pre-built human summary; used verbatim in the thrown error. */
    message?: string;
}
/**
 * Validate parsed tool-call args against the tool's JSON Schema.
 * Returns `{ valid: true }` to allow execution, or `{ valid: false, errors }`
 * to reject it with `AK_TOOL_INVALID_INPUT`.
 */
type ArgsValidator = (schema: JSONSchema7, args: Record<string, unknown>) => ArgsValidationResult;
/** Map JSON Schema `type` strings to TypeScript types. */
type JSONSchemaTypeMap = {
    string: string;
    number: number;
    integer: number;
    boolean: boolean;
    null: null;
    object: Record<string, unknown>;
    array: unknown[];
};
/** Resolve a single JSON Schema property to a TypeScript type. */
type InferJSONSchemaProperty<T> = T extends {
    type: 'object';
    properties: infer P;
} ? InferJSONSchemaObject<T> : T extends {
    type: 'array';
    items: infer I;
} ? Array<InferJSONSchemaProperty<I>> : T extends {
    type: infer U;
} ? U extends keyof JSONSchemaTypeMap ? JSONSchemaTypeMap[U] : unknown : unknown;
/** Resolve an object schema to a mapped type with required/optional handling. */
type InferJSONSchemaObject<T> = T extends {
    properties: infer P;
    required: infer R;
} ? R extends readonly string[] ? {
    [K in keyof P & string as K extends R[number] ? K : never]: InferJSONSchemaProperty<P[K]>;
} & {
    [K in keyof P & string as K extends R[number] ? never : K]?: InferJSONSchemaProperty<P[K]>;
} : {
    [K in keyof P & string]?: InferJSONSchemaProperty<P[K]>;
} : T extends {
    properties: infer P;
} ? {
    [K in keyof P & string]?: InferJSONSchemaProperty<P[K]>;
} : Record<string, unknown>;
/** Top-level inference: extract args type from a JSON Schema definition. */
type InferSchemaType<T> = T extends {
    type: 'object';
    properties: infer _P;
} ? InferJSONSchemaObject<T> : Record<string, unknown>;
interface ToolDefinition<TArgs = Record<string, unknown>> {
    name: string;
    description?: string;
    schema?: JSONSchema7;
    requiresConfirmation?: boolean;
    execute?: (args: TArgs, context: ToolExecutionContext) => MaybePromise<unknown> | AsyncIterable<unknown>;
    init?: () => MaybePromise<void>;
    dispose?: () => MaybePromise<void>;
    tags?: string[];
    category?: string;
}
/** Config for defineTool: schema is narrowed to a const type for inference. */
interface DefineToolConfig<TSchema extends JSONSchema7> {
    name: string;
    description?: string;
    schema?: TSchema;
    requiresConfirmation?: boolean;
    execute?: (args: InferSchemaType<TSchema>, context: ToolExecutionContext) => MaybePromise<unknown> | AsyncIterable<unknown>;
    init?: () => MaybePromise<void>;
    dispose?: () => MaybePromise<void>;
    tags?: string[];
    category?: string;
}
/** Create a ToolDefinition with automatic type inference from the JSON schema. */
declare function defineTool<TSchema extends JSONSchema7>(config: DefineToolConfig<TSchema>): ToolDefinition<InferSchemaType<TSchema>>;
interface ToolCallHandlerContext {
    messages: Message[];
    tool?: ToolDefinition;
}
type ToolAuthorizationPhase = 'propose' | 'execute';
interface ToolAuthorizationContext extends ToolCallHandlerContext {
    phase: ToolAuthorizationPhase;
}
interface ToolAuthorizationDecision {
    allowed: boolean;
    reason?: string;
}
type ToolAuthorizer = (toolCall: ToolCall, context: ToolAuthorizationContext) => MaybePromise<ToolAuthorizationDecision>;

type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
type MessageStatus = 'pending' | 'streaming' | 'complete' | 'error';
interface Message {
    id: string;
    role: MessageRole;
    /** Text projection of the message. Always populated, even for multi-modal. */
    content: string;
    /**
     * Multi-modal parts. When provided, `content` is a text projection
     * of these parts (see `partsToText`). Adapters that support the
     * relevant modality should prefer `parts` over `content`.
     */
    parts?: ContentPart[];
    status: MessageStatus;
    toolCalls?: ToolCall[];
    toolCallId?: string;
    metadata?: Record<string, unknown>;
    createdAt: Date;
}
interface MemoryRecord {
    version: 1;
    messages: Array<Omit<Message, 'createdAt'> & {
        createdAt: string;
    }>;
}

export { type ArgsValidator as A, videoPart as B, type ContentPart as C, type DataRegion as D, type FilePart as F, type ImagePart as I, type Message as M, type PartKind as P, type ToolDefinition as T, type VideoPart as V, type MemoryRecord as a, type MessageRole as b, type MessageStatus as c, type ToolExecutionContext as d, type ToolCall as e, type MaybePromise as f, type ToolAuthorizer as g, type ArgsValidationError as h, type ArgsValidationResult as i, type AudioPart as j, type DefineToolConfig as k, type InferSchemaType as l, type TextPart as m, type ToolAuthorizationContext as n, type ToolAuthorizationDecision as o, type ToolAuthorizationPhase as p, type ToolCallHandlerContext as q, type ToolCallStatus as r, audioPart as s, defineTool as t, filePart as u, filterParts as v, imagePart as w, normalizeContent as x, partsToText as y, textPart as z };