solid-js 1.7.8 → 1.7.10

package/types/reactive/signal.d.ts

@@ -33,57 +33,60 @@ export declare let Transition: TransitionState | null;
 declare let ExternalSourceFactory: ExternalSourceFactory | null;
 /** Object storing callbacks for debugging during development */
 export declare const DevHooks: {
-    afterUpdate: (() => void) | null;
-    afterCreateOwner: ((owner: Owner) => void) | null;
+  afterUpdate: (() => void) | null;
+  afterCreateOwner: ((owner: Owner) => void) | null;
 };
 export type ComputationState = 0 | 1 | 2;
 export interface SourceMapValue {
-    value: unknown;
-    name?: string;
-    graph?: Owner;
+  value: unknown;
+  name?: string;
+  graph?: Owner;
 }
 export interface SignalState<T> extends SourceMapValue {
-    value: T;
-    observers: Computation<any>[] | null;
-    observerSlots: number[] | null;
-    tValue?: T;
-    comparator?: (prev: T, next: T) => boolean;
+  value: T;
+  observers: Computation<any>[] | null;
+  observerSlots: number[] | null;
+  tValue?: T;
+  comparator?: (prev: T, next: T) => boolean;
 }
 export interface Owner {
-    owned: Computation<any>[] | null;
-    cleanups: (() => void)[] | null;
-    owner: Owner | null;
-    context: any | null;
-    sourceMap?: SourceMapValue[];
-    name?: string;
+  owned: Computation<any>[] | null;
+  cleanups: (() => void)[] | null;
+  owner: Owner | null;
+  context: any | null;
+  sourceMap?: SourceMapValue[];
+  name?: string;
 }
 export interface Computation<Init, Next extends Init = Init> extends Owner {
-    fn: EffectFunction<Init, Next>;
-    state: ComputationState;
-    tState?: ComputationState;
-    sources: SignalState<Next>[] | null;
-    sourceSlots: number[] | null;
-    value?: Init;
-    updatedAt: number | null;
-    pure: boolean;
-    user?: boolean;
-    suspense?: SuspenseContextType;
+  fn: EffectFunction<Init, Next>;
+  state: ComputationState;
+  tState?: ComputationState;
+  sources: SignalState<Next>[] | null;
+  sourceSlots: number[] | null;
+  value?: Init;
+  updatedAt: number | null;
+  pure: boolean;
+  user?: boolean;
+  suspense?: SuspenseContextType;
 }
 export interface TransitionState {
-    sources: Set<SignalState<any>>;
-    effects: Computation<any>[];
-    promises: Set<Promise<any>>;
-    disposed: Set<Computation<any>>;
-    queue: Set<Computation<any>>;
-    scheduler?: (fn: () => void) => unknown;
-    running: boolean;
-    done?: Promise<void>;
-    resolve?: () => void;
+  sources: Set<SignalState<any>>;
+  effects: Computation<any>[];
+  promises: Set<Promise<any>>;
+  disposed: Set<Computation<any>>;
+  queue: Set<Computation<any>>;
+  scheduler?: (fn: () => void) => unknown;
+  running: boolean;
+  done?: Promise<void>;
+  resolve?: () => void;
 }
-type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(fn: EffectFunction<Prev, Next>, trigger: () => void) => ExternalSource;
+type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(
+  fn: EffectFunction<Prev, Next>,
+  trigger: () => void
+) => ExternalSource;
 export interface ExternalSource {
-    track: EffectFunction<any, any>;
-    dispose: () => void;
+  track: EffectFunction<any, any>;
+  dispose: () => void;
 }
 export type RootFunction<T> = (dispose: () => void) => T;
 /**
@@ -97,10 +100,17 @@ export type RootFunction<T> = (dispose: () => void) => T;
  */
 export declare function createRoot<T>(fn: RootFunction<T>, detachedOwner?: typeof Owner): T;
 export type Accessor<T> = () => T;
-export type Setter<T> = (undefined extends T ? () => undefined : {}) & (<U extends T>(value: (prev: T) => U) => U) & (<U extends T>(value: Exclude<U, Function>) => U) & (<U extends T>(value: Exclude<U, Function> | ((prev: T) => U)) => U);
+export type Setter<in out T> = {
+  <U extends T>(...args: undefined extends T ? [] : [value: (prev: T) => U]): undefined extends T
+    ? undefined
+    : U;
+  <U extends T>(value: (prev: T) => U): U;
+  <U extends T>(value: Exclude<U, Function>): U;
+  <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
+};
 export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
 export interface SignalOptions<T> extends MemoOptions<T> {
-    internal?: boolean;
+  internal?: boolean;
 }
 /**
  * Creates a simple reactive state with a getter and setter
@@ -128,11 +138,10 @@ export interface SignalOptions<T> extends MemoOptions<T> {
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
 export interface BaseOptions {
-    name?: string;
+  name?: string;
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
-export interface EffectOptions extends BaseOptions {
-}
+export interface EffectOptions extends BaseOptions {}
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
 /**
  * Creates a reactive computation that runs immediately before render, mainly used to write to other reactive primitives
@@ -149,8 +158,14 @@ export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
  *
  * @description https://www.solidjs.com/docs/latest/api#createcomputed
  */
