@botpress/sdk 0.2.3 → 0.3.0

package/dist/integration/generic.d.ts

@@ -0,0 +1,28 @@
+export type BaseIntegration = {
+    name: string;
+    version: string;
+    configuration: any;
+    actions: Record<string, Record<'input' | 'output', any>>;
+    channels: Record<string, {
+        messages: Record<string, any>;
+        message: {
+            tags: Record<string, any>;
+        };
+        conversation: {
+            tags: Record<string, any>;
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        };
+    }>;
+    events: Record<string, any>;
+    states: Record<string, any>;
+    user: {
+        tags: Record<string, any>;
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    };
+};

package/dist/integration/implementation.d.ts

@@ -1,102 +1,25 @@
-/// <reference types="node" />
-import type { Client, Conversation, Message, User } from '@botpress/client';
 import type { Server } from 'node:http';
-import { Request, Response } from '../serve';
-import type { IntegrationContext } from './context';
-import { IntegrationLogger } from './logger';
-import { integrationHandler } from './server';
-type IntegrationProps<Configuration> = {
-    ctx: IntegrationContext<Configuration>;
-    client: Client;
-    logger: IntegrationLogger;
-};
-export type RegisterPayload = {
-    webhookUrl: string;
-};
-export type UnregisterPayload = {
-    webhookUrl: string;
-};
-export type WebhookPayload = {
-    req: Request;
-};
-export type ActionPayload<T, I> = {
-    type: T;
-    input: I;
-};
-export type EventPayload<E> = {
-    event: E;
-};
-export type CreateUserPayload = {
-    tags: Tags;
-};
-export type CreateConversationPayload = {
-    channel: string;
-    tags: Tags;
-};
-type Tags = {
-    [key: string]: string;
-};
-export type AckFunction = (props: {
-    tags: Tags;
-}) => Promise<void>;
-export type MessagePayload<P, M, C, U> = {
-    payload: P;
-    conversation: C;
-    message: M;
-    user: U;
-    type: string;
-};
-export type ActionDefinitions = {
-    [actionType: string]: {
-        input: any;
-        output: any;
-    };
-};
-export type ChannelDefinitions = {
-    [channelName: string]: MessageDefinitions;
-};
-export type EventDefinitions = {
-    [eventName: string]: any;
-};
-type MessageDefinitions = {
-    [messageType: string]: any;
-};
-type ActionFunctions<Configuration, A extends ActionDefinitions> = {
-    [actionType in keyof A]: (props: IntegrationProps<Configuration> & ActionPayload<actionType, A[actionType]['input']>) => Promise<A[actionType]['output']>;
-};
-type MessageHandlerProps = {
-    ack: AckFunction;
-};
-export type ChannelFunctions<Configuration, C extends ChannelDefinitions> = {
-    [channelName in keyof C]: {
-        messages: {
-            [messageType in keyof C[channelName]]: (props: IntegrationProps<Configuration> & MessagePayload<C[channelName][messageType], Message, Conversation, User> & MessageHandlerProps) => Promise<void>;
-        };
-    };
-};
-type BaseConfig = any;
-type BaseActions = ActionDefinitions;
-type BaseChannels = ChannelDefinitions;
-type BaseEvents = EventDefinitions;
-export type IntegrationImplementationProps<Configuration extends any = BaseConfig, Actions extends ActionDefinitions = BaseActions, Channels extends ChannelDefinitions = BaseChannels, _Events extends EventDefinitions = BaseEvents> = {
-    register: (props: IntegrationProps<Configuration> & RegisterPayload) => Promise<void>;
-    unregister: (props: IntegrationProps<Configuration> & UnregisterPayload) => Promise<void>;
-    handler: (props: IntegrationProps<Configuration> & WebhookPayload) => Promise<Response | void>;
-    createUser?: (props: IntegrationProps<Configuration> & CreateUserPayload) => Promise<Response | void>;
-    createConversation?: (props: IntegrationProps<Configuration> & CreateConversationPayload) => Promise<Response | void>;
-    actions: ActionFunctions<Configuration, Actions>;
-    channels: ChannelFunctions<Configuration, Channels>;
-};
-export declare class IntegrationImplementation<Configuration extends any = BaseConfig, Actions extends ActionDefinitions = BaseActions, Channels extends ChannelDefinitions = BaseChannels, Events extends EventDefinitions = BaseEvents> {
-    readonly props: IntegrationImplementationProps<Configuration, Actions, Channels, Events>;
-    readonly actions: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['actions'];
-    readonly channels: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['channels'];
-    readonly register: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['register'];
-    readonly unregister: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['unregister'];
-    readonly createUser: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['createUser'];
-    readonly createConversation: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['createConversation'];
-    readonly handler: ReturnType<typeof integrationHandler>;
+import { BaseIntegration } from './generic';
+import { RegisterFunction, UnregisterFunction, WebhookFunction, CreateUserFunction, CreateConversationFunction, ActionFunctions, ChannelFunctions } from './server';
+export type IntegrationImplementationProps<TIntegration extends BaseIntegration = BaseIntegration> = {
+    register: RegisterFunction<TIntegration>;
+    unregister: UnregisterFunction<TIntegration>;
+    handler: WebhookFunction<TIntegration>;
+    createUser?: CreateUserFunction<TIntegration>;
+    createConversation?: CreateConversationFunction<TIntegration>;
+    actions: ActionFunctions<TIntegration>;
+    channels: ChannelFunctions<TIntegration>;
+};
+export declare class IntegrationImplementation<TIntegration extends BaseIntegration = BaseIntegration> {
+    readonly props: IntegrationImplementationProps<TIntegration>;
+    readonly actions: IntegrationImplementationProps<TIntegration>['actions'];
+    readonly channels: IntegrationImplementationProps<TIntegration>['channels'];
+    readonly register: IntegrationImplementationProps<TIntegration>['register'];
+    readonly unregister: IntegrationImplementationProps<TIntegration>['unregister'];
+    readonly createUser: IntegrationImplementationProps<TIntegration>['createUser'];
+    readonly createConversation: IntegrationImplementationProps<TIntegration>['createConversation'];
+    readonly webhook: IntegrationImplementationProps<TIntegration>['handler'];
+    constructor(props: IntegrationImplementationProps<TIntegration>);
+    readonly handler: (req: import("../serve").Request) => Promise<void | import("../serve").Response>;
     readonly start: (port?: number) => Promise<Server>;
-    constructor(props: IntegrationImplementationProps<Configuration, Actions, Channels, Events>);
 }
-export {};

package/dist/integration/index.d.ts

@@ -1,5 +1,4 @@
-export * from './client';
 export * from './context';
 export * from './definition';
 export * from './implementation';
-export * from './server';
+export * from './client';

package/dist/integration/server.d.ts

@@ -1,12 +1,86 @@
-import { Conversation, Message, User } from '@botpress/client';
+import { type Conversation, type Message, type User } from '@botpress/client';
 import { Request, Response } from '../serve';
-import type { IntegrationImplementationProps } from './implementation';
-export declare const serveIntegration: (integration: IntegrationImplementationProps, port?: number) => Promise<void>;
-export declare const integrationHandler: (integration: IntegrationImplementationProps) => (req: Request) => Promise<Response | void>;
-export type MessageCreatedPayload = {
-    conversation: Conversation;
-    user: User;
-    message: Message;
-    payload: any;
-    type: string;
+import { Cast, Merge } from '../type-utils';
+import { IntegrationSpecificClient } from './client';
+import { ToTags } from './client/types';
+import { type IntegrationContext } from './context';
+import { BaseIntegration } from './generic';
+import { IntegrationLogger } from './logger';
+type PrefixConfig<TIntegration extends BaseIntegration> = {
+    enforcePrefix: TIntegration['name'];
 };
+type CommonArgs<TIntegration extends BaseIntegration> = {
+    ctx: IntegrationContext<TIntegration['configuration']>;
+    client: IntegrationSpecificClient<TIntegration>;
+    logger: IntegrationLogger;
+};
+type RegisterPayload = {
+    webhookUrl: string;
+};
+type RegisterArgs<TIntegration extends BaseIntegration> = CommonArgs<TIntegration> & RegisterPayload;
+type UnregisterPayload = {
+    webhookUrl: string;
+};
+type UnregisterArgs<TIntegration extends BaseIntegration> = CommonArgs<TIntegration> & UnregisterPayload;
+type WebhookPayload = {
+    req: Request;
+};
+type WebhookArgs<TIntegration extends BaseIntegration> = CommonArgs<TIntegration> & WebhookPayload;
+type ActionPayload<T extends string, I> = {
+    type: T;
+    input: I;
+};
+type ActionArgs<TIntegration extends BaseIntegration, T extends string, I> = CommonArgs<TIntegration> & ActionPayload<T, I>;
+type CreateUserPayload<TIntegration extends BaseIntegration> = {
+    tags: ToTags<keyof TIntegration['user']['tags'], PrefixConfig<TIntegration>>;
+};
+type CreateUserArgs<TIntegration extends BaseIntegration> = CommonArgs<TIntegration> & CreateUserPayload<TIntegration>;
+type CreateConversationPayload<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'] = keyof TIntegration['channels']> = {
+    channel: TChannel;
+    tags: ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags'], PrefixConfig<TIntegration>>;
+};
+type CreateConversationArgs<TIntegration extends BaseIntegration> = CommonArgs<TIntegration> & CreateConversationPayload<TIntegration>;
+type MessagePayload<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']> = {
+    type: TMessage;
+    payload: TIntegration['channels'][TChannel]['messages'][TMessage];
+    conversation: Merge<Conversation, {
+        tags: ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags'], PrefixConfig<TIntegration>>;
+    }>;
+    message: Merge<Message, {
+        tags: ToTags<keyof TIntegration['channels'][TChannel]['message']['tags'], PrefixConfig<TIntegration>>;
+    }>;
+    user: Merge<User, {
+        tags: ToTags<keyof TIntegration['user']['tags'], PrefixConfig<TIntegration>>;
+    }>;
+};
+type MessageArgs<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']> = CommonArgs<TIntegration> & MessagePayload<TIntegration, TChannel, TMessage> & {
+    ack: (props: {
+        tags: ToTags<keyof TIntegration['channels'][TChannel]['message']['tags'], PrefixConfig<TIntegration>>;
+    }) => Promise<void>;
+};
+export type RegisterFunction<TIntegration extends BaseIntegration> = (props: RegisterArgs<TIntegration>) => Promise<void>;
+export type UnregisterFunction<TIntegration extends BaseIntegration> = (props: UnregisterArgs<TIntegration>) => Promise<void>;
+export type WebhookFunction<TIntegration extends BaseIntegration> = (props: WebhookArgs<TIntegration>) => Promise<Response | void>;
+export type ActionFunctions<TIntegration extends BaseIntegration> = {
+    [ActionType in keyof TIntegration['actions']]: (props: ActionArgs<TIntegration, Cast<ActionType, string>, TIntegration['actions'][ActionType]['input']>) => Promise<TIntegration['actions'][ActionType]['output']>;
+};
+export type CreateUserFunction<TIntegration extends BaseIntegration> = (props: CreateUserArgs<TIntegration>) => Promise<Response | void>;
+export type CreateConversationFunction<TIntegration extends BaseIntegration> = (props: CreateConversationArgs<TIntegration>) => Promise<Response | void>;
+export type ChannelFunctions<TIntegration extends BaseIntegration> = {
+    [ChannelName in keyof TIntegration['channels']]: {
+        messages: {
+            [MessageType in keyof TIntegration['channels'][ChannelName]['messages']]: (props: CommonArgs<TIntegration> & MessageArgs<TIntegration, ChannelName, MessageType>) => Promise<void>;
+        };
+    };
+};
+export type IntegrationHandlers<TIntegration extends BaseIntegration> = {
+    register: RegisterFunction<TIntegration>;
+    unregister: UnregisterFunction<TIntegration>;
+    webhook: WebhookFunction<TIntegration>;
+    createUser?: CreateUserFunction<TIntegration>;
+    createConversation?: CreateConversationFunction<TIntegration>;
+    actions: ActionFunctions<TIntegration>;
+    channels: ChannelFunctions<TIntegration>;
+};
+export declare const integrationHandler: <TIntegration extends BaseIntegration>(instance: IntegrationHandlers<TIntegration>) => (req: Request) => Promise<Response | void>;
+export {};

package/dist/message.d.ts

@@ -87,51 +87,51 @@ export declare const defaults: {
                     value: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
                     value: string;
-                    action: "url" | "postback" | "say";
+                    action: "postback" | "url" | "say";
                     label: string;
                 }, {
                     value: string;
-                    action: "url" | "postback" | "say";
+                    action: "postback" | "url" | "say";
                     label: string;
                 }>, "many">;
             }, "strip", z.ZodTypeAny, {
+                title: string;
                 actions: {
                     value: string;
-                    action: "url" | "postback" | "say";
+                    action: "postback" | "url" | "say";
                     label: string;
                 }[];
-                title: string;
                 subtitle?: string | undefined;
                 imageUrl?: string | undefined;
             }, {
+                title: string;
                 actions: {
                     value: string;
-                    action: "url" | "postback" | "say";
+                    action: "postback" | "url" | "say";
                     label: string;
                 }[];
-                title: string;
                 subtitle?: string | undefined;
                 imageUrl?: string | undefined;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
             items: {
+                title: string;
                 actions: {
                     value: string;
-                    action: "url" | "postback" | "say";
+                    action: "postback" | "url" | "say";
                     label: string;
                 }[];
-                title: string;
                 subtitle?: string | undefined;
                 imageUrl?: string | undefined;
             }[];
         }, {
             items: {
+                title: string;
                 actions: {
                     value: string;
-                    action: "url" | "postback" | "say";
+                    action: "postback" | "url" | "say";
                     label: string;
                 }[];
-                title: string;
                 subtitle?: string | undefined;
                 imageUrl?: string | undefined;
             }[];
@@ -148,29 +148,29 @@ export declare const defaults: {
                 value: z.ZodString;
             }, "strip", z.ZodTypeAny, {
                 value: string;
-                action: "url" | "postback" | "say";
+                action: "postback" | "url" | "say";
                 label: string;
             }, {
                 value: string;
-                action: "url" | "postback" | "say";
+                action: "postback" | "url" | "say";
                 label: string;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
+            title: string;
             actions: {
                 value: string;
-                action: "url" | "postback" | "say";
+                action: "postback" | "url" | "say";
                 label: string;
             }[];
-            title: string;
             subtitle?: string | undefined;
             imageUrl?: string | undefined;
         }, {
+            title: string;
             actions: {
                 value: string;
-                action: "url" | "postback" | "say";
+                action: "postback" | "url" | "say";
                 label: string;
             }[];
-            title: string;
             subtitle?: string | undefined;
             imageUrl?: string | undefined;
         }>;
@@ -189,17 +189,17 @@ export declare const defaults: {
                 label: string;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
+            text: string;
             options: {
                 value: string;
                 label: string;
             }[];
-            text: string;
         }, {
+            text: string;
             options: {
                 value: string;
                 label: string;
             }[];
-            text: string;
         }>;
     };
     readonly choice: {
@@ -216,17 +216,17 @@ export declare const defaults: {
                 label: string;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
+            text: string;
             options: {
                 value: string;
                 label: string;
             }[];
-            text: string;
         }, {
+            text: string;
             options: {
                 value: string;
                 label: string;
             }[];
-            text: string;
         }>;
     };
 };

