Class UpdatePopover

Hierarchy

{
    input: {
        options: {
            props?: { readonly [key: string]: any };
            side?: "left" | "top" | "right" | "bottom";
            state?: boolean;
        } & (
            | { anchor: any; variant: "virtual" }
            | { anchorId: string; variant?: "react" }
        );
        part: "popover";
        subject?: any;
    };
} & { output: void } & {
    _tag: "dxos.org/plugin/layout/action/update-layout";
}
- UpdatePopover

Index

Constructors

constructor

new UpdatePopover(
    props: {
        input: {
            options: {
                props?: { readonly [key: string]: any };
                side?: "left" | "top" | "right" | "bottom";
                state?: boolean;
            } & (
                | { anchor: any; variant: "virtual" }
                | { anchorId: string; variant?: "react" }
            );
            part: "popover";
            subject?: any;
        };
        output: void;
    },
    options?: MakeOptions,
): UpdatePopover
Parameters
- props: {
      input: {
          options: {
              props?: { readonly [key: string]: any };
              side?: "left" | "top" | "right" | "bottom";
              state?: boolean;
          } & (
              | { anchor: any; variant: "virtual" }
              | { anchorId: string; variant?: "react" }
          );
          part: "popover";
          subject?: any;
      };
      output: void;
  }
- Optionaloptions: MakeOptions
Returns UpdatePopover
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).constructor
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4265

Properties

`Readonly`_tag

_tag: "dxos.org/plugin/layout/action/update-layout"

Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, })._tag

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4408

`Readonly`input

input: {
    options: {
        props?: { readonly [key: string]: any };
        side?: "left" | "top" | "right" | "bottom";
        state?: boolean;
    } & (
        | { anchor: any; variant: "virtual" }
        | { anchorId: string; variant?: "react" }
    );
    part: "popover";
    subject?: any;
} = ...

Defined in packages/sdk/app-framework/src/common/layout.ts:123

`Readonly`output

output: void = Schema.Void

Defined in packages/sdk/app-framework/src/common/layout.ts:157

`Static` `Readonly`_tag

_tag: "dxos.org/plugin/layout/action/update-layout"

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4390

`Static` `Readonly`[TypeId]

"[TypeId]": {
    _A: Invariant<UpdatePopover>;
    _I: Invariant<
        {
            _tag: "dxos.org/plugin/layout/action/update-layout";
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
            output: void;
        },
    >;
    _R: Covariant<never>;
}

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:160

`Static` `Readonly`ast

ast: Transformation

Since

3.10.0

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4267

`Static` `Readonly`Context

Context: never

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:63

`Static` `Readonly`Encoded

Encoded: {
    _tag: "dxos.org/plugin/layout/action/update-layout";
    input: {
        options: {
            props?: { readonly [key: string]: any };
            side?: "left" | "top" | "right" | "bottom";
            state?: boolean;
        } & (
            | { anchor: any; variant: "virtual" }
            | { anchorId: string; variant?: "react" }
        );
        part: "popover";
        subject?: any;
    };
    output: void;
}

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:62

`Static` `Readonly`fields

fields: {
    _tag: tag<"dxos.org/plugin/layout/action/update-layout">;
    input: Struct<
        {
            options: extend<
                Struct<
                    {
                        props: optional<Record$<typeof String$, typeof Any>>;
                        side: optional<Literal<["top", "right", "bottom", "left"]>>;
                        state: optional<SchemaClass<boolean, boolean, never>>;
                    },
                >,
                Union<
                    [
                        Struct<
                            {
                                anchor: SchemaClass<any, any, never>;
                                variant: Literal<["virtual"]>;
                            },
                        >,
                        Struct<
                            {
                                anchorId: SchemaClass<string, string, never>;
                                variant: optional<Literal<[(...)]>>;
                            },
                        >,
                    ],
                >,
            >;
            part: Literal<["popover"]>;
            subject: optional<SchemaClass<any, any, never>>;
        },
    >;
    output: typeof Void;
}

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4270

`Static` `Readonly`identifier

identifier: string

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4273

`Static` `Readonly`Type