-export declare function createComputed<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
-export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createComputed<Next>(
+  fn: EffectFunction<undefined | NoInfer<Next>, Next>
+): void;
+export declare function createComputed<Next, Init = Next>(
+  fn: EffectFunction<Init | Next, Next>,
+  value: Init,
+  options?: EffectOptions
+): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
  * ```typescript
@@ -166,8 +181,14 @@ export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Ini
  *
  * @description https://www.solidjs.com/docs/latest/api#createrendereffect
  */
-export declare function createRenderEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
-export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<Next>(
+  fn: EffectFunction<undefined | NoInfer<Next>, Next>
+): void;
+export declare function createRenderEffect<Next, Init = Next>(
+  fn: EffectFunction<Init | Next, Next>,
+  value: Init,
+  options?: EffectOptions
+): void;
 /**
  * Creates a reactive computation that runs after the render phase
  * ```typescript
@@ -183,10 +204,16 @@ export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction
  *
  * @description https://www.solidjs.com/docs/latest/api#createeffect
  */
-export declare function createEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
-export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions & {
+export declare function createEffect<Next>(
+  fn: EffectFunction<undefined | NoInfer<Next>, Next>
+): void;
+export declare function createEffect<Next, Init = Next>(
+  fn: EffectFunction<Init | Next, Next>,
+  value: Init,
+  options?: EffectOptions & {
     render?: boolean;
-}): void;
+  }
+): void;
 /**
  * Creates a reactive computation that runs after the render phase with flexible tracking
  * ```typescript
@@ -200,13 +227,16 @@ export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init
  *
  * @description https://www.solidjs.com/docs/latest/api#createreaction
  */
-export declare function createReaction(onInvalidate: () => void, options?: EffectOptions): (tracking: () => void) => void;
+export declare function createReaction(
+  onInvalidate: () => void,
+  options?: EffectOptions
+): (tracking: () => void) => void;
 export interface Memo<Prev, Next = Prev> extends SignalState<Next>, Computation<Next> {
-    value: Next;
-    tOwned?: Computation<Prev | Next, Next>[];
+  value: Next;
+  tOwned?: Computation<Prev | Next, Next>[];
 }
 export interface MemoOptions<T> extends EffectOptions {
-    equals?: false | ((prev: T, next: T) => boolean);
+  equals?: false | ((prev: T, next: T) => boolean);
 }
 /**
  * Creates a readonly derived reactive memoized signal
@@ -223,72 +253,84 @@ export interface MemoOptions<T> extends EffectOptions {
  *
  * @description https://www.solidjs.com/docs/latest/api#creatememo
  */
