@aigne/core 1.0.17 → 1.1.0-beta.2

package/lib/cjs/utils/mustache-utils.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderMessage = renderMessage;
-const mustache_1 = __importDefault(require("mustache"));
-function renderMessage(template, variables) {
-    return mustache_1.default.render(template, variables, undefined, {
-        escape: (v) => {
-            return typeof v === "object" ? JSON.stringify(v) : v;
-        },
-    });
-}

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

@@ -1,7 +0,0 @@
-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/cjs/utils/nullable.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/cjs/utils/omit.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,7 +0,0 @@
-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/cjs/utils/open-api-parameter.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatOpenAPIRequest = formatOpenAPIRequest;
-const lodash_1 = require("lodash");
-const logger_1 = require("./logger");
-const ordered_map_1 = require("./ordered-map");
-async function formatOpenAPIRequest(api, inputs, input) {
-    const { url, method, ...inputParams } = processParameters(api, inputs, input);
-    logger_1.logger.debug("inputParams", inputParams);
-    const authParams = await getAuthParams(api.auth);
-    logger_1.logger.debug("authParams", authParams);
-    return {
-        url,
-        method,
-        ...(0, lodash_1.omitBy)({
-            ...inputParams,
-            query: { ...inputParams.query, ...authParams.query },
-            cookies: { ...inputParams.cookies, ...authParams.cookies },
-            headers: { ...inputParams.headers, ...authParams.headers },
-        }, (i) => (0, lodash_1.isEmpty)(i)),
-    };
-}
-async function getAuthParams(auth) {
-    if (!auth)
-        return {};
-    if (auth.type === "custom") {
-        return await auth.auth();
-    }
-    const { type, key, token } = auth;
-    switch (auth.in) {
-        case "query":
-            return { query: { [key || "token"]: token } };
-        case "cookie":
-            return { cookies: { [key || "token"]: token } };
-        default: {
-            const prefix = type === "bearer" ? "Bearer " : type === "basic" ? "Basic " : "";
-            return { headers: { [key || "Authorization"]: `${prefix}${token}` } };
-        }
-    }
-}
-function processParameters(api, inputs, input) {
-    const result = {
-        url: api.url,
-        method: api.method,
-        headers: {},
-        query: {},
-        cookies: {},
-        body: {},
-    };
-    for (const [key, value] of Object.entries(input)) {
-        const schema = ordered_map_1.OrderedRecord.find(inputs, (x) => x.name === key);
-        if (!schema)
-            continue;
-        switch (schema.in) {
-            case "query":
-                result.query[key] = value;
-                break;
-            case "header":
-                result.headers[key] = value;
-                break;
-            case "cookie":
-                result.cookies[key] = value;
-                break;
-            case "body":
-                result.body[key] = value;
-                break;
-            case "path":
-                result.url = result.url.replace(`{${key}}`, String(value));
-                break;
-            default:
-                // 没有指定 in 的情况
-                if (result.method.toLowerCase() === "get") {
-                    result.query[key] = value;
-                }
-                else {
-                    result.body[key] = value;
-                }
-        }
-    }
-    return result;
-}

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