Type: UpdatePopover

Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:61

Methods

`Static`annotations

annotations(
    annotations: Schema<UpdatePopover>,
): SchemaClass<
    UpdatePopover,
    {
        _tag: "dxos.org/plugin/layout/action/update-layout";
        input: {
            options: {
                props?: { readonly [key: string]: any };
                side?: "left" | "top" | "right" | "bottom";
                state?: boolean;
            } & (
                | { anchor: any; variant: "virtual" }
                | { anchorId: string; variant?: "react" }
            );
            part: "popover";
            subject?: any;
        };
        output: void;
    },
    never,
>
Merges a set of new annotations with existing ones, potentially overwriting any duplicates.
Parameters
- annotations: Schema<UpdatePopover>
Returns SchemaClass<
    UpdatePopover,
    {
        _tag: "dxos.org/plugin/layout/action/update-layout";
        input: {
            options: {
                props?: { readonly [key: string]: any };
                side?: "left" | "top" | "right" | "bottom";
                state?: boolean;
            } & (
                | { anchor: any; variant: "virtual" }
                | { anchorId: string; variant?: "react" }
            );
            part: "popover";
            subject?: any;
        };
        output: void;
    },
    never,
>
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).annotations
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4269

`Static`extend

extend<Extended = never>(
    identifier: string,
): <NewFields extends Fields>(
    fields: NewFields | HasFields<NewFields>,
    annotations?: ClassAnnotations<
        Extended,
        {
            [K in string
            | number
            | symbol]: Type<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<(...), (...)>;
                            part: Literal<(...)>;
                            subject: optional<(...)>;
                        },
                    >;
                    output: typeof Void;
                } & NewFields,
            >[K]
        },
    >,
) => [Extended] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`"
    : Class<
        Extended,
        { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
            input: Struct<
                {
                    options: extend<
                        Struct<
                            {
                                props: optional<(...)>;
                                side: optional<(...)>;
                                state: optional<(...)>;
                            },
                        >,
                        Union<[Struct<(...)>, Struct<(...)>]>,
                    >;
                    part: Literal<["popover"]>;
                    subject: optional<SchemaClass<any, any, never>>;
                },
            >;
            output: typeof Void;
        } & NewFields,
        {
            _tag: "dxos.org/plugin/layout/action/update-layout";
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
            output: void;
        } & {} & {
            readonly [K in string
            | number
            | symbol as Key<NewFields, K>]: Encoded<NewFields[K]>
        } & {
            readonly [K in string
            | number
            | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]>
        },
        Context<NewFields[keyof NewFields]>,
        {
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
        } & { output: void } & Constructor<NewFields>,
        UpdatePopover,
        {},
    >
Type Parameters
- Extended = never
Parameters
- identifier: string
Returns <NewFields extends Fields>(
    fields: NewFields | HasFields<NewFields>,
    annotations?: ClassAnnotations<
        Extended,
        {
            [K in string
            | number
            | symbol]: Type<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<(...), (...)>;
                            part: Literal<(...)>;
                            subject: optional<(...)>;
                        },
                    >;
                    output: typeof Void;
                } & NewFields,
            >[K]
        },
    >,
) => [Extended] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`"
    : Class<
        Extended,
        { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
            input: Struct<
                {
                    options: extend<
                        Struct<
                            {
                                props: optional<(...)>;
                                side: optional<(...)>;
                                state: optional<(...)>;
                            },
                        >,
                        Union<[Struct<(...)>, Struct<(...)>]>,
                    >;
                    part: Literal<["popover"]>;
                    subject: optional<SchemaClass<any, any, never>>;
                },
            >;
            output: typeof Void;
        } & NewFields,
        {
            _tag: "dxos.org/plugin/layout/action/update-layout";
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
            output: void;
        } & {} & {
            readonly [K in string
            | number
            | symbol as Key<NewFields, K>]: Encoded<NewFields[K]>
        } & {
            readonly [K in string
            | number
            | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]>
        },
        Context<NewFields[keyof NewFields]>,
        {
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
        } & { output: void } & Constructor<NewFields>,
        UpdatePopover,
        {},
    >