-export declare function createMemo<Next extends Prev, Prev = Next>(fn: EffectFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(fn: EffectFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Prev = Next>(
+  fn: EffectFunction<undefined | NoInfer<Prev>, Next>
+): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(
+  fn: EffectFunction<Init | Prev, Next>,
+  value: Init,
+  options?: MemoOptions<Next>
+): Accessor<Next>;
 interface Unresolved {
-    state: "unresolved";
-    loading: false;
-    error: undefined;
-    latest: undefined;
-    (): undefined;
+  state: "unresolved";
+  loading: false;
+  error: undefined;
+  latest: undefined;
+  (): undefined;
 }
 interface Pending {
-    state: "pending";
-    loading: true;
-    error: undefined;
-    latest: undefined;
-    (): undefined;
+  state: "pending";
+  loading: true;
+  error: undefined;
+  latest: undefined;
+  (): undefined;
 }
 interface Ready<T> {
-    state: "ready";
-    loading: false;
-    error: undefined;
-    latest: T;
-    (): T;
+  state: "ready";
+  loading: false;
+  error: undefined;
+  latest: T;
+  (): T;
 }
 interface Refreshing<T> {
-    state: "refreshing";
-    loading: true;
-    error: undefined;
-    latest: T;
-    (): T;
+  state: "refreshing";
+  loading: true;
+  error: undefined;
+  latest: T;
+  (): T;
 }
 interface Errored {
-    state: "errored";
-    loading: false;
-    error: any;
-    latest: never;
-    (): never;
+  state: "errored";
+  loading: false;
+  error: any;
+  latest: never;
+  (): never;
 }
 export type Resource<T> = Unresolved | Pending | Ready<T> | Refreshing<T> | Errored;
 export type InitializedResource<T> = Ready<T> | Refreshing<T> | Errored;
 export type ResourceActions<T, R = unknown> = {
-    mutate: Setter<T>;
-    refetch: (info?: R) => T | Promise<T> | undefined | null;
+  mutate: Setter<T>;
+  refetch: (info?: R) => T | Promise<T> | undefined | null;
 };
 export type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
-export type ResourceFetcher<S, T, R = unknown> = (k: S, info: ResourceFetcherInfo<T, R>) => T | Promise<T>;
+export type ResourceFetcher<S, T, R = unknown> = (
+  k: S,
+  info: ResourceFetcherInfo<T, R>
+) => T | Promise<T>;
 export type ResourceFetcherInfo<T, R = unknown> = {
-    value: T | undefined;
-    refetching: R | boolean;
+  value: T | undefined;
+  refetching: R | boolean;
 };
 export type ResourceOptions<T, S = unknown> = {
-    initialValue?: T;
-    name?: string;
-    deferStream?: boolean;
-    ssrLoadFrom?: "initial" | "server";
-    storage?: (init: T | undefined) => [Accessor<T | undefined>, Setter<T | undefined>];
-    onHydrated?: (k: S | undefined, info: {
-        value: T | undefined;
-    }) => void;
+  initialValue?: T;
+  name?: string;
+  deferStream?: boolean;
+  ssrLoadFrom?: "initial" | "server";
+  storage?: (init: T | undefined) => [Accessor<T | undefined>, Setter<T | undefined>];
+  onHydrated?: (
+    k: S | undefined,
+    info: {
+      value: T | undefined;
+    }
+  ) => void;
 };
 export type InitializedResourceOptions<T, S = unknown> = ResourceOptions<T, S> & {
-    initialValue: T;
+  initialValue: T;
 };
 export type ResourceReturn<T, R = unknown> = [Resource<T>, ResourceActions<T | undefined, R>];
 export type InitializedResourceReturn<T, R = unknown> = [
-    InitializedResource<T>,
-    ResourceActions<T, R>
+  InitializedResource<T>,
+  ResourceActions<T, R>
 ];
 /**
  * Creates a resource that wraps a repeated promise in a reactive pattern:
@@ -318,14 +360,28 @@ export type InitializedResourceReturn<T, R = unknown> = [
  *
  * @description https://www.solidjs.com/docs/latest/api#createresource
  */
-export declare function createResource<T, R = unknown>(fetcher: ResourceFetcher<true, T, R>, options: InitializedResourceOptions<NoInfer<T>, true>): InitializedResourceReturn<T, R>;
-export declare function createResource<T, R = unknown>(fetcher: ResourceFetcher<true, T, R>, options?: ResourceOptions<NoInfer<T>, true>): ResourceReturn<T, R>;
-export declare function createResource<T, S, R = unknown>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T, R>, options: InitializedResourceOptions<NoInfer<T>, S>): InitializedResourceReturn<T, R>;
-export declare function createResource<T, S, R = unknown>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T, R>, options?: ResourceOptions<NoInfer<T>, S>): ResourceReturn<T, R>;
+export declare function createResource<T, R = unknown>(
+  fetcher: ResourceFetcher<true, T, R>,
+  options: InitializedResourceOptions<NoInfer<T>, true>
+): InitializedResourceReturn<T, R>;
+export declare function createResource<T, R = unknown>(
+  fetcher: ResourceFetcher<true, T, R>,
+  options?: ResourceOptions<NoInfer<T>, true>
+): ResourceReturn<T, R>;
+export declare function createResource<T, S, R = unknown>(
+  source: ResourceSource<S>,
+  fetcher: ResourceFetcher<S, T, R>,
+  options: InitializedResourceOptions<NoInfer<T>, S>
+): InitializedResourceReturn<T, R>;
+export declare function createResource<T, S, R = unknown>(
+  source: ResourceSource<S>,
+  fetcher: ResourceFetcher<S, T, R>,
+  options?: ResourceOptions<NoInfer<T>, S>
+): ResourceReturn<T, R>;
 export interface DeferredOptions<T> {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-    timeoutMs?: number;
+  equals?: false | ((prev: T, next: T) => boolean);
+  name?: string;
+  timeoutMs?: number;
 }
 /**
  * Creates a reactive computation that only runs and notifies the reactive context when the browser is idle
@@ -340,7 +396,10 @@ export interface DeferredOptions<T> {
  *
  * @description https://www.solidjs.com/docs/latest/api#createdeferred
  */