@@ -1,37 +0,0 @@
-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/cjs/utils/ordered-map.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderedRecord = void 0;
-var OrderedRecord;
-(function (OrderedRecord) {
-    function iterator(record) {
-        return (function* () {
-            if (!record)
-                return;
-            for (const id of record.$indexes) {
-                yield record[id];
-            }
-        })();
-    }
-    OrderedRecord.iterator = iterator;
-    function map(record, fn) {
-        if (!record)
-            return [];
-        const result = new Array(record.$indexes.length);
-        for (let i = 0; i < record.$indexes.length; i++) {
-            result[i] = fn(record[record.$indexes[i]], i);
-        }
-        return result;
-    }
-    OrderedRecord.map = map;
-    function toArray(record) {
-        return OrderedRecord.map(record, (value) => value);
-    }
-    OrderedRecord.toArray = toArray;
-    function fromArray(array) {
-        const record = { $indexes: [] };
-        for (const value of array ?? []) {
-            record[value.id] = value;
-            record.$indexes.push(value.id);
-        }
-        return record;
-    }
-    OrderedRecord.fromArray = fromArray;
-    function find(record, predicate) {
-        if (!record)
-            return undefined;
-        for (let i = 0; i < record.$indexes.length; i++) {
-            const id = record.$indexes[i];
-            const value = record[id];
-            if (predicate(value, i))
-                return value;
-        }
-        return undefined;
-    }
-    OrderedRecord.find = find;
-    function filter(record, predicate) {
-        if (!record)
-            return [];
-        const result = [];
-        for (let i = 0; i < record.$indexes.length; i++) {
-            const id = record.$indexes[i];
-            const value = record[id];
-            if (predicate(value, i))
-                result.push(value);
-        }
-        return result;
-    }
-    OrderedRecord.filter = filter;
-    function at(record, index) {
-        if (!record?.$indexes.length)
-            return undefined;
-        const id = record.$indexes.at(index);
-        return record[id];
-    }
-    OrderedRecord.at = at;
-    function push(record, ...items) {
-        for (const item of items) {
-            if (record[item.id])
-                throw new Error(`Item with id ${item.id} already exists`);
-            record.$indexes.push(item.id);
-            record[item.id] = item;
-        }
-        return record;
-    }
-    OrderedRecord.push = push;
-    function merge(...records) {
-        const result = { $indexes: [] };
-        for (const record of records) {
-            for (const id of record.$indexes) {
-                if (!result[id])
-                    result.$indexes.push(id);
-                result[id] = record[id];
-            }
-        }
-        return result;
-    }
-    OrderedRecord.merge = merge;
-    function pushOrUpdate(record, ...items) {
-        for (const item of items) {
-            if (!record[item.id]) {
-                record.$indexes.push(item.id);
-            }
-            record[item.id] = item;
-        }
-        return record;
-    }
-    OrderedRecord.pushOrUpdate = pushOrUpdate;
-})(OrderedRecord || (exports.OrderedRecord = OrderedRecord = {}));

package/lib/cjs/utils/partial.d.ts

@@ -1,3 +0,0 @@
-export type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;

package/lib/cjs/utils/partial.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,5 +0,0 @@
-import type { Runnable, RunnableInput, RunnableOutput, RunnableResponseStream } from "../runnable";
-import type { UnionToIntersection } from "./union";
-export type ExtractRunnableInputType<T> = T extends Runnable<infer I, RunnableOutput> ? I : never;
-export type ExtractRunnableOutputType<T> = T extends Runnable<RunnableInput, infer O> ? Exclude<O, RunnableResponseStream<unknown>> : never;
-export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, Record<string, unknown>>;

package/lib/cjs/utils/runnable-type.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,20 +0,0 @@
-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/cjs/utils/stream-utils.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectToRunnableResponseStream = objectToRunnableResponseStream;
-exports.runnableResponseStreamToObject = runnableResponseStreamToObject;
-exports.extractOutputsFromRunnableOutput = extractOutputsFromRunnableOutput;
-exports.asyncGeneratorToReadableStream = asyncGeneratorToReadableStream;
-exports.isAsyncGenerator = isAsyncGenerator;
-const runnable_1 = require("../runnable");
-function objectToRunnableResponseStream(obj) {
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue({ $text: obj.$text || undefined, delta: obj });
-            controller.close();
-        },
-    });
-}
-async function runnableResponseStreamToObject(stream) {
-    let $text = "";
-    const result = {};
-    for await (const value of stream) {
-        if ((0, runnable_1.isRunnableResponseDelta)(value)) {
-            $text += value.$text || "";
-            Object.assign(result, value.delta);
-        }
-    }
-    Object.assign(result, { $text: result.$text || $text || undefined });
-    return result;
-}
-/**
- * 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
- */
-async function extractOutputsFromRunnableOutput(output, resolve) {
-    if (output instanceof ReadableStream ||
-        isAsyncGenerator(output)) {
-        return new ReadableStream({
-            async start(controller) {
-                try {
-                    const result = {};
-                    let $text = "";
-                    for await (const value of output) {
-                        controller.enqueue(value);
-                        if ((0, runnable_1.isRunnableResponseDelta)(value)) {
-                            $text += value.$text || "";
-                            Object.assign(result, value.delta);
-                        }
-                    }
-                    Object.assign(result, { $text: result.$text || $text || undefined });
-                    await resolve(result);
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-                finally {
-                    controller.close();
-                }
-            },
-        });
-    }
-    await resolve(output);
-    return output;
-}
-function asyncGeneratorToReadableStream(generator) {
-    return new ReadableStream({
-        async start(controller) {
-            try {
-                for await (const value of generator) {
-                    controller.enqueue(value);
-                }
-            }
-            catch (error) {
-                controller.error(error);
-            }
-            finally {
-                controller.close();
-            }
-        },
-    });
-}
-function isAsyncGenerator(value) {
-    return Symbol.asyncIterator in value;
-}

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

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

package/lib/cjs/utils/structured-output-schema.js

@@ -1,43 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.outputsToJsonSchema = outputsToJsonSchema;
-const omitBy_1 = __importDefault(require("lodash/omitBy"));
-const is_non_nullable_1 = require("./is-non-nullable");
-const ordered_map_1 = require("./ordered-map");
-function outputsToJsonSchema(outputs) {
-    const outputToSchema = (output) => {
-        const properties = output.type === "object" && output.properties?.$indexes.length
-            ? ordered_map_1.OrderedRecord.map(output.properties, (property) => {
-                if (!property.name)
-                    return null;
-                const schema = outputToSchema(property);
-                if (!schema)
-                    return null;
-                return { schema, property };
-            }).filter(is_non_nullable_1.isNonNullable)
-            : undefined;
-        return (0, omitBy_1.default)({
-            type: output.type,
-            description: output.description,
-            properties: properties?.length
-                ? Object.fromEntries(properties.map((p) => [p.property.name, p.schema]))
-                : undefined,
-            items: output.type === "array" && output.items
-                ? outputToSchema(output.items)
-                : undefined,
-            additionalProperties: output.type === "object" ? false : undefined,
-            required: properties?.length
-                ? properties
-                    .filter((i) => i.property.required)
-                    .map((i) => i.property.name)
-                : undefined,
-        }, (v) => v === undefined);
-    };
-    return outputToSchema({
-        type: "object",
-        properties: outputs,
-    });
-}

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

@@ -1 +0,0 @@
-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/cjs/utils/union.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/dts/agent.d.ts

@@ -1,96 +0,0 @@
-import type { Context, ContextState } from "./context";
-import type { DataSchema } from "./definitions/data-schema";
-import type { AgentMemory, CreateRunnableMemory } from "./definitions/memory";
-import type { AgentPreload, BindAgentInputs, BoundAgent, PreloadCreator } from "./definitions/preload";
-import type { MemorableSearchOutput, MemoryItemWithScore, MemoryMessage } from "./memorable";
-import { type RunOptions, Runnable, type RunnableDefinition, type RunnableInput, type RunnableOutput, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
-import { OrderedRecord } from "./utils";
-import type { ExtractRunnableOutputType } from "./utils/runnable-type";
-export type AgentPreloads = Record<string, unknown>;
-export type AgentMemories = Record<string, MemoryItemWithScore[]>;
-export declare abstract class Agent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Runnable<I, O, State> {
-    definition: AgentDefinition;
-    context?: Context<State> | undefined;
-    constructor(definition: AgentDefinition, context?: Context<State> | undefined);
-    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): Promise<Memories>;
-    /**
-     * Update memories by user messages and assistant responses.
-     * @param messages Messages to be added to memories.
-     */
-    protected updateMemories(messages: MemoryMessage[]): Promise<void>;
-    protected loadPreloads(input: I): Promise<Preloads>;
-    run(input: I, options: RunOptions & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    run(input: I, options?: RunOptions & {
-        stream?: false;
-    }): Promise<O>;
-    private addHistory;
-    /**
-     * Hook that is called before the agent result is returned.
-     * @param _result The agent result.
-     */
-    protected onResult(_result: O): Promise<void>;
-    abstract process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
-    /**
-     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
-     * @param options The bind options.
-     * @returns The bound agent.
-     */
-    bind<Input extends BindAgentInputs<Record<string, never>, typeof this>>(options: {
-        description?: string;
-        input?: Input;
-    }): BoundAgent<Record<string, never>, typeof this, Readonly<Input>>;
-}
-export type AgentProcessOptions<Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
-    preloads: Preloads;
-    memories: Memories;
-};
-export type AgentProcessInput<I extends RunnableInput, Preloads extends AgentPreloads, Memories extends AgentMemories> = I & Preloads & Memories;
-export interface AgentDefinition extends RunnableDefinition {
-    preloads?: OrderedRecord<AgentPreload>;
-    memories?: OrderedRecord<AgentMemory>;
-}
-export type CreateAgentInputSchema = Record<string, DataSchema>;
-export type CreateAgentOutputSchema<Extra extends Record<string, unknown> = Record<string, unknown>> = Record<string, DataSchema & Extra>;
-export type CreateAgentPreloadsSchema<I extends CreateAgentInputSchema> = Record<string, PreloadCreator<I>>;
-export type CreateAgentPreloadsType<I extends CreateAgentInputSchema, Preloads extends CreateAgentPreloadsSchema<I>> = {
-    [name in keyof Preloads]: ExtractRunnableOutputType<ReturnType<Preloads[name]>["runnable"]>;
-};
-export type CreateAgentMemoriesSchema<I extends CreateAgentInputSchema, Extras extends Record<string, unknown> = Record<string, unknown>> = Record<string, CreateRunnableMemory<I> & Extras>;
-export type CreateAgentMemoriesType<I extends CreateAgentInputSchema, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> = {
-    [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
-};
-/**
- * Common options to create Agent.
- */
-export interface CreateAgentOptions<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> {
-    context?: Context<State>;
-    /**
-     * Agent name, used to identify the agent.
-     */
-    name?: string;
-    /**
-     * Input variables for this agent.
-     */
-    inputs: I;
-    /**
-     * Output variables for this agent.
-     */
-    outputs: O;
-    /**
-     * Preload runnables before running this agent. the preloaded data are available in the agent as input variables.
-     */
-    preloads?: Preloads;
-    /**
-     * Memories to be used in this agent.
-     */
-    memories?: Memories;
-}

package/lib/dts/constants.d.ts

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

package/lib/dts/context.d.ts

@@ -1,23 +0,0 @@
-import type { LLMModelConfiguration } from "./llm-model";
-import type { Memorable } from "./memorable";
-import type { Runnable, RunnableDefinition } from "./runnable";
-export interface ContextState {
-    userId?: string;
-    sessionId?: string;
-    [key: string]: unknown;
-}
-export interface ContextConfig {
-    llmModel?: LLMModelConfiguration;
-}
-export interface Context<State extends ContextState = ContextState, Config extends ContextConfig = ContextConfig> {
-    id: string;
-    state: State;
-    config: Config;
-    historyManager?: Memorable<{
-        input: object;
-        output: object;
-    }>;
-    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/dts/definitions/data-schema.d.ts

@@ -1,61 +0,0 @@
-import type { MakeNullablePropertyOptional } from "../utils/nullable";
-import { OrderedRecord } from "../utils/ordered-map";
-import type { ArrayElement } from "../utils/type-utils";
-import type { DataType } from "./data-type";
-export declare function schemaToDataType(dataType: {
-    [name: string]: DataSchema;
-}): OrderedRecord<DataType>;
-export type DataSchema = DataSchemaString | DataSchemaNumber | DataSchemaBoolean | DataSchemaObject | DataSchemaArray;
-export interface DataSchemaBase {
-    description?: string;
-    required?: boolean;
-}
-export interface DataSchemaString extends DataSchemaBase {
-    type: "string";
-}
-export interface DataSchemaNumber extends DataSchemaBase {
-    type: "number";
-}
-export interface DataSchemaBoolean extends DataSchemaBase {
-    type: "boolean";
-}
-export interface DataSchemaObject extends DataSchemaBase {
-    type: "object";
-    properties?: {
-        [key: string]: DataSchema;
-    };
-}
-export interface DataSchemaArray extends DataSchemaBase {
-    type: "array";
-    items?: DataSchema;
-}
-type SchemaTypeInner<T extends DataSchema> = T extends DataSchemaString ? string : T extends DataSchemaNumber ? number : T extends DataSchemaBoolean ? boolean : T extends DataSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
-}> : T extends DataSchemaArray ? Extract<T["items"], null | undefined> extends never ? SchemaType<NonNullable<T["items"]>>[] : SchemaType<{
-    type: "object";
-}>[] : never;
-type SchemaType<T extends DataSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
-export type SchemaToType<T extends Record<string, DataSchema>> = SchemaType<{
-    type: "object";
-    required: true;
-    properties: T;
-}>;
-type TypeToSchemaInner<T> = Extract<T, string | undefined> extends string | undefined ? DataSchemaString & {
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, number | undefined> extends number | undefined ? DataSchemaNumber & {
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, boolean | undefined> extends boolean | undefined ? DataSchemaBoolean & {
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, object | undefined> extends object | undefined ? DataSchemaObject & {
-    properties: {
-        [K in keyof T]: TypeToSchemaInner<NonNullable<T[K]>>;
-    };
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, [] | undefined> extends [] | undefined ? DataSchemaArray & {
-    items: Extract<T, undefined> extends undefined ? undefined : TypeToSchemaInner<NonNullable<ArrayElement<T>>>;
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : never;
-export type TypeToSchema<T extends Record<string, unknown>> = {
-    [K in keyof T]: TypeToSchemaInner<T[K]>;
-};
-export {};