Example
```
import { Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
 myField: Schema.String
}) {
 myMethod() {
   return this.myField + "my"
 }
}

class NextClass extends MyClass.extend<NextClass>("NextClass")({
 nextField: Schema.Number
}) {
 nextMethod() {
   return this.myMethod() + this.myField + this.nextField
 }
}
```
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).extend
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4296

`Static`make

make<C extends new (...args: any[]) => any>(
this: C,
...args: ConstructorParameters<C>,
): InstanceType<C>
Type Parameters
- C extends new (...args: any[]) => any
Parameters
- this: C
- ...args: ConstructorParameters<C>
Returns InstanceType<C>
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).make
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4268

`Static`pipe

pipe<A>(this: A): A
Type Parameters
- A
Parameters
- this: A
Returns A
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:9
pipe<A, B = never>(this: A, ab: (_: A) => B): B
Type Parameters
- A
- B = never
Parameters
- this: A
- ab: (_: A) => B
Returns B
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:10
pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
Type Parameters
- A
- B = never
- C = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
Returns C
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:11
pipe<A, B = never, C = never, D = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
): D
Type Parameters
- A
- B = never
- C = never
- D = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
Returns D
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:12
pipe<A, B = never, C = never, D = never, E = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
): E
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
Returns E
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:13
pipe<A, B = never, C = never, D = never, E = never, F = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
): F
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
Returns F
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:14
pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
): G
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
Returns G
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:15
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
): H
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
Returns H
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:16
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
): I
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
Returns I
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:17
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
): J
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
Returns J
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:18
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
): K
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
Returns K
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:19
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
): L
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
Returns L
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:20
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
): M
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
Returns M
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:21
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
): N
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
Returns N
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:22
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
): O
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
Returns O
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:23
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
): P
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
Returns P
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:24
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
): Q
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
Returns Q
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:25
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
): R
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
Returns R
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:26
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
): S
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
Returns S
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:27
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
): T
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
Returns T
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:28
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:29
pipe<
    A,
    B = never,
    C = never,
    D = never,
    E = never,
    F = never,
    G = never,
    H = never,
    I = never,
    J = never,
    K = never,
    L = never,
    M = never,
    N = never,
    O = never,
    P = never,
    Q = never,
    R = never,
    S = never,
    T = never,
    U = never,
>(
    this: A,
    ab: (_: A) => B,
    bc: (_: B) => C,
    cd: (_: C) => D,
    de: (_: D) => E,
    ef: (_: E) => F,
    fg: (_: F) => G,
    gh: (_: G) => H,
    hi: (_: H) => I,
    ij: (_: I) => J,
    jk: (_: J) => K,
    kl: (_: K) => L,
    lm: (_: L) => M,
    mn: (_: M) => N,
    no: (_: N) => O,
    op: (_: O) => P,
    pq: (_: P) => Q,
    qr: (_: Q) => R,
    rs: (_: R) => S,
    st: (_: S) => T,
    tu: (_: T) => U,
): U
Type Parameters
- A
- B = never
- C = never
- D = never
- E = never
- F = never
- G = never
- H = never
- I = never
- J = never
- K = never
- L = never
- M = never
- N = never
- O = never
- P = never
- Q = never
- R = never
- S = never
- T = never
- U = never
Parameters
- this: A
- ab: (_: A) => B
- bc: (_: B) => C
- cd: (_: C) => D
- de: (_: D) => E
- ef: (_: E) => F
- fg: (_: F) => G
- gh: (_: G) => H
- hi: (_: H) => I
- ij: (_: I) => J
- jk: (_: J) => K
- kl: (_: K) => L
- lm: (_: L) => M
- mn: (_: M) => N
- no: (_: N) => O
- op: (_: O) => P
- pq: (_: P) => Q
- qr: (_: Q) => R
- rs: (_: R) => S
- st: (_: S) => T
- tu: (_: T) => U
Returns U
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).pipe
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Pipeable.d.ts:30

`Static`transformOrFail