-export declare function createDeferred<T>(source: Accessor<T>, options?: DeferredOptions<T>): Accessor<T>;
+export declare function createDeferred<T>(
+  source: Accessor<T>,
+  options?: DeferredOptions<T>
+): Accessor<T>;
 export type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
 /**
  * Creates a conditional signal that only notifies subscribers when entering or exiting their key matching the value
@@ -366,7 +425,11 @@ export type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
  *
  * @description https://www.solidjs.com/docs/latest/api#createselector
  */
-export declare function createSelector<T, U = T>(source: Accessor<T>, fn?: EqualityCheckerFunction<T, U>, options?: BaseOptions): (key: U) => boolean;
+export declare function createSelector<T, U = T>(
+  source: Accessor<T>,
+  fn?: EqualityCheckerFunction<T, U>,
+  options?: BaseOptions
+): (key: U) => boolean;
 /**
  * Holds changes inside the block before the reactive context is updated
  * @param fn wraps the reactive updates that should be batched
@@ -384,15 +447,28 @@ export declare function batch<T>(fn: Accessor<T>): T;
  */
 export declare function untrack<T>(fn: Accessor<T>): T;
 /** @deprecated */
-export type ReturnTypes<T> = T extends readonly Accessor<unknown>[] ? {
-    [K in keyof T]: T[K] extends Accessor<infer I> ? I : never;
-} : T extends Accessor<infer I> ? I : never;
-export type AccessorArray<T> = [...Extract<{
-    [K in keyof T]: Accessor<T[K]>;
-}, readonly unknown[]>];
-export type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (input: S, prevInput: S | undefined, prev: Prev) => Next;
+export type ReturnTypes<T> = T extends readonly Accessor<unknown>[]
+  ? {
+      [K in keyof T]: T[K] extends Accessor<infer I> ? I : never;
+    }
+  : T extends Accessor<infer I>
+  ? I
+  : never;
+export type AccessorArray<T> = [
+  ...Extract<
+    {
+      [K in keyof T]: Accessor<T[K]>;
+    },
+    readonly unknown[]
+  >
+];
+export type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (
+  input: S,
+  prevInput: S | undefined,
+  prev: Prev
+) => Next;
 export interface OnOptions {
-    defer?: boolean;
+  defer?: boolean;
 }
 /**
  * on - make dependencies of a computation explicit
@@ -420,12 +496,20 @@ export interface OnOptions {
  *
  * @description https://www.solidjs.com/docs/latest/api#on
  */
-export declare function on<S, Next extends Prev, Prev = Next>(deps: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, options?: OnOptions & {
+export declare function on<S, Next extends Prev, Prev = Next>(
+  deps: AccessorArray<S> | Accessor<S>,
+  fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>,
+  options?: OnOptions & {
     defer?: false;
-}): EffectFunction<undefined | NoInfer<Next>, NoInfer<Next>>;
-export declare function on<S, Next extends Prev, Prev = Next>(deps: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, options: OnOptions & {
+  }
+): EffectFunction<undefined | NoInfer<Next>, NoInfer<Next>>;
+export declare function on<S, Next extends Prev, Prev = Next>(
+  deps: AccessorArray<S> | Accessor<S>,
+  fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>,
+  options: OnOptions & {
     defer: true;
-}): EffectFunction<undefined | NoInfer<Next>>;
+  }
+): EffectFunction<undefined | NoInfer<Next>>;
 /**
  * onMount - run an effect only after initial render on mount
  * @param fn an effect that should run only once on mount
@@ -452,16 +536,6 @@ export declare function onCleanup<T extends () => any>(fn: T): T;
  * @description https://www.solidjs.com/docs/latest/api#catcherror
  */
 export declare function catchError<T>(fn: () => T, handler: (err: Error) => void): T | undefined;
-/**
- * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead
- * onError - run an effect whenever an error is thrown within the context of the child scopes
- * @param fn an error handler that receives the error
- *
- * * If the error is thrown again inside the error handler, it will trigger the next available parent handler
- *
- * @description https://www.solidjs.com/docs/latest/api#onerror
- */
-export declare function onError(fn: (err: Error) => void): void;
 export declare function getListener(): Computation<any, any> | null;
 export declare function getOwner(): Owner | null;
 export declare function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined;
