This node's readiness aggregate — same element shape as NodeStatus.resourceReadiness.
Source src/FleetHealth.ts:484 lines
export class class LocalHealthclass LocalHealth {
status: 'ok' | 'degraded';
resources: ReadonlyArray<any>;
}
This node's readiness aggregate — same element shape as
NodeStatus.resourceReadiness
.
LocalHealth extends import SchemaSchema.const Class: <LocalHealth, {}>(identifier: string) => {
<Fields>(fields: Fields, annotations?: Schema.Annotations.Declaration<LocalHealth, readonly [Schema.Struct<Fields>]> | undefined): Schema.Class<LocalHealth, Schema.Struct<Fields>, {}>;
<S>(schema: S, annotations?: Schema.Annotations.Declaration<LocalHealth, readonly [S]> | undefined): Schema.Class<LocalHealth, S, {}>;
}
Creates a schema-backed class whose constructor validates input against a
Struct
schema. Construction throws a
SchemaError
on invalid
input.
When to use
Use when you need a schema-backed data class with validated construction,
schema-derived decoding/encoding, and class-style methods or inheritance.
Details
Pass the desired class type as the first type parameter. The second optional
type parameter can be used to add nominal brands.
Gotchas
Passing disableChecks in the options skips constructor validation.
Example (Defining a basic class)
import { Schema } from "effect"
class Person extends Schema.Class<Person>("Person")({
name: Schema.String,
age: Schema.Number
}) {}
const alice = new Person({ name: "Alice", age: 30 })
console.log(alice.name) // "Alice"
console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
Example (Extending a class)
import { Schema } from "effect"
class Animal extends Schema.Class<Animal>("Animal")({
name: Schema.String
}) {}
class Dog extends Animal.extend<Dog>("Dog")({
breed: Schema.String
}) {}
const dog = new Dog({ name: "Rex", breed: "Labrador" })
console.log(dog.name) // "Rex"
console.log(dog.breed) // "Labrador"
Class<class LocalHealthclass LocalHealth {
status: 'ok' | 'degraded';
resources: ReadonlyArray<any>;
}
This node's readiness aggregate — same element shape as
NodeStatus.resourceReadiness
.
LocalHealth>("FleetHealthLocal")({
status: Schema.Literals<
readonly ["ok", "degraded"]
>
(property) status: {
literals: L;
members: { readonly [K in keyof L]: Literal<L[K]>; };
mapMembers: (f: (members: readonly [Schema.Literal<'ok'>, Schema.Literal<'degraded'>]) => To) => Schema.Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
pick: (literals: L2) => Schema.Literals<L2>;
transform: (to: L2) => Schema.Union<readonly [Schema.decodeTo<Schema.Literal<L2['0']>, Schema.Literal<'ok'>, never, never>, Schema.decodeTo<Schema.Literal<L2['1']>, Schema.Literal<'degraded'>, never, never>]>;
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<'ok' | 'degraded', readonly []>) => Schema.Literals<readonly ['ok', 'degraded']>;
annotateKey: (annotations: Schema.Annotations.Key<'ok' | 'degraded'>) => Schema.Literals<readonly ['ok', 'degraded']>;
check: (checks_0: Check<'ok' | 'degraded'>, ...checks: Array<Check<'ok' | 'degraded'>>) => Schema.Literals<readonly ['ok', 'degraded']>;
rebuild: (ast: Union<Literal>) => Schema.Literals<readonly ['ok', 'degraded']>;
make: (input: 'ok' | 'degraded', options?: Schema.MakeOptions) => 'ok' | 'degraded';
makeOption: (input: 'ok' | 'degraded', options?: Schema.MakeOptions) => Option<'ok' | 'degraded'>;
makeEffect: (input: 'ok' | 'degraded', options?: Schema.MakeOptions) => Effect.Effect<'ok' | 'degraded', Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.function Literals<readonly ["ok", "degraded"]>(literals: readonly ["ok", "degraded"]): Schema.Literals<readonly ["ok", "degraded"]>Creates a union schema from an array of literal values.
Example (Defining status codes)
import { Schema } from "effect"
const schema = Schema.Literals(["active", "inactive", "pending"])
// accepts "active", "inactive", or "pending"
Literals(["ok", "degraded"]),
resources: Schema.$Array<any>(property) resources: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<any>, readonly []>) => Schema.$Array<any>;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<any>>) => Schema.$Array<any>;
check: (checks_0: Check<ReadonlyArray<any>>, ...checks: Array<Check<ReadonlyArray<any>>>) => Schema.$Array<any>;
rebuild: (ast: Arrays) => Schema.$Array<any>;
make: (input: ReadonlyArray<any>, options?: Schema.MakeOptions) => ReadonlyArray<any>;
makeOption: (input: ReadonlyArray<any>, options?: Schema.MakeOptions) => Option<ReadonlyArray<any>>;
makeEffect: (input: ReadonlyArray<any>, options?: Schema.MakeOptions) => Effect.Effect<ReadonlyArray<any>, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.Array<any>(self: any): Schema.$Array<any>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(import NodeStatusNodeStatus.resourceReadiness),
}) {}