transformOrFail<Transformed = never>(
    identifier: string,
): <NewFields extends Fields, R2, R3>(
    fields: NewFields,
    options: {
        decode: (
            input: {
                _tag: "dxos.org/plugin/layout/action/update-layout";
                input: {
                    options: {
                        props?: { readonly [key: string]: any };
                        side?: "left" | "top" | "right" | "bottom";
                        state?: boolean;
                    } & (
                        | { anchor: any; variant: "virtual" }
                        | { anchorId: string; variant?: "react" }
                    );
                    part: "popover";
                    subject?: any;
                };
                output: void;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: Type<
                    { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                        input: Struct<{ options: ...; part: ...; subject: ... }>;
                        output: typeof Void;
                    } & NewFields,
                >[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: Type<
                    { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                        input: Struct<
                            {
                                options: extend<(...), (...)>;
                                part: Literal<(...)>;
                                subject: optional<(...)>;
                            },
                        >;
                        output: typeof Void;
                    } & NewFields,
                >[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                input: {
                    options: {
                        props?: { readonly [key: ...]: ... };
                        side?: "left" | "top" | "right" | "bottom";
                        state?: boolean;
                    } & (
                        | { anchor: any; variant: "virtual" }
                        | { anchorId: string; variant?: (...) | (...) }
                    );
                    part: "popover";
                    subject?: any;
                };
            } & { output: void } & {
                _tag: "dxos.org/plugin/layout/action/update-layout";
            },
            ParseIssue,
            R3,
        >;
    },
    annotations?: ClassAnnotations<
        Transformed,
        {
            [K in string
            | number
            | symbol]: Type<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<(...), (...)>;
                            part: Literal<(...)>;
                            subject: optional<(...)>;
                        },
                    >;
                    output: typeof Void;
                } & NewFields,
            >[K]
        },
    >,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
            input: Struct<
                {
                    options: extend<
                        Struct<
                            {
                                props: optional<(...)>;
                                side: optional<(...)>;
                                state: optional<(...)>;
                            },
                        >,
                        Union<[Struct<(...)>, Struct<(...)>]>,
                    >;
                    part: Literal<["popover"]>;
                    subject: optional<SchemaClass<any, any, never>>;
                },
            >;
            output: typeof Void;
        } & NewFields,
        Encoded<
            { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                input: Struct<
                    {
                        options: extend<
                            Struct<{ props: ...; side: ...; state: ... }>,
                            Union<[(...), (...)]>,
                        >;
                        part: Literal<["popover"]>;
                        subject: optional<SchemaClass<any, any, never>>;
                    },
                >;
                output: typeof Void;
            },
        >,
        R2
        | R3
        | Context<NewFields[keyof NewFields]>,
        {
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
        } & { output: void } & Constructor<NewFields>,
        UpdatePopover,
        {},
    >
Type Parameters
- Transformed = never
Parameters
- identifier: string
Returns <NewFields extends Fields, R2, R3>(
    fields: NewFields,
    options: {
        decode: (
            input: {
                _tag: "dxos.org/plugin/layout/action/update-layout";
                input: {
                    options: {
                        props?: { readonly [key: string]: any };
                        side?: "left" | "top" | "right" | "bottom";
                        state?: boolean;
                    } & (
                        | { anchor: any; variant: "virtual" }
                        | { anchorId: string; variant?: "react" }
                    );
                    part: "popover";
                    subject?: any;
                };
                output: void;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: Type<
                    { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                        input: Struct<{ options: ...; part: ...; subject: ... }>;
                        output: typeof Void;
                    } & NewFields,
                >[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: Type<
                    { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                        input: Struct<
                            {
                                options: extend<(...), (...)>;
                                part: Literal<(...)>;
                                subject: optional<(...)>;
                            },
                        >;
                        output: typeof Void;
                    } & NewFields,
                >[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                input: {
                    options: {
                        props?: { readonly [key: ...]: ... };
                        side?: "left" | "top" | "right" | "bottom";
                        state?: boolean;
                    } & (
                        | { anchor: any; variant: "virtual" }
                        | { anchorId: string; variant?: (...) | (...) }
                    );
                    part: "popover";
                    subject?: any;
                };
            } & { output: void } & {
                _tag: "dxos.org/plugin/layout/action/update-layout";
            },
            ParseIssue,
            R3,
        >;
    },
    annotations?: ClassAnnotations<
        Transformed,
        {
            [K in string
            | number
            | symbol]: Type<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<(...), (...)>;
                            part: Literal<(...)>;
                            subject: optional<(...)>;
                        },
                    >;
                    output: typeof Void;
                } & NewFields,
            >[K]
        },
    >,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
            input: Struct<
                {
                    options: extend<
                        Struct<
                            {
                                props: optional<(...)>;
                                side: optional<(...)>;
                                state: optional<(...)>;
                            },
                        >,
                        Union<[Struct<(...)>, Struct<(...)>]>,
                    >;
                    part: Literal<["popover"]>;
                    subject: optional<SchemaClass<any, any, never>>;
                },
            >;
            output: typeof Void;
        } & NewFields,
        Encoded<
            { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                input: Struct<
                    {
                        options: extend<
                            Struct<{ props: ...; side: ...; state: ... }>,
                            Union<[(...), (...)]>,
                        >;
                        part: Literal<["popover"]>;
                        subject: optional<SchemaClass<any, any, never>>;
                    },
                >;
                output: typeof Void;
            },
        >,
        R2
        | R3
        | Context<NewFields[keyof NewFields]>,
        {
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
        } & { output: void } & Constructor<NewFields>,
        UpdatePopover,
        {},
    >
Example
```
import { Effect, Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
  myField: Schema.String
}) {
  myMethod() {
    return this.myField + "my"
  }
}

class NextClass extends MyClass.transformOrFail<NextClass>("NextClass")({
  nextField: Schema.Number
}, {
  decode: (i) =>
    Effect.succeed({
      myField: i.myField,
      nextField: i.myField.length
    }),
  encode: (a) => Effect.succeed({ myField: a.myField })
}) {
  nextMethod() {
    return this.myMethod() + this.myField + this.nextField
  }
}
```
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).transformOrFail
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4326

`Static`transformOrFailFrom

transformOrFailFrom<Transformed = never>(
    identifier: string,
): <NewFields extends Fields, R2, R3>(
    fields: NewFields,
    options: {
        decode: (
            input: {
                _tag: "dxos.org/plugin/layout/action/update-layout";
                input: {
                    options: {
                        props?: { readonly [key: string]: any };
                        side?: "left" | "top" | "right" | "bottom";
                        state?: boolean;
                    } & (
                        | { anchor: any; variant: "virtual" }
                        | { anchorId: string; variant?: "react" }
                    );
                    part: "popover";
                    subject?: any;
                };
                output: void;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: (
                    {
                        _tag: "dxos.org/plugin/layout/action/update-layout";
                        input: {
                            options: { props?: ...; side?: ...; state?: ... } & (
                                (...)
                                | (...)
                            );
                            part: "popover";
                            subject?: any;
                        };
                        output: void;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]: Encoded<NewFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]?: Encoded<(...)[(...)]>
                    }
                )[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: (
                    {
                        _tag: "dxos.org/plugin/layout/action/update-layout";
                        input: {
                            options: {
                                props?: (...)
                                | (...);
                                side?: (...) | (...) | (...) | (...) | (...);
                                state?: (...) | (...) | (...);
                            } & (
                                { anchor: ...; variant: ... }
                                | { anchorId: ...; variant?: ... }
                            );
                            part: "popover";
                            subject?: any;
                        };
                        output: void;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]: Encoded<NewFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]>
                    }
                )[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            Encoded<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<Struct<(...)>, Union<(...)>>;
                            part: Literal<[(...)]>;
                            subject: optional<SchemaClass<(...), (...), (...)>>;
                        },
                    >;
                    output: typeof Void;
                },
            >,
            ParseIssue,
            R3,
        >;
    },
    annotations?: ClassAnnotations<
        Transformed,
        {
            [K in string
            | number
            | symbol]: Type<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<(...), (...)>;
                            part: Literal<(...)>;
                            subject: optional<(...)>;
                        },
                    >;
                    output: typeof Void;
                } & NewFields,
            >[K]
        },
    >,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
            input: Struct<
                {
                    options: extend<
                        Struct<
                            {
                                props: optional<(...)>;
                                side: optional<(...)>;
                                state: optional<(...)>;
                            },
                        >,
                        Union<[Struct<(...)>, Struct<(...)>]>,
                    >;
                    part: Literal<["popover"]>;
                    subject: optional<SchemaClass<any, any, never>>;
                },
            >;
            output: typeof Void;
        } & NewFields,
        Encoded<
            { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                input: Struct<
                    {
                        options: extend<
                            Struct<{ props: ...; side: ...; state: ... }>,
                            Union<[(...), (...)]>,
                        >;
                        part: Literal<["popover"]>;
                        subject: optional<SchemaClass<any, any, never>>;
                    },
                >;
                output: typeof Void;
            },
        >,
        R2
        | R3
        | Context<NewFields[keyof NewFields]>,
        {
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
        } & { output: void } & Constructor<NewFields>,
        UpdatePopover,
        {},
    >
