@tailorkit/app 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/index.js

@@ -1,73 +1,82 @@
-// src/index.ts
-import { createContext, h, render } from "preact";
-import { useContext } from "preact/hooks";
-var preactVersion = "10.29.8";
-var createView = (path, options) => {
-  const Context = createContext(null);
-  const View = (props) => {
-    if (props.status === "loading") {
-      return options.loading ? h(options.loading, {}) : null;
-    }
-    if (props.status === "error") {
-      return options.error ? h(options.error, {}) : null;
-    }
-    return h(
-      Context.Provider,
-      { value: props.context },
-      h(options.component, {})
-    );
-  };
-  return {
-    component: View,
-    path,
-    useContext: () => {
-      const context = useContext(Context);
-      if (context === null) {
-        throw new Error(`View context is only available while rendering "${path}".`);
-      }
-      return context;
-    }
-  };
-};
-var defineClient = (client) => ({
-  ...client,
-  $meta: { preactVersion },
-  $runtime: { h, render }
-});
-var componentTagPrefix = "tailorkit-";
-var toComponentTagName = (name) => `${componentTagPrefix}${name.replaceAll(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[\s_]+/gu, "-").toLowerCase()}`;
-var toCallbackEventName = (name) => `tailorkitcallback${name.replaceAll(/[^A-Za-z0-9_$]/gu, "").toLowerCase()}`;
-var toEventProp = (event) => `on${event}`;
-var createRemoteComponent = (name, options = {}) => {
-  const tagName = toComponentTagName(name);
-  const callbacks = options.callbacks ?? {};
-  return function RemoteComponent({ children, ...props }) {
-    const nextProps = { ...props };
-    const callbackMap = {};
-    for (const [key, inputCount] of Object.entries(callbacks)) {
-      const callback = nextProps[key];
-      Reflect.deleteProperty(nextProps, key);
-      if (typeof callback !== "function") {
-        continue;
-      }
-      const eventName = toCallbackEventName(key);
-      callbackMap[eventName] = { callback: key, inputCount };
-      nextProps[toEventProp(eventName)] = (event) => {
-        callback(...(event.detail ?? []).slice(0, inputCount));
-      };
-    }
-    const serializedProps = Object.fromEntries(
-      Object.entries(nextProps).filter(([, value]) => typeof value !== "function")
-    );
-    nextProps["data-tailorkit-props"] = JSON.stringify(serializedProps);
-    if (Object.keys(callbackMap).length > 0) {
-      nextProps["data-tailorkit-callbacks"] = JSON.stringify(callbackMap);
-    }
-    return h(tagName, nextProps, options.children ? children : void 0);
-  };
-};
+import {
+  ClientProvider,
+  createApi,
+  createClient,
+  createRemoteComponent,
+  createSessionProvider,
+  createView,
+  defineClient,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-3XA36UOQ.js";
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  tk
+} from "./chunk-46CTW3XJ.js";
+import {
+  AppError,
+  appError
+} from "./chunk-IJBQ77AH.js";
 export {
+  AppError,
+  ClientProvider,
+  action,
+  and,
+  appError,
+  asc,
+  boolean,
+  count,
+  createApi,
+  createClient,
   createRemoteComponent,
+  createSessionProvider,
   createView,
-  defineClient
+  defineClient,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  reference,
+  table,
+  text,
+  tk,
+  useAction,
+  useMutation,
+  useQuery
 };

package/dist/preact.d.ts

