David
3a07c861b1
Six descriptors written from their pages replace the last stubs of tiers 1 and 2. A scene answers Activate and Deactivate through ctx.respond() with ActivationStarted and DeactivationStarted, the time and the cause filled in. device.raise(descriptor, name, payload) publishes DoorbellPress and the Event of a button on <root>/event with the endpoint and a new messageId; it throws a MessageError for an interface or instance the device did not declare, an event that answers a directive, a payload that does not fit and a message over 16000 bytes. TurnOn of a device with WakeOnLANController is deferred without the warning. On the wire: a doorbell has no properties object and proactivelyReported on the capability; SimpleEventSource is version 1.0, InventoryLevelSensor and WakeOnLANController version 3 (1.5.2: 1). A scene declared without options is announced as before. Alex2MQTT has no topic yet for the WakeUp event. 24 examples of the six pages are saved as fixtures. 267 tests pass, 241 before. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
101 lines
3.9 KiB
TypeScript
101 lines
3.9 KiB
TypeScript
/** A value that does not fit its schema: path is where ("payload.targetSetpoint.scale"), problem is what. */
|
|
export declare class SchemaError extends Error {
|
|
readonly path: string;
|
|
readonly problem: string;
|
|
constructor(path: string, problem: string);
|
|
}
|
|
export interface Schema<T> {
|
|
/** What the schema accepts, in the words of an error message: "an integer from 0 to 100", "ON | OFF". */
|
|
readonly expects: string;
|
|
/** The checked value. path names it in the error message. */
|
|
parse(input: unknown, path?: string): T;
|
|
}
|
|
/** A schema that accepts a missing value; s.object() makes its key optional in the inferred type. */
|
|
export interface OptionalSchema<T> extends Schema<T | undefined> {
|
|
readonly optional: true;
|
|
}
|
|
export interface EnumSchema<V> extends Schema<V> {
|
|
readonly values: readonly V[];
|
|
}
|
|
/** The type a schema produces. */
|
|
export type Infer<S> = S extends Schema<infer T> ? T : never;
|
|
export type Shape = Record<string, Schema<any>>;
|
|
type OptionalKeys<S extends Shape> = {
|
|
[K in keyof S]: S[K] extends OptionalSchema<any> ? K : never;
|
|
}[keyof S];
|
|
export type InferShape<S extends Shape> = {
|
|
[K in Exclude<keyof S, OptionalKeys<S>>]: Infer<S[K]>;
|
|
} & {
|
|
[K in OptionalKeys<S>]?: Infer<S[K]>;
|
|
};
|
|
export interface NumberRules {
|
|
min?: number;
|
|
max?: number;
|
|
/** Greater than, the bound itself excluded. */
|
|
gt?: number;
|
|
integer?: boolean;
|
|
}
|
|
export interface Temperature {
|
|
value: number;
|
|
scale: "CELSIUS" | "FAHRENHEIT" | "KELVIN";
|
|
}
|
|
export interface TimeInterval {
|
|
start?: string;
|
|
end?: string;
|
|
duration?: string;
|
|
}
|
|
/** The error of a value that is not what a schema expects. */
|
|
export declare function mismatch(path: string, expects: string, input: unknown): SchemaError;
|
|
/** The path of a key of the object at path. */
|
|
export declare const at: (path: string, key: string) => string;
|
|
declare function number(rules?: NumberRules): Schema<number>;
|
|
declare function string(rules?: {
|
|
min?: number;
|
|
max?: number;
|
|
pattern?: RegExp;
|
|
expects?: string;
|
|
}): Schema<string>;
|
|
declare function boolean(): Schema<boolean>;
|
|
declare function literal<V extends string | number | boolean | null>(value: V): Schema<V>;
|
|
declare function enumeration<V extends readonly string[]>(...values: V): EnumSchema<V[number]>;
|
|
/** One of a list too long to print in an error message: expects says what the list is. */
|
|
declare function oneOf<V extends string>(values: readonly V[], expects: string): EnumSchema<V>;
|
|
declare function unknown(): Schema<unknown>;
|
|
declare function optional<T>(inner: Schema<T>): OptionalSchema<T>;
|
|
/** A value that is made when none is given: the time of an event, which is now unless the caller says when. */
|
|
declare function defaulted<T>(inner: Schema<T>, make: () => T): Schema<T>;
|
|
declare function nullable<T>(inner: Schema<T>): Schema<T | null>;
|
|
declare function array<T>(item: Schema<T>, rules?: {
|
|
min?: number;
|
|
max?: number;
|
|
}): Schema<T[]>;
|
|
/**
|
|
* An object with the keys of shape. Keys the shape does not name are kept as they are: a field Alexa adds to a
|
|
* directive reaches the handler. unknownKeys "reject" is for what a developer writes, where such a key is a typo.
|
|
*/
|
|
declare function object<S extends Shape>(shape: S, rules?: {
|
|
unknownKeys?: "keep" | "reject";
|
|
}): Schema<InferShape<S>>;
|
|
declare function temperature(): Schema<Temperature>;
|
|
declare function dateTime(): Schema<string>;
|
|
declare function duration(): Schema<string>;
|
|
declare function timeInterval(): Schema<TimeInterval>;
|
|
export declare const s: {
|
|
string: typeof string;
|
|
number: typeof number;
|
|
boolean: typeof boolean;
|
|
literal: typeof literal;
|
|
enum: typeof enumeration;
|
|
oneOf: typeof oneOf;
|
|
unknown: typeof unknown;
|
|
optional: typeof optional;
|
|
defaulted: typeof defaulted;
|
|
nullable: typeof nullable;
|
|
array: typeof array;
|
|
object: typeof object;
|
|
temperature: typeof temperature;
|
|
dateTime: typeof dateTime;
|
|
duration: typeof duration;
|
|
timeInterval: typeof timeInterval;
|
|
};
|
|
export {};
|