@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/v1/language/.spec/schemas/draft-2020-12.schema.json

@@ -0,0 +1,462 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://schemas.astrale.ai/dsl/v1/draft-2020-12",
+    "title": "JSON Schema Draft 2020-12",
+    "$comment": "The Draft 2020-12 meta-schemas the V1 value-schema dialect composes, each under its own $id, exactly as the validator of the dialect embeds them. With value-schema.schema.json, they resolve the dialect without a network fetch.",
+    "$defs": {
+        "schema": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/schema",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/core": true,
+                "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+                "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+                "https://json-schema.org/draft/2020-12/vocab/validation": true,
+                "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+                "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+                "https://json-schema.org/draft/2020-12/vocab/content": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Core and Validation specifications meta-schema",
+            "allOf": [
+                {
+                    "$ref": "meta/core"
+                },
+                {
+                    "$ref": "meta/applicator"
+                },
+                {
+                    "$ref": "meta/unevaluated"
+                },
+                {
+                    "$ref": "meta/validation"
+                },
+                {
+                    "$ref": "meta/meta-data"
+                },
+                {
+                    "$ref": "meta/format-annotation"
+                },
+                {
+                    "$ref": "meta/content"
+                }
+            ],
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+            "properties": {
+                "definitions": {
+                    "$comment": "\"definitions\" has been replaced by \"$defs\".",
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "deprecated": true,
+                    "default": {}
+                },
+                "dependencies": {
+                    "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "anyOf": [
+                            {
+                                "$dynamicRef": "#meta"
+                            },
+                            {
+                                "$ref": "meta/validation#/$defs/stringArray"
+                            }
+                        ]
+                    },
+                    "deprecated": true,
+                    "default": {}
+                },
+                "$recursiveAnchor": {
+                    "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+                    "$ref": "meta/core#/$defs/anchorString",
+                    "deprecated": true
+                },
+                "$recursiveRef": {
+                    "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+                    "$ref": "meta/core#/$defs/uriReferenceString",
+                    "deprecated": true
+                }
+            }
+        },
+        "core": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/core",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/core": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Core vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "$id": {
+                    "$ref": "#/$defs/uriReferenceString",
+                    "$comment": "Non-empty fragments not allowed.",
+                    "pattern": "^[^#]*#?$"
+                },
+                "$schema": {
+                    "$ref": "#/$defs/uriString"
+                },
+                "$ref": {
+                    "$ref": "#/$defs/uriReferenceString"
+                },
+                "$anchor": {
+                    "$ref": "#/$defs/anchorString"
+                },
+                "$dynamicRef": {
+                    "$ref": "#/$defs/uriReferenceString"
+                },
+                "$dynamicAnchor": {
+                    "$ref": "#/$defs/anchorString"
+                },
+                "$vocabulary": {
+                    "type": "object",
+                    "propertyNames": {
+                        "$ref": "#/$defs/uriString"
+                    },
+                    "additionalProperties": {
+                        "type": "boolean"
+                    }
+                },
+                "$comment": {
+                    "type": "string"
+                },
+                "$defs": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    }
+                }
+            },
+            "$defs": {
+                "anchorString": {
+                    "type": "string",
+                    "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+                },
+                "uriString": {
+                    "type": "string",
+                    "format": "uri"
+                },
+                "uriReferenceString": {
+                    "type": "string",
+                    "format": "uri-reference"
+                }
+            }
+        },
+        "applicator": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/applicator": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Applicator vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "prefixItems": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "items": {
+                    "$dynamicRef": "#meta"
+                },
+                "contains": {
+                    "$dynamicRef": "#meta"
+                },
+                "additionalProperties": {
+                    "$dynamicRef": "#meta"
+                },
+                "properties": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "default": {}
+                },
+                "patternProperties": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "propertyNames": {
+                        "format": "regex"
+                    },
+                    "default": {}
+                },
+                "dependentSchemas": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "default": {}
+                },
+                "propertyNames": {
+                    "$dynamicRef": "#meta"
+                },
+                "if": {
+                    "$dynamicRef": "#meta"
+                },
+                "then": {
+                    "$dynamicRef": "#meta"
+                },
+                "else": {
+                    "$dynamicRef": "#meta"
+                },
+                "allOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "anyOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "oneOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "not": {
+                    "$dynamicRef": "#meta"
+                }
+            },
+            "$defs": {
+                "schemaArray": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "$dynamicRef": "#meta"
+                    }
+                }
+            }
+        },
+        "unevaluated": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Unevaluated applicator vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "unevaluatedItems": {
+                    "$dynamicRef": "#meta"
+                },
+                "unevaluatedProperties": {
+                    "$dynamicRef": "#meta"
+                }
+            }
+        },
+        "validation": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/validation",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/validation": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Validation vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "type": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/$defs/simpleTypes"
+                        },
+                        {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/$defs/simpleTypes"
+                            },
+                            "minItems": 1,
+                            "uniqueItems": true
+                        }
+                    ]
+                },
+                "const": true,
+                "enum": {
+                    "type": "array",
+                    "items": true
+                },
+                "multipleOf": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
+                "maximum": {
+                    "type": "number"
+                },
+                "exclusiveMaximum": {
+                    "type": "number"
+                },
+                "minimum": {
+                    "type": "number"
+                },
+                "exclusiveMinimum": {
+                    "type": "number"
+                },
+                "maxLength": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minLength": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "pattern": {
+                    "type": "string",
+                    "format": "regex"
+                },
+                "maxItems": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minItems": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "uniqueItems": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "maxContains": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minContains": {
+                    "$ref": "#/$defs/nonNegativeInteger",
+                    "default": 1
+                },
+                "maxProperties": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minProperties": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "required": {
+                    "$ref": "#/$defs/stringArray"
+                },
+                "dependentRequired": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$ref": "#/$defs/stringArray"
+                    }
+                }
+            },
+            "$defs": {
+                "nonNegativeInteger": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "nonNegativeIntegerDefault0": {
+                    "$ref": "#/$defs/nonNegativeInteger",
+                    "default": 0
+                },
+                "simpleTypes": {
+                    "enum": [
+                        "array",
+                        "boolean",
+                        "integer",
+                        "null",
+                        "number",
+                        "object",
+                        "string"
+                    ]
+                },
+                "stringArray": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true,
+                    "default": []
+                }
+            }
+        },
+        "meta-data": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Meta-data vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "title": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "default": true,
+                "deprecated": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "readOnly": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "writeOnly": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "examples": {
+                    "type": "array",
+                    "items": true
+                }
+            }
+        },
+        "format-annotation": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Format vocabulary meta-schema for annotation results",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "format": {
+                    "type": "string"
+                }
+            }
+        },
+        "content": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/content",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/content": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Content vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "contentEncoding": {
+                    "type": "string"
+                },
+                "contentMediaType": {
+                    "type": "string"
+                },
+                "contentSchema": {
+                    "$dynamicRef": "#meta"
+                }
+            }
+        }
+    }
+}