@@ -0,0 +1,52 @@
+import type { ComponentChildren } from "preact";
+import type { Client } from "./client/connection";
+import type { Reference } from "./client/reference";
+import { QueryStore } from "./client/query-store";
+import type { QueryState } from "./client/query-store";
+import type { AppError } from "./errors";
+export interface ClientProviderProps {
+    children?: ComponentChildren;
+    /** Supply a client for custom transport configuration. Caller-owned clients are not closed. */
+    client?: Client;
+    onError?: (error: AppError) => void;
+}
+export declare function ClientProvider({ children, client, onError }: ClientProviderProps): import("preact").VNode<import("preact").Attributes & {
+    value: QueryStore | null;
+    children?: ComponentChildren;
+}>;
+export interface QueryOptions {
+    enabled?: boolean;
+}
+type InputArguments<I> = undefined extends I ? [input?: I] : [input: I];
+type QueryArguments<I> = undefined extends I ? [input?: I, options?: QueryOptions] : [input: I, options?: QueryOptions];
+export interface QueryResult<T> extends QueryState<T> {
+    isPending: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+}
+export declare function useQuery<I, O>(ref: Reference<"query", I, O>, ...[input, options]: QueryArguments<NoInfer<I>>): QueryResult<O>;
+export interface CallOptions<I, O> {
+    onSuccess?: (data: O, input: I) => void;
+    onError?: (error: AppError, input: I) => void;
+}
+export interface CallState<T> {
+    data: T | undefined;
+    error: AppError | null;
+    status: "idle" | "pending" | "success" | "error";
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    reset: () => void;
+}
+export interface MutationResult<I, O> extends CallState<O> {
+    mutate: (...args: InputArguments<I>) => void;
+    mutateAsync: (...args: InputArguments<I>) => Promise<O>;
+}
+export declare function useMutation<I, O>(ref: Reference<"mutation", I, O>, options?: CallOptions<I, O>): MutationResult<I, O>;
+export interface ActionResult<I, O> extends CallState<O> {
+    execute: (...args: InputArguments<I>) => void;
+    executeAsync: (...args: InputArguments<I>) => Promise<O>;
+}
+export declare function useAction<I, O>(ref: Reference<"action", I, O>, options?: CallOptions<I, O>): ActionResult<I, O>;
+export {};

package/dist/protocol.d.ts

@@ -0,0 +1,74 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import { z } from "zod";
+export declare const invocationSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type Invocation = z.infer<typeof invocationSchema>;
+export type MutationInvocation = Invocation & {
+    requestId: string;
+};
+/** Public wire contract; implementations and clients both depend on this definition. */
+export declare const appContract: {
+    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+    mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        requestId: z.ZodUUID;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+    subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+};
+export type PlatformClient = ContractRouterClient<typeof appContract>;
+export type SubscriptionClient = Pick<PlatformClient, "subscribe">;
+/** Drizzle-generated SQL exported by application bundles. */
+export interface AppMigration {
+    id: string;
+    hash: string;
+    statements: string[];
+}

package/dist/protocol.js

@@ -0,0 +1,28 @@
+// src/protocol.ts
+import { oc, type } from "@orpc/contract";
+import { z } from "zod";
+var invocationSchema = z.strictObject({
+  name: z.string().max(512).regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}(?:\.[a-zA-Z][a-zA-Z0-9_]{0,63})*$/u),
+  args: z.unknown().optional()
+});
+var procedure = oc.errors({
+  BAD_REQUEST: {},
+  UNAUTHORIZED: {},
+  FORBIDDEN: {},
+  NOT_FOUND: {},
+  CONFLICT: {},
+  INCOMPATIBLE_VERSION: {},
+  UNAVAILABLE: {},
+  INTERNAL_SERVER_ERROR: {}
+});
+var appContract = {
+  queries: procedure.input(invocationSchema).output(type()),
+  mutations: procedure.input(invocationSchema.extend({ requestId: z.uuid() })).output(type()),
+  actions: procedure.input(invocationSchema).output(type()),
+  // A pass-through type schema preserves the private hibernation iterator instance.
+  subscribe: procedure.input(invocationSchema).output(type())
+};
+export {
+  appContract,
+  invocationSchema
+};

package/dist/server/builder.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { MutationDatabase, QueryDatabase } from "../database/types";
+import type { ActionContext, FunctionKind, Functions, Identity } from "./functions";
+type HandlerContext<K extends FunctionKind, A extends z.ZodType, F extends Functions> = {
+    input: z.output<A>;
+} & (K extends "action" ? ActionContext<F> : {
+    db: K extends "query" ? QueryDatabase : MutationDatabase;
+    identity: Identity;
+});
+type OutputInput<R> = R extends z.ZodType ? z.input<R> : unknown;
+type HandlerOutput<K, O> = K extends "action" ? O | Promise<O> : O & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+type BuiltFunction<K extends FunctionKind, A extends z.ZodType, R, O, F extends Functions> = {
+    readonly kind: K;
+    readonly args: A;
+    readonly handler: (context: Omit<HandlerContext<K, A, F>, "input"> & {
+        args: z.output<A>;
+    }) => HandlerOutput<K, O>;
+} & (R extends z.ZodType ? {
+    readonly result: R;
+} : unknown) & (K extends "action" ? {
+    readonly functions: F;
+} : unknown);
+/** Immutable builders preserve the validated input and wire output types at every step. */
+declare class FunctionBuilder<K extends FunctionKind, A extends z.ZodType, R extends z.ZodType | undefined = undefined, F extends Functions = Record<never, never>> {
+    private readonly kind;
+    private readonly args;
+    private readonly result;
+    private readonly calls;
+    constructor(kind: K, args: A, result: R, calls: F);
+    input<S extends z.ZodType>(schema: S): FunctionBuilder<K, S, R, F>;
+    output<S extends z.ZodType>(schema: S): FunctionBuilder<K, A, S, F>;
+    functions<const G extends Functions>(this: FunctionBuilder<"action", A, R, F>, functions: G): FunctionBuilder<"action", A, R, G>;
+    handler<O extends OutputInput<R>>(handler: (context: HandlerContext<K, A, F>) => HandlerOutput<K, O>): BuiltFunction<K, A, R, O, F>;
+}
+export declare const tk: Readonly<{
+    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}>;
+    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}>;
+    action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}>;
+}>;
+export {};

package/dist/server/bundle.d.ts

@@ -0,0 +1,17 @@
+import type { AppDefinition } from "./functions";
+import type { AppMigration } from "../protocol";
+/** Interface between an uploaded application module and the server runtime. */
+export interface RuntimeManifest {
+    apiVersion: number;
+    requires: readonly string[];
+}
+export interface ApplicationModule {
+    default: AppDefinition;
+    migrations: readonly AppMigration[];
+    runtimeManifest: RuntimeManifest;
+}
+/** Emitted by this SDK's builder; breaking interface changes increment apiVersion. */
+export declare const runtimeManifest: {
+    readonly apiVersion: 1;
+    readonly requires: readonly ["database", "actions"];
+};

package/dist/server/functions.d.ts