Type Parameters
- Transformed = never
Parameters
- identifier: string
Returns <NewFields extends Fields, R2, R3>(
    fields: NewFields,
    options: {
        decode: (
            input: {
                _tag: "dxos.org/plugin/layout/action/update-layout";
                input: {
                    options: {
                        props?: { readonly [key: string]: any };
                        side?: "left" | "top" | "right" | "bottom";
                        state?: boolean;
                    } & (
                        | { anchor: any; variant: "virtual" }
                        | { anchorId: string; variant?: "react" }
                    );
                    part: "popover";
                    subject?: any;
                };
                output: void;
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            {
                [K in string
                | number
                | symbol]: (
                    {
                        _tag: "dxos.org/plugin/layout/action/update-layout";
                        input: {
                            options: { props?: ...; side?: ...; state?: ... } & (
                                (...)
                                | (...)
                            );
                            part: "popover";
                            subject?: any;
                        };
                        output: void;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]: Encoded<NewFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]?: Encoded<(...)[(...)]>
                    }
                )[K]
            },
            ParseIssue,
            R2,
        >;
        encode: (
            input: {
                [K in string | number | symbol]: (
                    {
                        _tag: "dxos.org/plugin/layout/action/update-layout";
                        input: {
                            options: {
                                props?: (...)
                                | (...);
                                side?: (...) | (...) | (...) | (...) | (...);
                                state?: (...) | (...) | (...);
                            } & (
                                { anchor: ...; variant: ... }
                                | { anchorId: ...; variant?: ... }
                            );
                            part: "popover";
                            subject?: any;
                        };
                        output: void;
                    } & {} & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]: Encoded<NewFields[K]>
                    } & {
                        readonly [K in string
                        | number
                        | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]>
                    }
                )[K]
            },
            options: ParseOptions,
            ast: Transformation,
        ) => Effect<
            Encoded<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<Struct<(...)>, Union<(...)>>;
                            part: Literal<[(...)]>;
                            subject: optional<SchemaClass<(...), (...), (...)>>;
                        },
                    >;
                    output: typeof Void;
                },
            >,
            ParseIssue,
            R3,
        >;
    },
    annotations?: ClassAnnotations<
        Transformed,
        {
            [K in string
            | number
            | symbol]: Type<
                { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                    input: Struct<
                        {
                            options: extend<(...), (...)>;
                            part: Literal<(...)>;
                            subject: optional<(...)>;
                        },
                    >;
                    output: typeof Void;
                } & NewFields,
            >[K]
        },
    >,
) => [Transformed] extends [never]
    ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`"
    : Class<
        Transformed,
        { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
            input: Struct<
                {
                    options: extend<
                        Struct<
                            {
                                props: optional<(...)>;
                                side: optional<(...)>;
                                state: optional<(...)>;
                            },
                        >,
                        Union<[Struct<(...)>, Struct<(...)>]>,
                    >;
                    part: Literal<["popover"]>;
                    subject: optional<SchemaClass<any, any, never>>;
                },
            >;
            output: typeof Void;
        } & NewFields,
        Encoded<
            { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                input: Struct<
                    {
                        options: extend<
                            Struct<{ props: ...; side: ...; state: ... }>,
                            Union<[(...), (...)]>,
                        >;
                        part: Literal<["popover"]>;
                        subject: optional<SchemaClass<any, any, never>>;
                    },
                >;
                output: typeof Void;
            },
        >,
        R2
        | R3
        | Context<NewFields[keyof NewFields]>,
        {
            input: {
                options: {
                    props?: { readonly [key: string]: any };
                    side?: "left" | "top" | "right" | "bottom";
                    state?: boolean;
                } & (
                    | { anchor: any; variant: "virtual" }
                    | { anchorId: string; variant?: "react" }
                );
                part: "popover";
                subject?: any;
            };
        } & { output: void } & Constructor<NewFields>,
        UpdatePopover,
        {},
    >
Example
```
import { Effect, Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
  myField: Schema.String
}) {
  myMethod() {
    return this.myField + "my"
  }
}