package/dist/schema.d.ts

@@ -0,0 +1,15 @@
+import type { z } from 'zod';
+import { AnyZodObject } from './type-utils';
+type SchemaOptions<T> = {
+    title: string;
+    examples: T[];
+};
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+type UiDefinition<TSchema extends AnyZodObject = AnyZodObject> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
+    [K in keyof z.infer<TSchema>]: Partial<SchemaOptions<z.infer<TSchema>[K]>>;
+};
+export type SchemaDefinition<TSchema extends AnyZodObject = AnyZodObject> = {
+    schema: TSchema;
+    ui?: Partial<UiDefinition<TSchema>>;
+};
+export {};

package/dist/serve.d.ts

@@ -17,4 +17,5 @@ export type Response = {
     status?: number;
 };
 export type Handler = (req: Request) => Promise<Response | void>;
+export declare function parseBody<T>(req: Request): T;
 export declare function serve(handler: Handler, port?: number, callback?: (port: number) => void): Promise<Server>;

package/dist/type-utils.d.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+export type AnyZodObject = z.ZodObject<any>;
+export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B;
+export type Cast<T, U> = T extends U ? T : U;
+export type Iof<T extends object> = {
+    [K in keyof T]: T[K];
+};
+export type Join<S extends (string | number | symbol)[]> = S extends [infer H, ...infer T] ? `${Cast<H, string>}${Join<Cast<T, string[]>>}` : S extends [infer H] ? Cast<H, string> : '';
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Botpress SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,8 +17,7 @@
     "@botpress/client": "0.3.2",
     "axios": "0.27.2",
     "radash": "^9.5.0",
-    "zod": "^3.20.6",
-    "zod-to-json-schema": "^3.20.1"
+    "zod": "^3.20.6"
   },
   "devDependencies": {
     "@types/node": "^18.11.17",

package/dist/bot/client.d.ts

@@ -1,25 +0,0 @@
-import { Axios as AxiosInstance } from 'axios';
-import type { Merge, Except } from 'type-fest';
-import type { BotContext } from './context';
-import type { RegisterBotPayload, UnregisterBotPayload, EventReceivedBotPayload } from './implementation';
-type Props<T = any> = Merge<Except<BotContext, 'operation'>, {
-    url: string;
-    data: T;
-}>;
-/**
- * @description Meant to query your bot server directly (e.g. without going through the Botpress API)
- */
-export declare class BotClient {
-    private axios;
-    constructor(axiosInstance?: AxiosInstance);
-    register: (props: Props<RegisterBotPayload>) => Promise<any>;
-    unregister: (props: Props<UnregisterBotPayload>) => Promise<any>;
-    eventReceived: (props: Props<EventReceivedBotPayload>) => Promise<any>;
-}
-export declare function formatBotHeaders(ctx: BotContext): {
-    "x-bp-type": string;
-    "x-bot-id": string;
-    "x-bp-operation": "event_received" | "register" | "unregister" | "ping";
-    "x-bp-configuration": string;
-};
-export {};

package/dist/bot/state.d.ts

@@ -1,29 +0,0 @@
-import type { Message, Conversation, User, Event, Client, State } from '@botpress/client';
-import type { BotContext } from './context';
-export type MessageHandler = (props: {
-    client: Client;
-    message: Message;
-    conversation: Conversation;
-    user: User;
-    event: Event;
-    ctx: BotContext;
-}) => Promise<void>;
-export type EventHandler = (props: {
-    client: Client;
-    event: Event;
-    ctx: BotContext;
-}) => Promise<void>;
-export type StateExpiredHandler = (props: {
-    client: Client;
-    state: State;
-    ctx: BotContext;
-}) => Promise<void>;
-export type RegisterHandler = () => Promise<void>;
-export type UnregisterHandler = () => Promise<void>;
-export type BotState = {
-    registerHandlers: RegisterHandler[];
-    unregisterHandlers: UnregisterHandler[];
-    messageHandlers: MessageHandler[];
-    eventHandlers: EventHandler[];
-    stateExpiredHandlers: StateExpiredHandler[];
-};

package/dist/error.d.ts

@@ -1,18 +0,0 @@
-declare abstract class BaseError<Type extends string> extends Error {
-    readonly type: Type;
-    readonly message: string;
-    readonly error?: Error | undefined;
-    constructor(type: Type, message: string, error?: Error | undefined);
-    toJSON(): {
-        type: Type;
-        message: string;
-    };
-}
-type BadRequestType = 'BadRequest';
-/**
- *  A bad request error occurred
- */
-export declare class BadRequestError extends BaseError<BadRequestType> {
-    constructor(message: string, error?: Error);
-}
-export {};

package/dist/integration/client.d.ts

@@ -1,39 +0,0 @@
-import { Conversation, Message, User } from '@botpress/client';
-import { Axios as AxiosInstance } from 'axios';
-import type { IntegrationContext } from './context';
-import type { ActionPayload, CreateConversationPayload, CreateUserPayload, MessagePayload, RegisterPayload, UnregisterPayload, WebhookPayload } from './implementation';
-type Props<T = any> = {
-    url: string;
-    data: T;
-} & Omit<IntegrationContext, 'operation'>;
-/**
- * @description Meant to query your integration server directly (e.g. without going through the Botpress API)
- */
-export declare class IntegrationClient {
-    private axios;
-    constructor(axiosInstance?: AxiosInstance);
-    actionTriggered: (props: Props<ActionPayload<string, any>>) => Promise<import("axios").AxiosResponse<any, any>>;
-    messageCreated: (props: Props<MessagePayload<any, Message, Conversation, User>>) => Promise<import("axios").AxiosResponse<any, any>>;
-    register: (props: Props<RegisterPayload>) => Promise<import("axios").AxiosResponse<any, any>>;
-    unregister: (props: Props<UnregisterPayload>) => Promise<import("axios").AxiosResponse<any, any>>;
-    webhookReceived: (props: Props<WebhookPayload>) => Promise<import("axios").AxiosResponse<unknown, any>>;
-    createUser: (props: Props<CreateUserPayload>) => Promise<import("axios").AxiosResponse<{
-        user: {
-            id: User['id'];
-        };
-    }, any>>;
-    createConversation: (props: Props<CreateConversationPayload>) => Promise<import("axios").AxiosResponse<{
-        conversation: {
-            id: Conversation['id'];
-        };
-    }, any>>;
-}
-export declare function formatIntegrationHeaders(ctx: IntegrationContext): {
-    "x-bot-id": string;
-    "x-bp-operation": "register" | "unregister" | "ping" | "message_created" | "webhook_received" | "action_triggered" | "create_user" | "create_conversation";
-    "x-bot-user-id": string;
-    "x-integration-id": string;
-    "x-webhook-id": string;
-    "x-bp-configuration": string;
-};
-export {};

package/dist/integration/error.d.ts

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-export declare const runtimeErrorSchema: z.ZodObject<{
-    code: z.ZodLiteral<400>;
-    type: z.ZodLiteral<"Runtime">;
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    code: 400;
-    message: string;
-    type: "Runtime";
-}, {
-    code: 400;
-    message: string;
-    type: "Runtime";
-}>;

package/dist/integration/schema.d.ts

@@ -1,16 +0,0 @@
-import type { z } from 'zod';
-import zodToJsonSchema from 'zod-to-json-schema';
-export type SchemaOptions<T> = {
-    title: string;
-    examples: T[];
-};
-type IsEmptyObject<T> = keyof T extends never ? true : false;
-export type UiDefinition<TSchema extends z.ZodObject<any>> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
-    [K in keyof z.infer<TSchema>]: Partial<SchemaOptions<z.infer<TSchema>[K]>>;
-};
-export type SchemaDefinition<TSchema extends z.ZodObject<any>> = {
-    schema: TSchema;
-    ui?: Partial<UiDefinition<TSchema>>;
-};
-export declare function schemaDefinitionToJsonSchema(definition: SchemaDefinition<z.ZodObject<any>>): ReturnType<typeof zodToJsonSchema>;
-export {};