package/dist/v1/language/.spec/schemas/value-schema.schema.json

@@ -0,0 +1,22 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://schemas.astrale.ai/dsl/v1/value-schema",
+    "$dynamicAnchor": "meta",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true,
+        "https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary": true
+    },
+    "title": "Astrale V1 value schema",
+    "$comment": "The meta-schema of the V1 value-schema dialect: Draft 2020-12 and the required Astrale vocabulary (fullMatch, x-astrale-path, x-astrale-value-kind). Its $dynamicAnchor extends Draft 2020-12 at every subschema, not only the root. The rules of the profile beyond it are published as schema.values.RULES.",
+    "allOf": [{ "$ref": "https://json-schema.org/draft/2020-12/schema" }],
+    "properties": {
+        "fullMatch": { "type": "string" },
+        "x-astrale-path": { "type": "object" }
+    }
+}

package/dist/v1/language/callable/admission.d.ts

@@ -0,0 +1,15 @@
+import type { CallablePolicy } from '../policy/model/policy.js';
+/**
+ * The language ceiling of a declared admission age, in seconds. Raising it later widens the
+ * language; lowering it would refuse accepted Schemas.
+ */
+export declare const MAXIMUM_ADMISSION_AGE_SECONDS = 300;
+/** Whether `value` is a declarable admission age: an integer from 1 to the language ceiling. */
+export declare function isAdmissionMaxAge(value: unknown): value is number;
+/**
+ * The input fields an admission of this callable reads: the `field` of every `input` check object
+ * of its Policy, unique and in Unicode code-point order. A callable without Policy checks reads no
+ * input field. Two calls that agree on these fields, and on everything else the admission reads,
+ * receive the same admission.
+ */
+export declare function admissionInputFields(policy: CallablePolicy | undefined): readonly string[];