@@ -487,19 +561,19 @@ export type Transition = [Accessor<boolean>, (fn: () => void) => Promise<void>];
 export declare function useTransition(): Transition;
 export declare function resumeEffects(e: Computation<any>[]): void;
 export interface DevComponent<T> extends Memo<unknown> {
-    props: T;
-    name: string;
-    component: (props: T) => unknown;
+  props: T;
+  name: string;
+  component: (props: T) => unknown;
 }
 export declare function devComponent<P, V>(Comp: (props: P) => V, props: P): V;
 export declare function registerGraph(value: SourceMapValue): void;
 export type ContextProviderComponent<T> = FlowComponent<{
-    value: T;
+  value: T;
 }>;
 export interface Context<T> {
-    id: symbol;
-    Provider: ContextProviderComponent<T>;
-    defaultValue: T;
+  id: symbol;
+  Provider: ContextProviderComponent<T>;
+  defaultValue: T;
 }
 /**
  * Creates a Context to handle a state scoped for the children of a component
@@ -520,7 +594,10 @@ export interface Context<T> {
  *
  * @description https://www.solidjs.com/docs/latest/api#createcontext
  */
-export declare function createContext<T>(defaultValue?: undefined, options?: EffectOptions): Context<T | undefined>;
+export declare function createContext<T>(
+  defaultValue?: undefined,
+  options?: EffectOptions
+): Context<T | undefined>;
 export declare function createContext<T>(defaultValue: T, options?: EffectOptions): Context<T>;
 /**
  * use a context to receive a scoped state from a parent's Context.Provider
@@ -534,7 +611,7 @@ export declare function useContext<T>(context: Context<T>): T;
 export type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
 export type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
 export type ChildrenReturn = Accessor<ResolvedChildren> & {
-    toArray: () => ResolvedJSXElement[];
+  toArray: () => ResolvedJSXElement[];
 };
 /**
  * Resolves child elements to help interact with children
@@ -546,20 +623,34 @@ export type ChildrenReturn = Accessor<ResolvedChildren> & {
  */
 export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
 export type SuspenseContextType = {
-    increment?: () => void;
-    decrement?: () => void;
-    inFallback?: () => boolean;
-    effects?: Computation<any>[];
-    resolved?: boolean;
+  increment?: () => void;
+  decrement?: () => void;
+  inFallback?: () => boolean;
+  effects?: Computation<any>[];
+  resolved?: boolean;
 };
 type SuspenseContext = Context<SuspenseContextType> & {
-    active?(): boolean;
-    increment?(): void;
-    decrement?(): void;
+  active?(): boolean;
+  increment?(): void;
+  decrement?(): void;
 };
 declare let SuspenseContext: SuspenseContext;
 export declare function getSuspenseContext(): SuspenseContext;
 export declare function enableExternalSource(factory: ExternalSourceFactory): void;
 export declare function readSignal(this: SignalState<any> | Memo<any>): any;
-export declare function writeSignal(node: SignalState<any> | Memo<any>, value: any, isComp?: boolean): any;
+export declare function writeSignal(
+  node: SignalState<any> | Memo<any>,
+  value: any,
+  isComp?: boolean
+): any;
+/**
+ * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead
+ * onError - run an effect whenever an error is thrown within the context of the child scopes
+ * @param fn an error handler that receives the error
+ *
+ * * If the error is thrown again inside the error handler, it will trigger the next available parent handler
+ *
+ * @description https://www.solidjs.com/docs/latest/api#onerror
+ */
+export declare function onError(fn: (err: Error) => void): void;
 export {};

package/types/render/Suspense.d.ts

@@ -5,9 +5,9 @@ import type { JSX } from "../jsx.js";
  * @description https://www.solidjs.com/docs/latest/api#suspenselist-experimental
  */
 export declare function SuspenseList(props: {
-    children: JSX.Element;
-    revealOrder: "forwards" | "backwards" | "together";
-    tail?: "collapsed" | "hidden";
+  children: JSX.Element;
+  revealOrder: "forwards" | "backwards" | "together";
+  tail?: "collapsed" | "hidden";
 }): JSX.Element;
 /**
  * tracks all resources inside a component and renders a fallback until they are all resolved
@@ -21,6 +21,6 @@ export declare function SuspenseList(props: {
  * @description https://www.solidjs.com/docs/latest/api#suspense
  */
 export declare function Suspense(props: {
-    fallback?: JSX.Element;
-    children: JSX.Element;
+  fallback?: JSX.Element;
+  children: JSX.Element;
 }): JSX.Element;