@@ -0,0 +1,90 @@
+import type { z } from "zod";
+import type { QueryDatabase, MutationDatabase } from "../database/types";
+export interface Identity {
+    readonly userId: string;
+    readonly projectId: string;
+    readonly appId: string;
+    readonly installationId: string;
+    readonly deploymentId: string;
+    readonly expiresAt: number;
+}
+export type FunctionKind = "query" | "mutation" | "action";
+export type FunctionResult<D> = D extends {
+    result: infer R extends z.ZodType;
+} ? z.output<R> : D extends {
+    handler: (context: never) => infer O;
+} ? Awaited<O> : never;
+type FunctionCalls<F, K extends "query" | "mutation"> = {
+    readonly [N in keyof F as F[N] extends {
+        kind: FunctionKind;
+    } ? (F[N] extends {
+        kind: K;
+    } ? N : never) : N]: F[N] extends {
+        args: infer A extends z.ZodType;
+        handler: (context: never) => unknown;
+    } ? K extends "mutation" ? (...args: undefined extends z.input<A> ? [args?: z.input<A>, options?: {
+        requestId?: string;
+    }] : [args: z.input<A>, options?: {
+        requestId?: string;
+    }]) => Promise<FunctionResult<F[N]>> : (...args: undefined extends z.input<A> ? [args?: z.input<A>] : [args: z.input<A>]) => Promise<FunctionResult<F[N]>> : F[N] extends Functions ? FunctionCalls<F[N], K> : never;
+};
+export interface ActionContext<F extends Functions = Record<never, never>> {
+    readonly identity: Identity;
+    readonly signal: AbortSignal;
+    readonly queries: FunctionCalls<F, "query">;
+    readonly mutations: FunctionCalls<F, "mutation">;
+}
+export interface FunctionDefinition<K extends FunctionKind, A extends z.ZodType, O, F extends Functions = Record<never, never>> {
+    readonly kind: K;
+    readonly args: A;
+    readonly result?: z.ZodType<O>;
+    readonly handler: (context: {
+        args: z.output<A>;
+    } & (K extends "action" ? ActionContext<F> : {
+        db: K extends "query" ? QueryDatabase : MutationDatabase;
+        identity: Identity;
+    })) => K extends "action" ? O | Promise<O> : O;
+}
+export declare function query<A extends z.ZodType, O>(definition: Omit<FunctionDefinition<"query", A, O>, "kind"> & {
+    handler: FunctionDefinition<"query", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}): Readonly<{
+    args: A;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: FunctionDefinition<"query", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "query";
+}>;
+export declare function mutation<A extends z.ZodType, O>(definition: Omit<FunctionDefinition<"mutation", A, O>, "kind"> & {
+    handler: FunctionDefinition<"mutation", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}): Readonly<{
+    args: A;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: FunctionDefinition<"mutation", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "mutation";
+}>;
+export declare function action<A extends z.ZodType, O, const F extends Functions = Record<never, never>>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
+    functions?: F;
+}): Readonly<{
+    args: A;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: (context: {
+        args: z.infer<A>;
+    } & ActionContext<F>) => O | Promise<O>;
+    functions?: F;
+    kind: "action";
+}>;
+export type RegisteredFunction = {
+    kind: FunctionKind;
+    args: z.ZodType;
+    result?: z.ZodType;
+    handler: (context: never) => unknown;
+    functions?: Functions;
+};
+export interface Functions {
+    readonly [name: string]: RegisteredFunction | Functions;
+}
+export declare function isFunction(value: RegisteredFunction | Functions): value is RegisteredFunction;
+export declare function defineServer<const F extends Functions>(functions: F): Readonly<{
+    functions: F;
+}>;
+export type AppDefinition = ReturnType<typeof defineServer>;
+export {};

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+export { defineServer, query, mutation, action } from "./server/functions";
+export { tk } from "./server/builder";
+export type { QueryDatabase, MutationDatabase } from "./database/types";
+export type { Identity, FunctionDefinition, AppDefinition, ActionContext, FunctionKind, } from "./server/functions";
+export { table, text, integer, real, boolean, eq, ne, gt, gte, lt, lte, and, or, asc, desc, count, isNull, isNotNull, inArray, } from "./database/schema";
+export { AppError } from "./errors";
+export type { ErrorCode } from "./errors";
+export type { ApplicationModule, RuntimeManifest } from "./server/bundle";

package/dist/server.js

@@ -0,0 +1,56 @@
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  tk
+} from "./chunk-46CTW3XJ.js";
+import {
+  AppError
+} from "./chunk-IJBQ77AH.js";
+export {
+  AppError,
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  tk
+};

package/dist/views.d.ts