package/dist/v1/language/callable/admission.js

@@ -0,0 +1,43 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+/**
+ * The language ceiling of a declared admission age, in seconds. Raising it later widens the
+ * language; lowering it would refuse accepted Schemas.
+ */
+export const MAXIMUM_ADMISSION_AGE_SECONDS = 300;
+/** Whether `value` is a declarable admission age: an integer from 1 to the language ceiling. */
+export function isAdmissionMaxAge(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= 1 &&
+        value <= MAXIMUM_ADMISSION_AGE_SECONDS);
+}
+/**
+ * The input fields an admission of this callable reads: the `field` of every `input` check object
+ * of its Policy, unique and in Unicode code-point order. A callable without Policy checks reads no
+ * input field. Two calls that agree on these fields, and on everything else the admission reads,
+ * receive the same admission.
+ */
+export function admissionInputFields(policy) {
+    if (policy === undefined || policy === true)
+        return Object.freeze([]);
+    const fields = new Set();
+    collectInputFields(policy, fields);
+    return Object.freeze([...fields].sort(compareUnicode));
+}
+function collectInputFields(expression, fields) {
+    if ('check' in expression) {
+        if (expression.object.kind === 'input')
+            fields.add(expression.object.field);
+        return;
+    }
+    if ('sameNode' in expression) {
+        for (const object of [expression.sameNode.left, expression.sameNode.right]) {
+            if (object.kind === 'input')
+                fields.add(object.field);
+        }
+        return;
+    }
+    for (const child of 'allOf' in expression ? expression.allOf : expression.anyOf) {
+        collectInputFields(child, fields);
+    }
+}

package/dist/v1/language/callable/model/callable.d.ts

@@ -21,6 +21,15 @@ export type OutputMode = CallableOutput['mode'];
 export interface CallableExecution {
     readonly durable: boolean;
 }
+/**
+ * Admission age of a callable: how old, in whole seconds, the admission decision used for one of its
+ * calls may be. A destination may reuse an admission it received within that age; a Runtime that
+ * never reuses one conforms. Absent means every call is admitted afresh, and `maxAge` is an integer
+ * from 1 to `MAXIMUM_ADMISSION_AGE_SECONDS`.
+ */
+export interface CallableAdmission {
+    readonly maxAge: number;
+}
 /** A binary Function receives portable metadata and one required byte stream. */
 export interface BinaryInput {
     readonly mode: 'binary';
@@ -39,6 +48,7 @@ export interface CallableDefinitionBase<Input extends CallableInputContract = Ca
     readonly input: Input;
     readonly output: CallableOutput;
     readonly execution?: CallableExecution;
+    readonly admission?: CallableAdmission;
 }
 export type CallableDefinition<Input extends CallableInputContract = CallableInputContract> = CallableDefinitionBase<Input> & ({
     readonly auth: 'anonymous' | 'authenticated';

package/dist/v1/language/callable/resolved.d.ts

@@ -1,8 +1,9 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressing/index.js';
 import type { ResolvedClass } from '../class/resolved.js';
 import type { CallablePolicy } from '../policy/model/policy.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
-import type { BinaryInputProjection, CallableExecution, FunctionDefinition, MethodDefinition } from './model/callable.js';
+import type { BinaryInputProjection, CallableAdmission, CallableExecution, FunctionDefinition, MethodDefinition } from './model/callable.js';
 import type { FunctionAuth } from './model/callable.js';
 type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefinition, Auth extends FunctionAuth, Policy extends CallablePolicy> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
     readonly auth: Auth;
@@ -22,6 +23,8 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
     readonly output: MethodDefinition['output'];
     /** Present only for a durable Method. */
     readonly execution?: CallableExecution;
+    /** Present only when the Method declares an admission age. */
+    readonly admission?: CallableAdmission;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
@@ -34,7 +37,11 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
         readonly static: Static;
         readonly abstract: Abstract;
     };
-    validateInput(input: unknown): readonly Diagnostic[];
+    /**
+     * The issues of `input` against the callable's input schema, `options` overriding the portable
+     * limits it is admitted under: those it crossed the wire under, for a call's input.
+     */
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
     readonly __input?: Input;
@@ -53,12 +60,18 @@ export interface ResolvedFunction<out Input = unknown, out Output = unknown, out
     readonly output: FunctionDefinition['output'];
     /** Present only for a durable Function. */
     readonly execution?: CallableExecution;
+    /** Present only when the Function declares an admission age. */
+    readonly admission?: CallableAdmission;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     /** Present only when the callable input is a safely enumerable closed object. */
     readonly inputFields?: readonly string[];
     readonly definition: CallableDefinitionOf<FunctionDefinition, Auth, Policy>;
-    validateInput(input: unknown): readonly Diagnostic[];
+    /**
+     * The issues of `input` against the callable's input schema, `options` overriding the portable
+     * limits it is admitted under: those it crossed the wire under, for a call's input.
+     */
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
     readonly __input?: Input;

package/dist/v1/language/class/inheritance.d.ts

@@ -1,12 +1,43 @@
 import type { ClassRef } from '../../addressing/index.js';
-import type { ClassKind } from './model/class.js';
-/** The representation shared by source, compiled and resolved Class admission. */
-export interface ClassInheritance {
+import type { ClassKind, Inheritance } from './model/class.js';
+import type { EdgeContract, EdgeCount } from './model/edge.js';
+/** A Class as satisfaction reads it, shared by source, compiled and resolved Class admission. */
+export interface ClassAncestry {
     readonly ref: ClassRef;
     readonly kind: ClassKind;
     readonly extends: readonly ClassRef[];
 }
+/** The origin of the Kernel, whose Schema every Domain depends on. */
+export declare const KERNEL_ORIGIN = "kernel.astrale.ai";
 /** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
-export declare function isGraphRoot(value: Pick<ClassInheritance, 'ref' | 'kind'>): boolean;
+export declare function isGraphRoot(value: Pick<ClassAncestry, 'ref' | 'kind'>): boolean;
 /** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
-export declare function classSatisfies(candidate: ClassInheritance, required: ClassInheritance, resolve: (ref: ClassRef) => ClassInheritance | undefined): boolean;
+export declare function classSatisfies(candidate: ClassAncestry, required: ClassAncestry, resolve: (ref: ClassRef) => ClassAncestry | undefined): boolean;
+/** The inheritance a Class declares, `'internal'` when it declares none. */
+export declare function inheritanceOf(declaration: {
+    readonly inheritance?: Inheritance;
+}): Inheritance;
+/**
+ * Whether a Class of another Domain may extend this Class: only an `'open'` one admits it. Its own
+ * Domain may extend any Class that is not `'final'`.
+ */
+export declare function admitsForeignSubclass(declaration: {
+    readonly inheritance?: Inheritance;
+}): boolean;
+/**
+ * Whether `child` safely refines its parent Edge contract `parent`: same orientation, at least the
+ * parent's constraints, and endpoints whose accepted Classes `satisfies` one the paired parent
+ * endpoint accepts, within its count. Undirected endpoints may pair in either order.
+ */
+export declare function edgeContractRefines(child: EdgeContract, parent: EdgeContract & Pick<ClassAncestry, 'ref' | 'kind'>, satisfies: (candidate: ClassRef, accepts: readonly ClassRef[]) => boolean): boolean;
+/** Interpret an Edge count as inclusive degree bounds. */
+export declare function countBounds(value: EdgeCount): readonly [number, number];
+/** Whether Edges of one Class, read from source to target, close a cycle (`acyclic` forbids it). */
+export declare function hasDirectedCycle(edges: readonly {
+    readonly source: {
+        readonly key: string;
+    };
+    readonly target: {
+        readonly key: string;
+    };
+}[]): boolean;