@botpress/sdk 2.0.4 → 2.1.0

package/dist/schema.d.ts

@@ -0,0 +1,18 @@
+import * as z from './zui';
+type SchemaOptions<T> = {
+    title: string;
+    examples: T[];
+};
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+type UiDefinition<TSchema extends z.ZuiObjectSchema = z.ZuiObjectSchema> = 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.ZuiObjectSchema = z.ZuiObjectSchema> = {
+    schema: TSchema;
+    /**
+     * @deprecated
+     * Use zod.Schema.displayAs() instead
+     **/
+    ui?: Partial<UiDefinition<TSchema>>;
+};
+export {};

package/dist/serve.d.ts

@@ -0,0 +1,20 @@
+import { Server } from 'node:http';
+export type Request = {
+    body?: string;
+    path: string;
+    query: string;
+    method: string;
+    headers: {
+        [key: string]: string | undefined;
+    };
+};
+export type Response = {
+    body?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    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/utils/array-utils.d.ts

@@ -0,0 +1 @@
+export declare const safePush: <T>(arr: T[] | undefined, ...values: T[]) => T[];

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * as records from './record-utils';
+export * as arrays from './array-utils';
+export * as types from './type-utils';

package/dist/utils/record-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const pairs: <K extends string, V>(obj: Record<K, V>) => [K, V][];
+export declare const values: <K extends string, V>(obj: Record<K, V>) => V[];
+export declare const mapValues: <K extends string, V, R>(obj: Record<K, V>, fn: (value: V, key: K) => R) => Record<K, R>;

package/dist/utils/type-utils.d.ts

@@ -0,0 +1,33 @@
+export type ValueOf<T> = T[keyof T];
+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 SafeCast<T, U> = [T] extends [never] ? U : Cast<T, U>;
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type Default<T, U> = undefined extends T ? U : T;
+export type IsExtend<X, Y> = X extends Y ? true : false;
+export type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false;
+export type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>;
+export type AssertExtends<_A extends B, B> = true;
+export type AssertTrue<_T extends true> = true;
+export type AssertAll<_T extends true[]> = true;
+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 Split<S extends string | number | symbol, D extends string> = S extends `${infer H}${D}${infer T}` ? [H, ...Split<Cast<T, string>, D>] : [S];
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * removes string index signature from Record
+ */
+export type ToSealedRecord<R extends Record<string, any>> = {
+    [K in keyof R as string extends K ? never : K]: R[K];
+};
+type NormalizeObject<T extends object> = T extends infer O ? {
+    [K in keyof O]: Normalize<O[K]>;
+} : never;
+export type Normalize<T> = T extends (...args: infer A) => infer R ? (...args: Normalize<A>) => Normalize<R> : T extends Array<infer E> ? Array<Normalize<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<Normalize<E>> : T extends Promise<infer R> ? Promise<Normalize<R>> : T extends Buffer ? Buffer : T extends object ? NormalizeObject<T> : T;
+type DeepPartialObject<T extends object> = T extends infer O ? {
+    [K in keyof O]?: DeepPartial<O[K]>;
+} : never;
+export type DeepPartial<T> = T extends (...args: infer A) => infer R ? (...args: DeepPartial<A>) => DeepPartial<R> : T extends Array<infer E> ? Array<DeepPartial<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<DeepPartial<E>> : T extends Promise<infer R> ? Promise<DeepPartial<R>> : T extends Buffer ? Buffer : T extends object ? DeepPartialObject<T> : T;
+export {};

package/dist/utils/type-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/zui.d.ts

@@ -0,0 +1,5 @@
+import { z } from '@bpinternal/zui';
+export * from '@bpinternal/zui';
+export type GenericZuiSchema<A extends Record<string, z.ZodTypeAny> = Record<string, z.ZodTypeAny>, R extends z.ZodTypeAny = z.ZodTypeAny> = (typeArguments: A) => R;
+export type ZuiObjectSchema = z.ZodObject | z.ZodRecord;
+export default z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Botpress SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,7 +14,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.38.0",
+    "@botpress/client": "0.38.1",
     "@bpinternal/zui": "0.12.0"
   },
   "devDependencies": {