@aigne/core 1.0.1 → 1.0.2-beta.2

package/lib/dts/memorable.d.ts

@@ -0,0 +1,183 @@
+import type { LLMModelInputMessage } from "./llm-model";
+import { Runnable } from "./runnable";
+export interface MemoryMetadata {
+    [key: string]: any;
+}
+export type MemoryActionItem<T> = {
+    event: "add";
+    id: string;
+    memory: T;
+    metadata?: MemoryMetadata;
+} | {
+    event: "update";
+    id: string;
+    memory: T;
+    oldMemory: T;
+    metadata?: MemoryMetadata;
+} | {
+    event: "delete";
+    id: string;
+    memory: T;
+} | {
+    event: "none";
+    memory: T;
+};
+export interface MemoryItem<T> {
+    id: string;
+    userId?: string;
+    sessionId?: string;
+    createdAt: string;
+    updatedAt: string;
+    memory: T;
+    metadata: MemoryMetadata;
+}
+export interface MemoryItemWithScore<T = any> extends MemoryItem<T> {
+    score: number;
+}
+export type MemoryMessage = LLMModelInputMessage;
+export type MemoryActions<T> = {
+    action: "add";
+    inputs: {
+        messages: MemoryMessage[];
+        options?: {
+            userId?: string;
+            sessionId?: string;
+            metadata?: MemoryMetadata;
+        };
+    };
+    outputs: {
+        results: MemoryActionItem<T>[];
+    };
+} | {
+    action: "search";
+    inputs: {
+        query: string;
+        options?: {
+            k?: number;
+            userId?: string;
+            sessionId?: string;
+            filter?: MemoryMetadata;
+            sort?: MemorySortOptions;
+        };
+    };
+    outputs: {
+        results: MemoryItemWithScore<T>[];
+    };
+} | {
+    action: "filter";
+    inputs: {
+        options?: {
+            k?: number;
+            userId?: string;
+            sessionId?: string;
+            filter?: MemoryMetadata;
+            sort?: MemorySortOptions;
+        };
+    };
+    outputs: {
+        results: MemoryItem<T>[];
+    };
+} | {
+    action: "get";
+    inputs: {
+        memoryId: string;
+    };
+    outputs: {
+        result: MemoryItem<T> | null;
+    };
+} | {
+    action: "create";
+    inputs: {
+        memory: T;
+        options?: {
+            userId?: string;
+            sessionId?: string;
+            metadata?: MemoryMetadata;
+        };
+    };
+    outputs: {
+        result: MemoryItem<T>;
+    };
+} | {
+    action: "update";
+    inputs: {
+        memoryId: string;
+        memory: T;
+    };
+    outputs: {
+        result: MemoryItem<T> | null;
+    };
+} | {
+    action: "delete";
+    inputs: {
+        filter: string | string[] | Record<string, any>;
+    };
+    outputs: {};
+} | {
+    action: "reset";
+    inputs: {};
+    outputs: {};
+};
+export interface SortItem {
+    field: string;
+    direction: "asc" | "desc";
+}
+export type MemorySortOptions = SortItem | SortItem[];
+export declare abstract class Memorable<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
+    constructor();
+    abstract runner?: MemoryRunner<T, C>;
+    abstract add(messages: Extract<MemoryActions<T>, {
+        action: "add";
+    }>["inputs"]["messages"], options?: Extract<MemoryActions<T>, {
+        action: "add";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "add";
+    }>["outputs"]>;
+    abstract search(query: Extract<MemoryActions<T>, {
+        action: "search";
+    }>["inputs"]["query"], options?: Extract<MemoryActions<T>, {
+        action: "search";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "search";
+    }>["outputs"]>;
+    abstract filter(options: Extract<MemoryActions<T>, {
+        action: "filter";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "filter";
+    }>["outputs"]>;
+    abstract get(memoryId: Extract<MemoryActions<T>, {
+        action: "get";
+    }>["inputs"]["memoryId"]): Promise<Extract<MemoryActions<T>, {
+        action: "get";
+    }>["outputs"]>;
+    abstract create(memory: Extract<MemoryActions<T>, {
+        action: "create";
+    }>["inputs"]["memory"], options?: Extract<MemoryActions<T>, {
+        action: "create";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "create";
+    }>["outputs"]>;
+    abstract update(memoryId: Extract<MemoryActions<T>, {
+        action: "update";
+    }>["inputs"]["memoryId"], memory: T): Promise<Extract<MemoryActions<T>, {
+        action: "update";
+    }>["outputs"]>;
+    abstract delete(memoryId: Extract<MemoryActions<T>, {
+        action: "delete";
+    }>["inputs"]["filter"]): Promise<Extract<MemoryActions<T>, {
+        action: "delete";
+    }>["outputs"]>;
+    abstract reset(): Promise<void>;
+}
+export interface MemoryRunnerInput<C = undefined> {
+    messages: MemoryMessage[];
+    userId?: string;
+    sessionId?: string;
+    metadata?: MemoryMetadata;
+    filter?: MemoryMetadata;
+    customData: C;
+}
+export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryActionItem<T>[]> {
+    constructor(name: string);
+}
+export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T["search"]>>["results"];

package/lib/dts/open-api-agent.d.ts

@@ -0,0 +1,55 @@
+import { Agent } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import type { CreateRunnableMemory } from "./definitions/memory";
+import type { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from "./definitions/open-api";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
+import type { OrderedRecord } from "./utils";
+export declare class OpenAPIAgent<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: OpenAPIAgentDefinition;
+    static create: typeof create;
+    constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
+    process(input: I): Promise<O>;
+    fetch<T>(request: FetchRequest): Promise<T>;
+}
+export interface OpenAPIAgentDefinition extends RunnableDefinition {
+    type: "open_api_agent";
+    inputs: OrderedRecord<OpenAPIDataType>;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+export interface CreateOpenAPIAgentOptions<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    id?: string;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+declare function create<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState>({ context, ...options }: CreateOpenAPIAgentOptions<I, O, Memories, State>): OpenAPIAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export {};

package/lib/dts/pipeline-agent.d.ts

@@ -0,0 +1,79 @@
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from "./runnable";
+import type { MakeNullablePropertyOptional } from "./utils/nullable";
+import { OrderedRecord } from "./utils/ordered-map";
+import type { ExtractRunnableInputType } from "./utils/runnable-type";
+export declare class PipelineAgent<I extends {
+    [key: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: PipelineAgentDefinition;
+    static create: typeof create;
+    constructor(definition: PipelineAgentDefinition, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("stream/web").ReadableStream<RunnableResponseDelta<O>>>;
+}
+type VariableWithPropPath = {
+    fromVariable: string;
+    fromVariablePropPath?: (string | number)[];
+};
+export type PipelineAgentProcessParameter<R extends Runnable = any, RI extends {
+    [name: string]: DataTypeSchema;
+} = ExtractRunnableInputType<R>> = {
+    runnable: R;
+    input: MakeNullablePropertyOptional<{
+        [key in keyof RI]: VariableWithPropPath;
+    }>;
+};
+declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema & {
+        fromVariable: string;
+        fromVariablePropPath?: string[];
+    };
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState, Processes extends {
+    [name: string]: PipelineAgentProcessParameter;
+}>({ context, ...options }: {
+    context: Context<State>;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    processes: Processes;
+}): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export interface PipelineAgentDefinition extends RunnableDefinition {
+    type: "pipeline_agent";
+    processes?: OrderedRecord<PipelineAgentProcess>;
+    outputs: OrderedRecord<PipelineAgentOutput>;
+}
+export type PipelineAgentOutput = RunnableOutput & {
+    from: "variable";
+    fromVariableId?: string;
+    fromVariablePropPath?: (string | number)[];
+};
+export type PipelineAgentProcess = {
+    id: string;
+    name?: string;
+    runnable?: {
+        id?: string;
+    };
+    input?: {
+        [inputId: string]: {
+            from: "variable";
+            fromVariableId?: string;
+            fromVariablePropPath?: (string | number | symbol)[];
+        };
+    };
+};
+export {};

package/lib/dts/runnable.d.ts

@@ -0,0 +1,70 @@
+import type { Context, ContextState } from "./context";
+import type { DataType } from "./definitions/data-type";
+import type { Memorable } from "./memorable";
+import { OrderedRecord } from "./utils/ordered-map";
+export interface RunOptions {
+    stream?: boolean;
+}
+export type RunnableResponse<T> = T | RunnableResponseStream<T>;
+export declare abstract class Runnable<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, State extends ContextState = ContextState> {
+    definition: RunnableDefinition;
+    context?: Context<State> | undefined;
+    constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
+    get id(): string;
+    get name(): string | undefined;
+    inputs: {
+        [key in keyof I]: DataType;
+    };
+    outputs: {
+        [key in keyof O]: DataType;
+    };
+    abstract run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    abstract run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+    abstract run(input: I, options?: RunOptions): Promise<RunnableResponse<O>>;
+}
+export interface RunnableDefinition {
+    id: string;
+    type: string;
+    name?: string;
+    description?: string;
+    memories?: OrderedRecord<RunnableMemory>;
+    inputs: OrderedRecord<RunnableInput>;
+    outputs: OrderedRecord<RunnableOutput>;
+}
+export interface RunnableMemory {
+    id: string;
+    name?: string;
+    memory?: Memorable<any>;
+    query?: {
+        from: "variable";
+        fromVariableId?: string;
+        fromVariablePropPath?: string[];
+    };
+    options?: {
+        k?: number;
+    };
+}
+export type RunnableInput = DataType;
+export type RunnableOutput = DataType;
+export interface RunnableResponseDelta<T> {
+    $text?: string;
+    delta?: Partial<T>;
+}
+export interface RunnableResponseError {
+    error: {
+        message: string;
+    };
+}
+export type RunnableResponseChunk<T> = RunnableResponseDelta<T>;
+export type RunnableResponseChunkWithError<T> = RunnableResponseChunk<T> | RunnableResponseError;
+export declare function isRunnableResponseDelta<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseDelta<T>;
+export declare function isRunnableResponseError<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseError;
+export type RunnableResponseStream<T> = ReadableStream<RunnableResponseChunk<T>>;

package/lib/dts/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const FETCH_TIMEOUT: number;

package/lib/dts/utils/fetch-open-api.d.ts

@@ -0,0 +1,2 @@
+import type { FetchRequest } from "../definitions/open-api";
+export declare function fetchOpenApi<T>(request: FetchRequest): Promise<T>;

package/lib/dts/utils/fetch.d.ts

@@ -0,0 +1 @@
+export declare function checkFetchResponse(result: Response): Promise<Response>;

package/lib/dts/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./fetch";
+export * from "./fetch-open-api";
+export * from "./is-non-nullable";
+export * from "./mustache-utils";
+export * from "./nullable";
+export * from "./omit";
+export * from "./open-api-parameter";
+export * from "./ordered-map";
+export * from "./stream-utils";
+export * from "./union";

package/lib/dts/utils/is-non-nullable.d.ts

@@ -0,0 +1,2 @@
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+export declare function isPropsNonNullable<T, K extends keyof T>(...props: (K | K[])[]): (value: T) => value is T & Required<Pick<T, K>>;

package/lib/dts/utils/message-utils.d.ts

@@ -0,0 +1,20 @@
+import type { LLMAgentDefinition } from "../llm-agent";
+import type { LLMModelInputMessage } from "../llm-model";
+import type { MemoryItemWithScore } from "../memorable";
+export declare function mergeHistoryMessages(messages: LLMModelInputMessage[], history: LLMModelInputMessage[]): LLMModelInputMessage[];
+export declare function memoriesToMessages(memories: {
+    [name: string]: MemoryItemWithScore[];
+}, { primaryMemoryName }?: {
+    primaryMemoryName?: string;
+}): {
+    primaryMemory: LLMModelInputMessage[];
+    memory: string;
+};
+export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
+    [name: string]: any;
+}, memories: {
+    [name: string]: MemoryItemWithScore[];
+}): {
+    originalMessages: LLMModelInputMessage[];
+    messagesWithMemory: LLMModelInputMessage[];
+};

package/lib/dts/utils/mustache-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function renderMessage(template: string, variables?: {
+    [key: string]: any;
+}): string;

package/lib/dts/utils/nullable.d.ts

@@ -0,0 +1,7 @@
+export type MakeNullablePropertyOptional<T extends {
+    [key: string]: any;
+}> = {
+    [K in keyof T as Extract<T[K], null | undefined> extends never ? K : never]: T[K];
+} & {
+    [K in keyof T as Extract<T[K], null | undefined> extends never ? never : K]?: T[K];
+};

package/lib/dts/utils/omit.d.ts

@@ -0,0 +1 @@
+export type OmitPropsFromUnion<T, K extends string | number | symbol> = T extends any ? Omit<T, K> : never;

package/lib/dts/utils/open-api-parameter.d.ts

@@ -0,0 +1,7 @@
+import type { AuthConfig, FetchRequest, HTTPMethod } from "../definitions/open-api";
+import type { OpenAPIAgentDefinition } from "../open-api-agent";
+export declare function formatOpenAPIRequest(api: {
+    url: string;
+    method: HTTPMethod;
+    auth?: AuthConfig;
+}, inputs: OpenAPIAgentDefinition["inputs"], input: Record<string, any>): Promise<FetchRequest>;

package/lib/dts/utils/ordered-map.d.ts

@@ -0,0 +1,37 @@
+export type OrderedRecord<T extends {
+    id: string;
+}> = Record<string, T> & {
+    $indexes: string[];
+};
+export declare namespace OrderedRecord {
+    function iterator<T extends {
+        id: string;
+    }>(record?: OrderedRecord<T>): IterableIterator<T>;
+    function map<O, T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, fn: (value: T, index: number) => O): O[];
+    function toArray<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined): T[];
+    function fromArray<T extends {
+        id: string;
+    }>(array?: T[]): OrderedRecord<T>;
+    function find<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T | undefined;
+    function filter<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T[];
+    function at<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, index: number): T | undefined;
+    function push<T extends {
+        id: string;
+    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
+    function merge<T extends {
+        id: string;
+    }>(...records: OrderedRecord<T>[]): OrderedRecord<T>;
+    function pushOrUpdate<T extends {
+        id: string;
+    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
+}

package/lib/dts/utils/runnable-type.d.ts

@@ -0,0 +1,3 @@
+import type { Runnable, RunnableResponseStream } from "../runnable";
+export type ExtractRunnableInputType<T> = T extends Runnable<infer I, any> ? I : never;
+export type ExtractRunnableOutputType<T> = T extends Runnable<any, infer O> ? Exclude<O, RunnableResponseStream<any>> : never;

package/lib/dts/utils/stream-utils.d.ts

@@ -0,0 +1,20 @@
+import { type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "../runnable";
+export declare function objectToRunnableResponseStream<T extends {
+    [key: string]: any;
+}>(obj: T): RunnableResponseStream<T>;
+export declare function runnableResponseStreamToObject<T extends {
+    [key: string]: any;
+}>(stream: RunnableResponseStream<T> | AsyncGenerator<RunnableResponseChunk<T>>): Promise<T>;
+/**
+ * Extracts the outputs from a runnable output stream and run the
+ * resolve function on the result before the stream closes. It can be
+ * used to update the memories of an agent.
+ * @param output The runnable output stream or object
+ * @param resolve The function to run on the result
+ * @returns The runnable output stream or object
+ */
+export declare function extractOutputsFromRunnableOutput<T extends {
+    [key: string]: any;
+}>(output: RunnableResponse<T> | AsyncGenerator<RunnableResponseChunk<T>>, resolve: (result: T) => Promise<void> | void): Promise<RunnableResponse<T>>;
+export declare function asyncGeneratorToReadableStream<T>(generator: AsyncGenerator<T>): ReadableStream<T>;
+export declare function isAsyncGenerator<T extends AsyncGenerator>(value: any): value is T;

package/lib/dts/utils/structured-output-schema.d.ts

@@ -0,0 +1,3 @@
+import type { RunnableOutput } from "../runnable";
+import { OrderedRecord } from "./ordered-map";
+export declare function outputsToJsonSchema(outputs: OrderedRecord<RunnableOutput>): object;

package/lib/dts/utils/union.d.ts

@@ -0,0 +1 @@
+export type UnionToIntersection<U, O = any> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I extends O ? I : never : never;

package/lib/esm/agent.d.ts

@@ -0,0 +1,41 @@
+import type { Context, ContextState } from "./context";
+import type { MemoryItemWithScore, MemoryMessage } from "./memorable";
+import { type RunOptions, Runnable, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
+export interface AgentProcessOptions<Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}> {
+    memories: Memories;
+}
+export declare abstract class Agent<I extends {
+    [key: string]: any;
+} = {}, O extends {
+    [key: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Runnable<I, O, State> {
+    private getMemoryQuery;
+    /**
+     * Load memories that are defined in the agent definition.
+     * @param input The agent input.
+     * @param context The AIGNE context.
+     * @returns A dictionary of memories, where the key is the memory id or name and the value is an array of memory items.
+     */
+    protected loadMemories(input: I, context?: Context): Promise<Memories>;
+    /**
+     * Update memories by user messages and assistant responses.
+     * @param messages Messages to be added to memories.
+     */
+    protected updateMemories(messages: MemoryMessage[]): Promise<void>;
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+    /**
+     * Hook that is called before the agent result is returned.
+     * @param _result The agent result.
+     */
+    protected onResult(_result: O): Promise<void>;
+    abstract process(input: I, options: AgentProcessOptions<Memories>): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
+}

package/lib/esm/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const TYPES: {
+    context: symbol;
+    definition: symbol;
+    llmModel: symbol;
+    functionRunner: symbol;
+};
+export declare const StreamTextOutputName = "$text";

package/lib/esm/context.d.ts

@@ -0,0 +1,17 @@
+import type { LLMModelConfiguration } from "./llm-model";
+import type { Runnable, RunnableDefinition } from "./runnable";
+export interface ContextState {
+    userId?: string;
+    sessionId?: string;
+    [key: string]: any;
+}
+export interface ContextConfig {
+    llmModel?: LLMModelConfiguration;
+}
+export interface Context<State extends ContextState = ContextState, Config extends ContextConfig = ContextConfig> {
+    state: State;
+    config: Config;
+    resolve<T extends Runnable>(id: string | RunnableDefinition | T): Promise<T>;
+    register<R extends Array<RunnableDefinition | Runnable> = []>(...definition: R): void;
+    resolveDependency<T>(token: string | symbol): T;
+}

package/lib/esm/definitions/data-type-schema.d.ts

@@ -0,0 +1,42 @@
+import type { MakeNullablePropertyOptional } from "../utils/nullable";
+import { OrderedRecord } from "../utils/ordered-map";
+import type { DataType } from "./data-type";
+export declare function schemaToDataType(dataType: {
+    [name: string]: DataTypeSchema;
+}): OrderedRecord<DataType>;
+export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
+export interface DataTypeSchemaBase {
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeSchemaString extends DataTypeSchemaBase {
+    type: "string";
+}
+export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
+    type: "number";
+}
+export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
+    type: "boolean";
+}
+export interface DataTypeSchemaObject extends DataTypeSchemaBase {
+    type: "object";
+    properties?: {
+        [key: string]: DataTypeSchema;
+    };
+}
+export interface DataTypeSchemaArray extends DataTypeSchemaBase {
+    type: "array";
+    items?: DataTypeSchema;
+}
+type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
+    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
+}> : T extends DataTypeSchemaArray ? T["items"] extends null | undefined ? SchemaType<{
+    type: "object";
+}>[] : SchemaType<NonNullable<T["items"]>>[] : never;
+export type SchemaType<T extends DataTypeSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
+export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
+    type: "object";
+    required: true;
+    properties: T;
+}>;
+export {};