class NextClass extends MyClass.transformOrFailFrom<NextClass>("NextClass")({
  nextField: Schema.Number
}, {
  decode: (i) =>
    Effect.succeed({
      myField: i.myField,
      nextField: i.myField.length
    }),
  encode: (a) => Effect.succeed({ myField: a.myField })
}) {
  nextMethod() {
    return this.myMethod() + this.myField + this.nextField
  }
}
```
Inherited from Schema.TaggedClass<UpdatePopover>()(UPDATE_LAYOUT, { input: Schema.Struct({ part: Schema.Literal('popover').annotations({ description: 'Updating the popover.' }), subject: Schema.optional( Schema.Any.annotations({ description: 'URI of the component to display in the popover or data to pass to the popover.', }), ), options: Schema.Struct({ side: Schema.optional( Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }), ), state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })), props: Schema.optional( Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({ description: 'Additional props for the popover.', }), ), }).pipe( Schema.extend( Schema.Union( Schema.Struct({ variant: Schema.Literal('virtual'), anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }), }), Schema.Struct({ variant: Schema.optional(Schema.Literal('react')), anchorId: Schema.String.annotations({ description: 'An id that can be used to determine whether to render the anchor subcomponent.', }), }), ), ), ), }), output: Schema.Void, }).transformOrFailFrom
- Defined in node_modules/.pnpm/[email protected]/node_modules/effect/dist/dts/Schema.d.ts:4359

Class UpdatePopover

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns UpdatePopover

Properties

Readonly_tag

Readonlyinput

Readonlyoutput

Static Readonly_tag

Static Readonly[TypeId]

Static Readonlyast

Since

Static ReadonlyContext

Static ReadonlyEncoded

Static Readonlyfields

Static Readonlyidentifier

Static ReadonlyType

Methods

Staticannotations

Parameters

Staticextend

Type Parameters

Parameters

Example

Staticmake

Type Parameters

Parameters

Returns InstanceType<C>

Staticpipe

Type Parameters

Parameters

Returns A

Type Parameters

Parameters

Returns B

Type Parameters

Parameters

Returns C

Type Parameters

Parameters

Returns D

Type Parameters

Parameters

Returns E

Type Parameters

Parameters

Returns F

Type Parameters

Parameters

Returns G

Type Parameters

Parameters

Returns H

Type Parameters

Parameters

Returns I

Type Parameters

Parameters

Returns J

Type Parameters

Parameters

Returns K

Type Parameters

Parameters

Returns L

Type Parameters

Parameters

Returns M

Type Parameters

Parameters

Returns N

Type Parameters

Parameters

Returns O

`Readonly`_tag

`Readonly`input

`Readonly`output

`Static` `Readonly`_tag

`Static` `Readonly`[TypeId]

`Static` `Readonly`ast

`Static` `Readonly`Context

`Static` `Readonly`Encoded

`Static` `Readonly`fields

`Static` `Readonly`identifier

`Static` `Readonly`Type

`Static`annotations

`Static`extend

`Static`make

`Static`pipe

`Static`transformOrFail

`Static`transformOrFailFrom