Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 | /**
* JSON Schema type for describing values. Supports primitives, arrays, objects,
* and object interfaces (i.e. an object with methods you can invoke),
* with recursive definitions.
*/
export type JsonSchema =
| PrimitiveJsonSchema
| ArrayJsonSchema
| ObjectJsonSchema
| InterfaceJsonSchema;
/**
* Primitive JSON Schema types (string, number, boolean).
*/
type PrimitiveJsonSchema = {
type: 'string' | 'number' | 'boolean';
description?: string;
};
/**
* Array JSON Schema with recursive item type.
*/
type ArrayJsonSchema = {
type: 'array';
description?: string;
items: JsonSchema;
};
/**
* Object JSON Schema with recursive property definitions.
*/
type ObjectJsonSchema = {
type: 'object';
description?: string;
properties: {
[key: string]: JsonSchema;
};
required?: string[];
additionalProperties?: boolean;
};
/**
* Schema describing an object interface — a reference to an object whose
* methods can be invoked. Used as the return-type schema for methods that
* hand back an object reference (whether local or across a boundary), so
* a client can learn the returned object's API inline from the parent
* description without an extra round-trip.
*
* The `methods` field is recursive: any method here can itself return an
* interface, and so on.
*
* Naming note: this schema describes an object interface. Whether the
* reference to that object is unforgeable (i.e. an ocap in the strict
* sense) is a property of the reference plumbing (which vat holds it,
* whether it crossed a CapTP boundary, etc.), not of the interface
* description itself. Same schema either way.
*/
type InterfaceJsonSchema = {
type: 'interface';
description?: string;
methods: {
[key: string]: MethodSchema;
};
};
/**
* Schema describing a method, including its purpose, arguments, and return value.
*/
export type MethodSchema = {
/**
* Description of the method's purpose and behavior.
*/
description: string;
/**
* Arguments of the method, keyed by argument name.
* Each argument includes its type and description.
*/
args: Record<string, JsonSchema>;
/**
* Names of the required arguments. Mirrors {@link ObjectJsonSchema.required}:
* an argument not listed here may be omitted by the caller, and an absent
* `required` means every argument in `args` is required.
*/
required?: string[];
/**
* Return value schema, including type and description.
*/
returns?: JsonSchema;
};
|