@@ -0,0 +1,89 @@
+import { h } from "preact";
+import type { ComponentChild, ComponentChildren, ComponentType, VNode } from "preact";
+export interface TailorKitViews {
+}
+export interface TailorKitSlots {
+}
+export type SlotName = keyof TailorKitSlots & string;
+export type ViewPath = Extract<keyof TailorKitViews & string, `/${string}`>;
+export type AppViewPath = ViewPath;
+export type ViewProps<TPath extends ViewPath> = TailorKitViews[TPath] extends object ? TailorKitViews[TPath] : Record<string, never>;
+export type ViewPropsForPath<TPath extends AppViewPath> = TPath extends ViewPath ? ViewProps<TPath> : never;
+export type ViewContext<TPath extends AppViewPath> = ViewPropsForPath<TPath> extends {
+    context: infer TContext;
+} ? TContext : Record<string, never>;
+export type View<TProps extends object = Record<string, never>> = (props: TProps) => ComponentChild;
+export type ViewRuntimeProps<TPath extends AppViewPath> = {
+    context: ViewContext<TPath>;
+    view: TPath;
+    status: "ready";
+} | {
+    context?: never;
+    view: TPath;
+    status: "loading";
+} | {
+    context?: never;
+    view: TPath;
+    status: "error";
+};
+export interface ViewDefinition<TPath extends AppViewPath = AppViewPath> {
+    component: View<ViewRuntimeProps<TPath>>;
+    path: TPath;
+    useContext: () => ViewContext<TPath>;
+}
+type RegisteredViews = {
+    [TPath in AppViewPath]: ViewDefinition<TPath>;
+};
+type ViewDefinitions = Partial<{
+    [P in AppViewPath]: RegisteredViews[P] | false;
+}>;
+type InvalidViewPath<TViews> = Exclude<keyof TViews & string, AppViewPath>;
+type RequireViewPaths<TViews> = InvalidViewPath<TViews> extends never ? unknown : {
+    readonly __tailorkit_error__: `View paths must be declared by the host. Invalid view: ${InvalidViewPath<TViews>}`;
+};
+type ViewKeyPathMismatch<TViews> = {
+    [TPath in keyof TViews & string]: TViews[TPath] extends false ? never : TViews[TPath] extends ViewDefinition<infer TViewPath> ? TViewPath extends TPath ? never : TPath : TPath;
+}[keyof TViews & string];
+type RequireMatchingViewKeys<TViews> = ViewKeyPathMismatch<TViews> extends never ? unknown : {
+    readonly __tailorkit_error__: `View key must match createView path. Invalid view: ${ViewKeyPathMismatch<TViews>}`;
+};
+export type SlotView<TSlot extends SlotName> = Extract<TailorKitSlots[TSlot], AppViewPath>;
+type SlotDefinitions = {
+    [V in SlotName]?: Pick<ViewDefinitions, SlotView<V>>;
+};
+type RequireSlotViews<V, S> = V extends SlotName ? Exclude<keyof S, SlotView<V>> extends never ? unknown : {
+    readonly __tailorkit_error__: "View is not supported by this slot";
+} : never;
+export interface TailorKitClient<TSlots extends SlotDefinitions = SlotDefinitions> {
+    slots: TSlots;
+    /** Wrap the app root with providers shared by every view. */
+    component?: ComponentType<{
+        children?: ComponentChildren;
+    }>;
+}
+export interface TailorKitClientMeta {
+    preactVersion: string;
+}
+export interface TailorKitClientRuntime {
+    h: typeof h;
+    render: (vnode: VNode | null, parent: Element | Document | ShadowRoot | DocumentFragment) => void;
+}
+export type TailorKitClientWithMeta<TViews extends SlotDefinitions = SlotDefinitions> = TailorKitClient<TViews> & {
+    $meta: TailorKitClientMeta;
+    $runtime: TailorKitClientRuntime;
+};
+export declare const createView: <const TPath extends AppViewPath>(path: TPath, options: {
+    component: View<Record<string, never>>;
+}) => ViewDefinition<TPath>;
+export declare const defineClient: <const TSlots extends SlotDefinitions>(client: TailorKitClient<TSlots> & {
+    slots: { [V in keyof TSlots]: TSlots[V] & RequireViewPaths<TSlots[V]> & RequireMatchingViewKeys<TSlots[V]> & RequireSlotViews<V, TSlots[V]>; };
+} & (Exclude<keyof TSlots, SlotName> extends never ? unknown : {
+    __tailorkit_error__: "Unknown slot";
+})) => TailorKitClientWithMeta<TSlots>;
+export declare const createRemoteComponent: <TProps extends object, TChildren extends boolean = false>(name: string, options?: {
+    callbacks?: Record<string, number>;
+    children?: TChildren;
+}) => View<TProps & {
+    children?: TChildren extends true ? ComponentChildren : never;
+}>;
+export {};