@dxos/app-framework - v0.8.2
    Preparing search index...

    Class Open

    Hierarchy

    • {
          input: {
              options?: {
                  key?: string;
                  pivotId?: string;
                  positioning?: "start" | "end";
                  scrollIntoView?: boolean;
                  state?: true;
                  variant?: string;
                  workspace?: string;
              };
              part: "main";
              subject: readonly string[];
          };
      } & { output: void } & {
          _tag: "dxos.org/plugin/layout/action/update-layout";
      }
      • Open
    Index

    Constructors

    constructor

    Properties

    _tag input output _tag [TypeId] ast Context Encoded fields identifier Type

    Methods

    annotations extend make pipe transformOrFail transformOrFailFrom

    Constructors

    • Parameters

      • props: {
            input: {
                options?: {
                    key?: string;
                    pivotId?: string;
                    positioning?: "start" | "end";
                    scrollIntoView?: boolean;
                    state?: true;
                    variant?: string;
                    workspace?: string;
                };
                part: "main";
                subject: readonly string[];
            };
            output: void;
        }
      • Optionaloptions: MakeOptions

      Returns LayoutAction.Open

    Properties

    Readonly_tag

    _tag: "dxos.org/plugin/layout/action/update-layout"
    input: {
        options?: {
            key?: string;
            pivotId?: string;
            positioning?: "start" | "end";
            scrollIntoView?: boolean;
            state?: true;
            variant?: string;
            workspace?: string;
        };
        part: "main";
        subject: readonly string[];
    } = ...
    output: void = Schema.Void

    Static Readonly_tag

    _tag: "dxos.org/plugin/layout/action/update-layout"
    "[TypeId]": {
        _A: Invariant<LayoutAction.Open>;
        _I: Invariant<
            {
                _tag: "dxos.org/plugin/layout/action/update-layout";
                input: {
                    options?: {
                        key?: string;
                        pivotId?: string;
                        positioning?: "start"
                        | "end";
                        scrollIntoView?: boolean;
                        state?: true;
                        variant?: string;
                        workspace?: string;
                    };
                    part: "main";
                    subject: readonly string[];
                };
                output: void;
            },
        >;
        _R: Covariant<never>;
    }
    ast: Transformation

    3.10.0

    Context: never
    Encoded: {
        _tag: "dxos.org/plugin/layout/action/update-layout";
        input: {
            options?: {
                key?: string;
                pivotId?: string;
                positioning?: "start" | "end";
                scrollIntoView?: boolean;
                state?: true;
                variant?: string;
                workspace?: string;
            };
            part: "main";
            subject: readonly string[];
        };
        output: void;
    }
    fields: {
        _tag: tag<"dxos.org/plugin/layout/action/update-layout">;
        input: Struct<
            {
                options: optional<
                    Struct<
                        {
                            key: optional<SchemaClass<string, string, never>>;
                            pivotId: optional<SchemaClass<string, string, never>>;
                            positioning: optional<Union<[Literal<[(...)]>, Literal<[(...)]>]>>;
                            scrollIntoView: optional<SchemaClass<boolean, boolean, never>>;
                            state: optional<Literal<[true]>>;
                            variant: optional<SchemaClass<string, string, never>>;
                            workspace: optional<SchemaClass<string, string, never>>;
                        },
                    >,
                >;
                part: Literal<["main"]>;
                subject: Array$<SchemaClass<string, string, never>>;
            },
        >;
        output: typeof Void;
    }
    identifier: string
    Type: LayoutAction.Open

    Methods

    • Merges a set of new annotations with existing ones, potentially overwriting any duplicates.

      Parameters

      Returns SchemaClass<
          LayoutAction.Open,
          {
              _tag: "dxos.org/plugin/layout/action/update-layout";
              input: {
                  options?: {
                      key?: string;
                      pivotId?: string;
                      positioning?: "start"
                      | "end";
                      scrollIntoView?: boolean;
                      state?: true;
                      variant?: string;
                      workspace?: string;
                  };
                  part: "main";
                  subject: readonly string[];
              };
              output: void;
          },
          never,
      >

    • 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: optional<(...)>;
                                  part: Literal<(...)>;
                                  subject: Array$<(...)>;
                              },
                          >;
                          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: optional<
                              Struct<
                                  {
                                      key: optional<(...)>;
                                      pivotId: optional<(...)>;
                                      positioning: optional<(...)>;
                                      scrollIntoView: optional<(...)>;
                                      state: optional<(...)>;
                                      variant: optional<(...)>;
                                      workspace: optional<(...)>;
                                  },
                              >,
                          >;
                          part: Literal<["main"]>;
                          subject: Array$<SchemaClass<string, string, never>>;
                      },
                  >;
                  output: typeof Void;
              } & NewFields,
              {
                  _tag: "dxos.org/plugin/layout/action/update-layout";
                  input: {
                      options?: {
                          key?: string;
                          pivotId?: string;
                          positioning?: "start"
                          | "end";
                          scrollIntoView?: boolean;
                          state?: true;
                          variant?: string;
                          workspace?: string;
                      };
                      part: "main";
                      subject: readonly string[];
                  };
                  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?: {
                          key?: string;
                          pivotId?: string;
                          positioning?: "start" | "end";
                          scrollIntoView?: boolean;
                          state?: true;
                          variant?: string;
                          workspace?: string;
                      };
                      part: "main";
                      subject: readonly string[];
                  };
              } & { output: void } & Constructor<NewFields>,
              LayoutAction.Open,
              {},
          >

      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
       }
      }

    • Type Parameters

      • C extends new (...args: any[]) => any

      Parameters

      • this: C
      • ...args: ConstructorParameters<C>

      Returns InstanceType<C>

    • Type Parameters

      • A

      Parameters

      • this: A

      Returns A

    • Type Parameters

      • A
      • B = never

      Parameters

      • this: A
      • ab: (_: A) => B

      Returns B

    • Type Parameters

      • A
      • B = never
      • C = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C

      Returns C

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D

      Returns D

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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

    • 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?: {
                              key?: string;
                              pivotId?: string;
                              positioning?: "start" | "end";
                              scrollIntoView?: boolean;
                              state?: true;
                              variant?: string;
                              workspace?: string;
                          };
                          part: "main";
                          subject: readonly string[];
                      };
                      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: optional<(...)>;
                                      part: Literal<(...)>;
                                      subject: Array$<(...)>;
                                  },
                              >;
                              output: typeof Void;
                          } & NewFields,
                      >[K]
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  {
                      input: {
                          options?: {
                              key?: string;
                              pivotId?: string;
                              positioning?: "start"
                              | "end";
                              scrollIntoView?: boolean;
                              state?: true;
                              variant?: string;
                              workspace?: string;
                          };
                          part: "main";
                          subject: readonly string[];
                      };
                  } & { 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: optional<(...)>;
                                  part: Literal<(...)>;
                                  subject: Array$<(...)>;
                              },
                          >;
                          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: optional<
                              Struct<
                                  {
                                      key: optional<(...)>;
                                      pivotId: optional<(...)>;
                                      positioning: optional<(...)>;
                                      scrollIntoView: optional<(...)>;
                                      state: optional<(...)>;
                                      variant: optional<(...)>;
                                      workspace: optional<(...)>;
                                  },
                              >,
                          >;
                          part: Literal<["main"]>;
                          subject: Array$<SchemaClass<string, string, never>>;
                      },
                  >;
                  output: typeof Void;
              } & NewFields,
              Encoded<
                  { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                      input: Struct<
                          {
                              options: optional<
                                  Struct<
                                      {
                                          key: ...;
                                          pivotId: ...;
                                          positioning: ...;
                                          scrollIntoView: ...;
                                          state: ...;
                                          variant: ...;
                                          workspace: ...;
                                      },
                                  >,
                              >;
                              part: Literal<["main"]>;
                              subject: Array$<SchemaClass<string, string, never>>;
                          },
                      >;
                      output: typeof Void;
                  },
              >,
              R2
              | R3
              | Context<NewFields[keyof NewFields]>,
              {
                  input: {
                      options?: {
                          key?: string;
                          pivotId?: string;
                          positioning?: "start" | "end";
                          scrollIntoView?: boolean;
                          state?: true;
                          variant?: string;
                          workspace?: string;
                      };
                      part: "main";
                      subject: readonly string[];
                  };
              } & { output: void } & Constructor<NewFields>,
              LayoutAction.Open,
              {},
          >

      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
        }
      }

    • 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?: {
                              key?: string;
                              pivotId?: string;
                              positioning?: "start" | "end";
                              scrollIntoView?: boolean;
                              state?: true;
                              variant?: string;
                              workspace?: string;
                          };
                          part: "main";
                          subject: readonly string[];
                      };
                      output: void;
                  },
                  options: ParseOptions,
                  ast: Transformation,
              ) => Effect<
                  {
                      [K in string
                      | number
                      | symbol]: (
                          {
                              _tag: "dxos.org/plugin/layout/action/update-layout";
                              input: {
                                  options?: {
                                      key?: ...;
                                      pivotId?: ...;
                                      positioning?: ...;
                                      scrollIntoView?: ...;
                                      state?: ...;
                                      variant?: ...;
                                      workspace?: ...;
                                  };
                                  part: "main";
                                  subject: readonly string[];
                              };
                              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?: {
                                      key?: (...)
                                      | (...);
                                      pivotId?: (...) | (...);
                                      positioning?: (...) | (...) | (...);
                                      scrollIntoView?: (...) | (...) | (...);
                                      state?: (...) | (...);
                                      variant?: (...) | (...);
                                      workspace?: (...) | (...);
                                  };
                                  part: "main";
                                  subject: readonly string[];
                              };
                              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: optional<Struct<(...)>>;
                                  part: Literal<[(...)]>;
                                  subject: Array$<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: optional<(...)>;
                                  part: Literal<(...)>;
                                  subject: Array$<(...)>;
                              },
                          >;
                          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: optional<
                              Struct<
                                  {
                                      key: optional<(...)>;
                                      pivotId: optional<(...)>;
                                      positioning: optional<(...)>;
                                      scrollIntoView: optional<(...)>;
                                      state: optional<(...)>;
                                      variant: optional<(...)>;
                                      workspace: optional<(...)>;
                                  },
                              >,
                          >;
                          part: Literal<["main"]>;
                          subject: Array$<SchemaClass<string, string, never>>;
                      },
                  >;
                  output: typeof Void;
              } & NewFields,
              Encoded<
                  { _tag: tag<"dxos.org/plugin/layout/action/update-layout"> } & {
                      input: Struct<
                          {
                              options: optional<
                                  Struct<
                                      {
                                          key: ...;
                                          pivotId: ...;
                                          positioning: ...;
                                          scrollIntoView: ...;
                                          state: ...;
                                          variant: ...;
                                          workspace: ...;
                                      },
                                  >,
                              >;
                              part: Literal<["main"]>;
                              subject: Array$<SchemaClass<string, string, never>>;
                          },
                      >;
                      output: typeof Void;
                  },
              >,
              R2
              | R3
              | Context<NewFields[keyof NewFields]>,
              {
                  input: {
                      options?: {
                          key?: string;
                          pivotId?: string;
                          positioning?: "start" | "end";
                          scrollIntoView?: boolean;
                          state?: true;
                          variant?: string;
                          workspace?: string;
                      };
                      part: "main";
                      subject: readonly string[];
                  };
              } & { output: void } & Constructor<NewFields>,
              LayoutAction.Open,
              {},
          >

      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
        }
      }

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods