@fgv/ts-json 3.0.1-alpha.6 → 4.0.1

package/dist/ts-json.d.ts

@@ -45,7 +45,7 @@ export declare class CompositeJsonMap implements IJsonReferenceMap {
      */
     has(key: string): boolean;
     /**
-     * Gets a {@link JsonObject | JSON object} specified by key.
+     * Gets a JSON object specified by key.
      * @param key - The key of the object to be retrieved.
      * @param context - An optional {@link IJsonContext | JSON Context} used to format the object.
      * @returns `Success` with the formatted object if successful. `Failure` with detail `'unknown'`
@@ -54,7 +54,7 @@ export declare class CompositeJsonMap implements IJsonReferenceMap {
      */
     getJsonObject(key: string, context?: IJsonContext): DetailedResult<JsonObject, JsonReferenceMapFailureReason>;
     /**
-     * Gets a {@link JsonValue | JSON value} specified by key.
+     * Gets a JSON value specified by key.
      * @param key - The key of the object to be retrieved.
      * @param context - An optional {@link IJsonContext | JSON Context} used to format the value.
      * @returns `Success` with the formatted object if successful. `Failure` with detail `'unknown'`
@@ -110,7 +110,7 @@ export declare class ConditionalJsonConverter extends JsonEditorConverter {
 export declare type ConditionalJsonConverterOptions = Omit<TemplatedJsonConverterOptions, 'useConditionalNames'>;
 
 /**
- * The {@link Editor.Rules.ConditionalJsonEditorRule | ConditionalJsonEditorRule} evaluates
+ * The {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule} evaluates
  * properties with conditional keys, omitting non-matching keys and merging keys that match,
  * or default keys only if no other keys match.
  *
@@ -122,30 +122,30 @@ export declare type ConditionalJsonConverterOptions = Omit<TemplatedJsonConverte
  */
 declare class ConditionalJsonEditorRule extends JsonEditorRuleBase {
     /**
-     * Stored fully-resolved {@link Editor.Rules.IConditionalJsonRuleOptions | options} for this
+     * Stored fully-resolved {@link EditorRules.IConditionalJsonRuleOptions | options} for this
      * rule.
      * @public
      */
     protected _options?: IConditionalJsonRuleOptions;
     /**
-     * Creates a new {@link Editor.Rules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
-     * @param options - Optional {@link Editor.Rules.IConditionalJsonRuleOptions | configuration options}
+     * Creates a new {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+     * @param options - Optional {@link EditorRules.IConditionalJsonRuleOptions | configuration options}
      * used for this rule.
      */
     constructor(options?: IConditionalJsonRuleOptions);
     /**
-     * Creates a new {@link Editor.Rules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
-     * @param options - Optional {@link Editor.Rules.IConditionalJsonRuleOptions | configuration options}
+     * Creates a new {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+     * @param options - Optional {@link EditorRules.IConditionalJsonRuleOptions | configuration options}
      * used for this rule.
      */
     static create(options?: IConditionalJsonRuleOptions): Result<ConditionalJsonEditorRule>;
     /**
      * Evaluates a property for conditional application.
      * @param key - The key of the property to be considered
-     * @param value - The {@link JsonValue | value} of the property to be considered.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
      * @returns Returns `Success` with detail `'deferred'` and a
-     * {@link Editor.Rules.IConditionalJsonDeferredObject | IConditionalJsonDeferredObject}.
+     * {@link EditorRules.IConditionalJsonDeferredObject | IConditionalJsonDeferredObject}.
      * for a matching, default or unconditional key. Returns `Failure` with detail `'ignore'` for
      * a non-matching conditional, or with detail `'error'` if an error occurs. Otherwise
      * fails with detail `'inapplicable'`.
@@ -155,17 +155,17 @@ declare class ConditionalJsonEditorRule extends JsonEditorRuleBase {
      * Finalizes any deferred conditional properties. If the only deferred property is
      * default, that property is emitted. Otherwise all matching properties are emitted.
      * @param finalized - The deferred properties to be considered for merge.
-     * @param __state - The {@link Editor.JsonEditorState | editor state} for the object
+     * @param __state - The {@link JsonEditorState | editor state} for the object
      * being edited.
      */
     finalizeProperties(finalized: JsonObject[], __state: JsonEditorState): DetailedResult<JsonObject[], JsonEditFailureReason>;
     /**
      * Determines if a given property key is conditional. Derived classes can override this
      * method to use a different format for conditional properties.
-     * @param value - The {@link JsonValue | value} of the property to be considered.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
      * @returns `Success` with detail `'deferred'` and a
-     * {@link Editor.Rules.IConditionalJsonKeyResult | IConditionalJsonKeyResult} describing the
+     * {@link EditorRules.IConditionalJsonKeyResult | IConditionalJsonKeyResult} describing the
      * match for a default or matching conditional property.  Returns `Failure` with detail `'ignore'`
      * for a non-matching conditional property. Fails with detail `'error'` if an error occurs
      * or with detail `'inapplicable'` if the key does not represent a conditional property.
@@ -193,7 +193,7 @@ declare class ConditionalJsonEditorRule extends JsonEditorRuleBase {
 export declare function contextFromConverterOptions(partial?: Partial<IJsonConverterOptions>): IJsonContext | undefined;
 
 /**
- * Creates a new {@link Editor.JsonEditor | JsonEditor} from an optionally supplied partial
+ * Creates a new {@link JsonEditor | JsonEditor} from an optionally supplied partial
  * {@link IJsonConverterOptions | JSON converter options}.
  * Expands supplied options with default values and constructs an editor with
  * matching configuration and defined rules.
@@ -240,8 +240,8 @@ declare namespace EditorRules {
 export { EditorRules }
 
 /**
- * On a successful match, the {@link Editor.Rules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}
- * stores a {@link Editor.Rules.IConditionalJsonDeferredObject | IConditionalJsonDeferredObject} describing the
+ * On a successful match, the {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}
+ * stores a {@link EditorRules.IConditionalJsonDeferredObject | IConditionalJsonDeferredObject} describing the
  * matching result, to be resolved at finalization time.
  * @public
  */
@@ -250,7 +250,7 @@ declare interface IConditionalJsonDeferredObject extends IConditionalJsonKeyResu
 }
 
 /**
- * Returned by {@link Editor.Rules.ConditionalJsonEditorRule._tryParseCondition | ConditionalJsonEditorRule._tryParseCondition}
+ * Returned by {@link EditorRules.ConditionalJsonEditorRule._tryParseCondition | ConditionalJsonEditorRule._tryParseCondition}
  * to indicate whether a successful match was due to a matching condition or a default value.
  * @public
  */
@@ -259,7 +259,7 @@ declare interface IConditionalJsonKeyResult extends JsonObject {
 }
 
 /**
- * Configuration options for the {@link Editor.Rules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
+ * Configuration options for the {@link EditorRules.ConditionalJsonEditorRule | ConditionalJsonEditorRule}.
  * @public
  */
 declare interface IConditionalJsonRuleOptions extends Partial<IJsonEditorOptions> {
@@ -271,13 +271,13 @@ declare interface IConditionalJsonRuleOptions extends Partial<IJsonEditorOptions
 }
 
 /**
- * A specialized JSON editor which does a deep clone of a supplied {@link JsonValue | JsonValue}.
+ * A specialized JSON editor which does a deep clone of a supplied `JsonValue`.
  * @public
  */
 export declare interface IJsonCloneEditor {
     /**
-     * Returns a deep clone of a supplied {@link JsonValue | JsonValue}.
-     * @param src - The {@link JsonValue | JsonValue} to be cloned.
+     * Returns a deep clone of a supplied `JsonValue`.
+     * @param src - The `JsonValue` to be cloned.
      * @param context - An optional {@link IJsonContext | JSON context} used for clone
      * conversion operations.
      */
@@ -392,7 +392,7 @@ export declare interface IJsonConverterOptions {
 }
 
 /**
- * Initialization options for a {@link Editor.JsonEditor | JsonEditor}.
+ * Initialization options for a {@link JsonEditor | JsonEditor}.
  * @public
  */
 export declare interface IJsonEditorOptions {
@@ -401,29 +401,29 @@ export declare interface IJsonEditorOptions {
 }
 
 /**
- * An {@link Editor.IJsonEditorRule | IJsonEditorRule} represents a single configurable
- * rule to be applied by a {@link Editor.JsonEditor | JsonEditor}.
+ * An {@link IJsonEditorRule | IJsonEditorRule} represents a single configurable
+ * rule to be applied by a {@link JsonEditor | JsonEditor}.
  * @public
  */
 export declare interface IJsonEditorRule {
     /**
-     * Called by a {@link Editor.JsonEditor | JsonEditor} to possibly edit one of the properties being
+     * Called by a {@link JsonEditor | JsonEditor} to possibly edit one of the properties being
      * merged into a target object.
      * @param key - The key of the property to be edited.
-     * @param value - The {@link JsonValue | value} of the property to be edited.
-     * @param state - {@link Editor.JsonEditorState | Editor state} which applies to the edit.
-     * @returns If the property was edited, returns `Success` with a {@link JsonObject | JsonObject} containing
+     * @param value - The `JsonValue` of the property to be edited.
+     * @param state - {@link JsonEditorState | Editor state} which applies to the edit.
+     * @returns If the property was edited, returns `Success` with a `JsonObject` containing
      * the edited results and with detail `'edited'`. If this property should be deferred for later consideration
-     * or merge, `Success` with detail `'deferred'` and a {@link JsonObject | JsonObject} to be finalized.  If
+     * or merge, `Success` with detail `'deferred'` and a `JsonObject` to be finalized.  If
      * the rule does not affect this property, returns `Failure` with detail `'inapplicable'`. If an error occurred
      * while processing the error, returns `Failure` with detail `'error'`.
      */
     editProperty(key: string, value: JsonValue, state: JsonEditorState): DetailedResult<JsonObject, JsonPropertyEditFailureReason>;
     /**
-     * Called by a {@link Editor.JsonEditor | JsonEditor} to possibly edit a property value or array element.
-     * @param value - The {@link JsonValue | value} of the property to be edited.
-     * @param state - {@link Editor.JsonEditorState | Editor state} which applies to the edit.
-     * @returns Returns `Success` with the {@link JsonValue | JsonValue} to be inserted, with detail `'edited'` if
+     * Called by a {@link JsonEditor | JsonEditor} to possibly edit a property value or array element.
+     * @param value - The `JsonValue` of the property to be edited.
+     * @param state - {@link JsonEditorState | Editor state} which applies to the edit.
+     * @returns Returns `Success` with the `JsonValue` to be inserted, with detail `'edited'` if
      * the value was edited.  Returns `Failure` with `'inapplicable'` if the rule does not affect this value.
      * Fails with detail `'ignore'` if the value is to be ignored, or with `'error'` if an error occurs.
      */
@@ -431,8 +431,8 @@ export declare interface IJsonEditorRule {
     /**
      * Called for each rule after all properties have been merged.  Any properties that were deferred
      * during the initial edit pass are supplied as input.
-     * @param deferred - Any {@link JsonObject | objects} that were deferred during the first edit pass.
-     * @param state - {@link Editor.JsonEditorState | Editor state} which applies to the edit.
+     * @param deferred - Any JSON objects that were deferred during the first edit pass.
+     * @param state - {@link JsonEditorState | Editor state} which applies to the edit.
      * @returns On `Success` return, any returned objects are merged in order and finalization
      * is stopped. Finalization is also stopped on `Failure` with detail `'ignore'`. On `Failure`
      * with detail `'inapplicable'`, finalization continues with the next rule. Fails with an
@@ -442,7 +442,7 @@ export declare interface IJsonEditorRule {
 }
 
 /**
- * Validation options for a {@link Editor.JsonEditor | JsonEditor}.
+ * Validation options for a {@link JsonEditor | JsonEditor}.
  * @public
  */
 export declare interface IJsonEditorValidationOptions {
@@ -470,7 +470,7 @@ export declare interface IJsonEditorValidationOptions {
 }
 
 /**
- * Interface for a simple map that returns named {@link JsonValue | JsonValue} values with templating,
+ * Interface for a simple map that returns named `JsonValue` values with templating,
  * conditional logic, and external reference lookups applied using an optionally supplied context.
  * @public
  */
@@ -489,20 +489,20 @@ export declare interface IJsonReferenceMap {
      */
     has(key: string): boolean;
     /**
-     * Gets a {@link JsonObject | JsonObject} specified by key.
+     * Gets a `JsonObject` specified by key.
      * @param key - The key of the object to be retrieved.
      * @param context - Optional {@link IJsonContext | IJsonContext} used to construct
      * the object.
-     * @returns `Success` with the formatted {@link JsonObject | object} if successful. `Failure`
+     * @returns `Success` with the formatted JsonObject if successful. `Failure`
      * with detail `'unknown'`  if no such object exists, or `Failure` with detail `'error'` if
      * the object was found but could not be formatted.
      */
     getJsonObject(key: string, context?: IJsonContext): DetailedResult<JsonObject, JsonReferenceMapFailureReason>;
     /**
-     * Gets a {@link JsonValue | JsonValue} specified by key.
+     * Gets a `JsonValue` specified by key.
      * @param key - The key of the object to be retrieved.
      * @param context - Optional {@link IJsonContext | JSON Context} used to format the value
-     * @returns `Success` with the formatted {@link JsonValue | value} if successful. `Failure`
+     * @returns `Success` with the formatted `JsonValue` if successful. `Failure`
      * with detail `'unknown'` if no such object exists, or `Failure` with detail `'error'` if
      * the object was found but could not be formatted.
      */
@@ -545,7 +545,7 @@ declare interface IMultiValuePropertyParts {
     readonly propertyValues: string[];
     /**
      * If `true`, the resolved values are added as an array
-     * with the name of the {@link Editor.Rules.IMultiValuePropertyParts.propertyVariable | propertyVariable}.
+     * with the name of the {@link EditorRules.IMultiValuePropertyParts.propertyVariable | propertyVariable}.
      * If false, values are added as individual properties with names that correspond the value.
      */
     readonly asArray: boolean;
@@ -567,13 +567,13 @@ export declare interface IReferenceMapKeyPolicyValidateOptions {
  * Initialization options for a {@link SimpleJsonMap | SimpleJsonMap}.
  * @public
  */
-declare interface ISimpleJsonMapOptions {
+export declare interface ISimpleJsonMapOptions {
     keyPolicy?: ReferenceMapKeyPolicy<JsonValue>;
     editor?: JsonEditor;
 }
 
 /**
- * Configuration options for the {@link Editor.Rules.TemplatedJsonEditorRule | Templated JSON editor rule}.
+ * Configuration options for the {@link EditorRules.TemplatedJsonEditorRule | Templated JSON editor rule}.
  * @public
  */
 declare interface ITemplatedJsonRuleOptions extends Partial<IJsonEditorOptions> {
@@ -596,7 +596,7 @@ declare const json: JsonConverter;
 
 /**
  * A simple validating {@link JsonConverter | JSON converter}. Converts `unknown` to a
- * {@link JsonArray | JsonArray}, or fails if the unknown contains invalid JSON or is
+ * `JsonArray`, or fails if the unknown contains invalid JSON or is
  * not an array.
  * @public
  */
@@ -692,7 +692,7 @@ export declare class JsonContextHelper {
      */
     extendRefs(refs?: IJsonReferenceMap[]): Result<IJsonReferenceMap | undefined>;
     /**
-     * Applies {@link JsonContextHelper.(extendContext:static) | extendContext} to the
+     * Applies static `JsonContextHelper.extendContext` to the
      * {@link IJsonContext | IJsonContext} associated with this helper.
      * @param add - Optional initializer containing {@link VariableValue | variable values} and/or
      * {@link IJsonReferenceMap | reference maps} to be added to the {@link IJsonContext | context}.
@@ -705,7 +705,7 @@ export declare class JsonContextHelper {
         refs?: IJsonReferenceMap[];
     }): Result<IJsonContext | undefined>;
     /**
-     * Applies {@link JsonContextHelper.(mergeContext:static) | mergeContext} to the
+     * Applies static `JsonContextHelper.mergeContext` to the
      * {@link IJsonContext | IJsonContext} associated with this helper.
      * @param add - Optional initializer containing {@link VariableValue | variable values} and/or
      * {@link IJsonReferenceMap | reference maps} to be added to the {@link IJsonContext | context}.
@@ -753,48 +753,48 @@ export declare type JsonEditFailureReason = 'ignore' | 'inapplicable' | 'edited'
  */
 export declare class JsonEditor implements IJsonCloneEditor {
     /**
-     * Default singleton {@link Editor.JsonEditor | JsonEditor}.
+     * Default singleton {@link JsonEditor | JsonEditor}.
      * @internal
      */
     protected static _default?: JsonEditor;
     /**
-     * Full set of {@link Editor.IJsonEditorOptions | editor options} in effect for this editor.
+     * Full set of {@link IJsonEditorOptions | editor options} in effect for this editor.
      */
     options: IJsonEditorOptions;
     /**
-     * The set of {@link Editor.IJsonEditorRule | editor rules} applied by this editor.
+     * The set of {@link IJsonEditorRule | editor rules} applied by this editor.
      * @internal
      */
     protected _rules: IJsonEditorRule[];
     /**
-     * Protected constructor for {@link Editor.JsonEditor | JsonEditor} and derived classes.
-     * External consumers should instantiate via the {@link Editor.JsonEditor.create | create static method}.
-     * @param options - Optional partial {@link Editor.IJsonEditorOptions | editor options} for the
+     * Protected constructor for {@link JsonEditor | JsonEditor} and derived classes.
+     * External consumers should instantiate via the {@link JsonEditor.create | create static method}.
+     * @param options - Optional partial {@link IJsonEditorOptions | editor options} for the
      * constructed editor.
-     * @param rules - Any {@link Editor.IJsonEditorRule | editor rules} to be applied by the editor.
+     * @param rules - Any {@link IJsonEditorRule | editor rules} to be applied by the editor.
      * @internal
      */
     protected constructor(options?: Partial<IJsonEditorOptions>, rules?: IJsonEditorRule[]);
     /**
-     * Default singleton {@link Editor.JsonEditor | JsonEditor} for simple use. Applies all rules
+     * Default singleton {@link JsonEditor | JsonEditor} for simple use. Applies all rules
      * but with no default context.
      */
     static get default(): JsonEditor;
     /**
-     * Constructs a new {@link Editor.JsonEditor | JsonEditor}.
-     * @param options - Optional partial {@link Editor.IJsonEditorOptions | editor options} for the
+     * Constructs a new {@link JsonEditor | JsonEditor}.
+     * @param options - Optional partial {@link IJsonEditorOptions | editor options} for the
      * constructed editor.
-     * @param rules - Optional set of {@link Editor.IJsonEditorRule | editor rules} to be applied by the editor.
-     * @readonly A new {@link Editor.JsonEditor | JsonEditor}.
+     * @param rules - Optional set of {@link IJsonEditorRule | editor rules} to be applied by the editor.
+     * @readonly A new {@link JsonEditor | JsonEditor}.
      */
     static create(options?: Partial<IJsonEditorOptions>, rules?: IJsonEditorRule[]): Result<JsonEditor>;
     /**
      * Gets the default set of rules to be applied for a given set of options.
      * By default, all available rules (templates, conditionals, multi-value and references)
      * are applied.
-     * @param options - Optional partial {@link Editor.IJsonEditorOptions | editor options} for
+     * @param options - Optional partial {@link IJsonEditorOptions | editor options} for
      * all rules.
-     * @returns Default {@link Editor.IJsonEditorRule | editor rules} with any supplied options
+     * @returns Default {@link IJsonEditorRule | editor rules} with any supplied options
      * applied.
      */
     static getDefaultRules(options?: IJsonEditorOptions): Result<IJsonEditorRule[]>;
@@ -804,21 +804,21 @@ export declare class JsonEditor implements IJsonCloneEditor {
     protected static _getDefaultOptions(options?: Partial<IJsonEditorOptions>): Result<IJsonEditorOptions>;
     /**
      * Merges a supplied source object into a supplied target, updating the target object.
-     * @param target - The target {@link JsonObject | object} to be updated
-     * @param src - The source {@link JsonObject | object} to be merged
+     * @param target - The target `JsonObject` to be updated
+     * @param src - The source `JsonObject` to be merged
      * @param runtimeContext - An optional {@link IJsonContext | IJsonContext} supplying variables
      * and references.
-     * @returns `Success` with the original source {@link JsonObject | object} if merge was successful.
+     * @returns `Success` with the original source `JsonObject` if merge was successful.
      * Returns `Failure` with details if an error occurs.
      */
     mergeObjectInPlace(target: JsonObject, src: JsonObject, runtimeContext?: IJsonContext): Result<JsonObject>;
     /**
      * Merges multiple supplied source objects into a supplied target, updating the target
      * object and using the default context supplied at creation time.
-     * @param target - The target {@link JsonObject | object} to be updated
-     * @param srcObjects - {@link JsonObject | Objects} to be merged into the target object, in the order
+     * @param target - The target `JsonObject` to be updated
+     * @param srcObjects - `JsonObject`s to be merged into the target object, in the order
      * supplied.
-     * @returns `Success` with the original source {@link JsonObject | object} if merge was successful.
+     * @returns `Success` with the original source `JsonObject` if merge was successful.
      * Returns `Failure` with details if an error occurs.
      */
     mergeObjectsInPlace(target: JsonObject, srcObjects: JsonObject[]): Result<JsonObject>;
@@ -827,16 +827,16 @@ export declare class JsonEditor implements IJsonCloneEditor {
      * object and using an optional {@link IJsonContext | context} supplied in the call.
      * @param context - An optional {@link IJsonContext | IJsonContext} supplying variables and
      * references.
-     * @param base - The base {@link JsonObject | object} to be updated
+     * @param base - The base `JsonObject` to be updated
      * @param srcObjects - Objects to be merged into the target object, in the order supplied.
-     * @returns `Success` with the original source {@link JsonObject | object} if merge was successful.
+     * @returns `Success` with the original source `JsonObject` if merge was successful.
      * Returns `Failure` with details if an error occurs.
      */
     mergeObjectsInPlaceWithContext(context: IJsonContext | undefined, base: JsonObject, srcObjects: JsonObject[]): Result<JsonObject>;
     /**
-     * Deep clones a supplied {@link JsonValue | JSON value}, applying all editor rules and a default
+     * Deep clones a supplied `JsonValue`, applying all editor rules and a default
      * or optionally supplied context
-     * @param src - The {@link JsonValue | JsonValue} to be cloned.
+     * @param src - The `JsonValue` to be cloned.
      * @param context - An optional {@link IJsonContext | JSON context} supplying variables and references.
      */
     clone(src: JsonValue, context?: IJsonContext): DetailedResult<JsonValue, JsonEditFailureReason>;
@@ -895,90 +895,90 @@ export declare class JsonEditor implements IJsonCloneEditor {
 }
 
 /**
- * A thin wrapper to allow an arbitrary {@link Editor.JsonEditor | JsonEditor} to be used via the
+ * A thin wrapper to allow an arbitrary {@link JsonEditor | JsonEditor} to be used via the
  * \@fgv/ts-utils `Converter` pattern.
  * @public
  */
 export declare class JsonEditorConverter extends Conversion.BaseConverter<JsonValue, IJsonContext> {
     readonly editor: JsonEditor;
     /**
-     * Constructs a new {@link Editor.JsonEditor | JsonEditor}Converter which uses the supplied editor
+     * Constructs a new {@link JsonEditor | JsonEditor}Converter which uses the supplied editor
      * @param editor -
      */
     constructor(editor: JsonEditor);
     /**
-     * Constructs a new {@link Editor.JsonEditor | JsonEditor}Converter which uses the supplied editor
+     * Constructs a new {@link JsonEditor | JsonEditor}Converter which uses the supplied editor
      * @param editor -
      */
     static createWithEditor(editor: JsonEditor): Result<JsonEditorConverter>;
     /**
      * Gets a derived converter which fails if the resulting converted
-     * {@link JsonValue | JsonValue} is not a {@link JsonObject | JsonObject}.
+     * `JsonValue` is not a `JsonObject`.
      */
     object(): Converter<JsonObject, IJsonContext>;
     /**
      * Gets a derived converter which fails if the resulting converted
-     * {@link JsonValue | JsonValue} is not a {@link JsonArray | JsonArray}.
+     * `JsonValue` is not a `JsonArray`.
      */
     array(): Converter<JsonArray, IJsonContext>;
     protected _convert(from: unknown, context?: IJsonContext): Result<JsonValue>;
 }
 
 /**
- * Default base implementation of {@link Editor.IJsonEditorRule | IJsonEditorRule} returns inapplicable for all operations so that
+ * Default base implementation of {@link IJsonEditorRule | IJsonEditorRule} returns inapplicable for all operations so that
  * derived classes need only implement the operations they actually support.
  * @public
  */
-declare class JsonEditorRuleBase implements IJsonEditorRule {
+export declare class JsonEditorRuleBase implements IJsonEditorRule {
     /**
-     * {@inheritdoc Editor.IJsonEditorRule.editProperty}
+     * {@inheritdoc IJsonEditorRule.editProperty}
      */
     editProperty(__key: string, __value: JsonValue, __state: JsonEditorState): DetailedResult<JsonObject, JsonPropertyEditFailureReason>;
     /**
-     * {@inheritdoc Editor.IJsonEditorRule.editValue}
+     * {@inheritdoc IJsonEditorRule.editValue}
      */
     editValue(__value: JsonValue, __state: JsonEditorState): DetailedResult<JsonValue, JsonEditFailureReason>;
     /**
-     * {@inheritdoc Editor.IJsonEditorRule.finalizeProperties}
+     * {@inheritdoc IJsonEditorRule.finalizeProperties}
      */
     finalizeProperties(__deferred: JsonObject[], __state: JsonEditorState): DetailedResult<JsonObject[], JsonEditFailureReason>;
 }
 
 /**
- * Represents the internal state of a {@link Editor.JsonEditor | JsonEditor}.
+ * Represents the internal state of a {@link JsonEditor | JsonEditor}.
  * @public
  */
 export declare class JsonEditorState {
     /**
-     * Static global counter used to assign each {@link Editor.JsonEditorState | JsonEditorState}
+     * Static global counter used to assign each {@link JsonEditorState | JsonEditorState}
      * a unique identifier.
      * @internal
      */
     protected static _nextId: number;
     /**
-     * The {@link Editor.IJsonCloneEditor | editor} for which this state applies.
+     * The {@link IJsonCloneEditor | editor} for which this state applies.
      */
     readonly editor: IJsonCloneEditor;
     /**
-     * Fully resolved {@link Editor.IJsonEditorOptions | editor options} that apply
+     * Fully resolved {@link IJsonEditorOptions | editor options} that apply
      * to the operation for which this state applies.
      */
     readonly options: IJsonEditorOptions;
     /**
-     * Any deferred {@link JsonObject | objects} to be merged during finalization.
+     * Any deferred JSON objects to be merged during finalization.
      * @internal
      */
     protected readonly _deferred: JsonObject[];
     /**
-     * Unique global identifier for this {@link Editor.JsonEditorState | state object}.
+     * Unique global identifier for this {@link JsonEditorState | state object}.
      * @internal
      */
     protected readonly _id: number;
     /**
-     * Constructs a new {@link Editor.JsonEditorState | JsonEditorState}.
-     * @param editor - The {@link Editor.IJsonCloneEditor | editor} to which this state
+     * Constructs a new {@link JsonEditorState | JsonEditorState}.
+     * @param editor - The {@link IJsonCloneEditor | editor} to which this state
      * applies.
-     * @param baseOptions - The {@link Editor.IJsonEditorOptions | editor options} that
+     * @param baseOptions - The {@link IJsonEditorOptions | editor options} that
      * apply to this rule.
      * @param runtimeContext - An optional {@link IJsonContext | JSON context} to be used
      * for json value conversion.
@@ -989,31 +989,31 @@ export declare class JsonEditorState {
      */
     get context(): IJsonContext | undefined;
     /**
-     * An array of {@link JsonObject | objects} that are deferred for merge during
+     * An array of JSON objects that were deferred for merge during
      * finalization.
      */
     get deferred(): JsonObject[];
     /**
      * Merges an optional {@link IJsonContext | JSON context} into a supplied set
-     * of {@link Editor.IJsonEditorOptions | JSON editor options}.
-     * @param options - The {@link Editor.IJsonEditorOptions | IJsonEditorOptions} into
+     * of {@link IJsonEditorOptions | JSON editor options}.
+     * @param options - The {@link IJsonEditorOptions | IJsonEditorOptions} into
      * which the the new context is to be merged.
      * @param context - The {@link IJsonContext | JSON context} to be merged into the
      * editor options.
-     * @returns `Success` with the supplied {@link Editor.IJsonEditorOptions | options} if
-     * there was nothing to merge, or aa new {@link Editor.IJsonEditorOptions | IJsonEditorOptions}
+     * @returns `Success` with the supplied {@link IJsonEditorOptions | options} if
+     * there was nothing to merge, or aa new {@link IJsonEditorOptions | IJsonEditorOptions}
      * constructed from the base options merged with the supplied context.  Returns `Failure`
      * with more information if an error occurs.
      * @internal
      */
     protected static _getEffectiveOptions(options: IJsonEditorOptions, context?: IJsonContext): Result<IJsonEditorOptions>;
     /**
-     * Adds a supplied {@link JsonObject | object} to the deferred list.
-     * @param obj - The {@link JsonObject | object} to be deferred.
+     * Adds a supplied `JsonObject` to the deferred list.
+     * @param obj - The `JsonObject` to be deferred.
      */
     defer(obj: JsonObject): void;
     /**
-     * Gets a {@link TemplateVars | TemplateVars} from the context of this {@link Editor.JsonEditorState | JsonEditorState},
+     * Gets a {@link TemplateVars | TemplateVars} from the context of this {@link JsonEditorState | JsonEditorState},
      * or from an optional supplied {@link IJsonContext | IJsonContext} if the current state has no default
      * context.
      * @param defaultContext - An optional default {@link IJsonContext | IJsonContext} to use as `TemplateVars`
@@ -1032,7 +1032,7 @@ export declare class JsonEditorState {
      */
     getRefs(defaultContext?: IJsonContext): IJsonReferenceMap | undefined;
     /**
-     * Gets the context of this {@link Editor.JsonEditorState | JsonEditorState} or an optionally
+     * Gets the context of this {@link JsonEditorState | JsonEditorState} or an optionally
      * supplied default context if this state has no context.
      * @param defaultContext - The default {@link IJsonContext | JSON context} to use as default
      * if this state has no context.
@@ -1056,9 +1056,9 @@ export declare class JsonEditorState {
     /**
      * Helper method to constructs  `DetailedFailure` with appropriate details and messaging
      * for various validation failures.
-     * @param rule - The {@link Editor.JsonEditorValidationRules | validation rule} that failed.
+     * @param rule - The {@link JsonEditorValidationRules | validation rule} that failed.
      * @param message -  A string message describing the failed validation.
-     * @param validation - The {@link Editor.IJsonEditorValidationOptions | validation options}
+     * @param validation - The {@link IJsonEditorValidationOptions | validation options}
      * in effect.
      * @returns A `DetailedFailure` with appropriate detail and message.
      */
@@ -1066,14 +1066,14 @@ export declare class JsonEditorState {
 }
 
 /**
- * Possible validation rules for a {@link Editor.JsonEditor | JsonEditor}.
+ * Possible validation rules for a {@link JsonEditor | JsonEditor}.
  * @public
  */
 export declare type JsonEditorValidationRules = 'invalidPropertyName' | 'invalidPropertyValue' | 'undefinedPropertyValue';
 
 /**
  * A simple validating {@link JsonConverter | JSON converter}. Converts unknown
- * to a {@link JsonObject | JsonObject}, or fails if the `unknown` contains invalid
+ * to a `JsonObject`, or fails if the `unknown` contains invalid
  * JSON or is not an object.
  * @public
  */
@@ -1111,7 +1111,7 @@ declare type MapOrRecord<T> = Map<string, T> | Record<string, T>;
 export declare function mergeDefaultJsonConverterOptions(partial?: Partial<IJsonConverterOptions>): IJsonConverterOptions;
 
 /**
- * The {@link Editor.Rules.MultiValueJsonEditorRule | Multi-Value JSON editor rule}
+ * The {@link EditorRules.MultiValueJsonEditorRule | Multi-Value JSON editor rule}
  * expands matching keys multiple times, projecting the value into the template
  * context for any child objects rendered by the rule.
  *
@@ -1124,26 +1124,26 @@ export declare function mergeDefaultJsonConverterOptions(partial?: Partial<IJson
  */
 declare class MultiValueJsonEditorRule extends JsonEditorRuleBase {
     /**
-     * Stored fully-resolved {@link Editor.IJsonEditorOptions | editor options}
+     * Stored fully-resolved {@link IJsonEditorOptions | editor options}
      * for this rule.
      * @public
      */
     protected _options?: IJsonEditorOptions;
     /**
-     * Creates a new {@link Editor.Rules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
-     * @param options - Optional {@link Editor.IJsonEditorOptions | configuration options}.
+     * Creates a new {@link EditorRules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options}.
      */
     constructor(options?: IJsonEditorOptions);
     /**
-     * Creates a new {@link Editor.Rules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
-     * @param options - Optional {@link Editor.IJsonEditorOptions | configuration options}.
+     * Creates a new {@link EditorRules.MultiValueJsonEditorRule | MultiValueJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options}.
      */
     static create(options?: IJsonEditorOptions): Result<MultiValueJsonEditorRule>;
     /**
      * Evaluates a property for multi-value expansion.
      * @param key - The key of the property to be considered
-     * @param value - The {@link JsonValue | value} of the property to be considered.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
      * @returns `Success` with an object containing the fully-resolved child values to be merged for
      * matching multi-value property. Returns `Failure` with detail `'error'` if an error occurs or
      * with detail `'inapplicable'` if the property key is not a conditional property.
@@ -1151,7 +1151,7 @@ declare class MultiValueJsonEditorRule extends JsonEditorRuleBase {
     editProperty(key: string, value: JsonValue, state: JsonEditorState): DetailedResult<JsonObject, JsonPropertyEditFailureReason>;
     /**
      * Extends the {@link IJsonContext | current context} with a supplied state and values.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
      * @param values - An array of {@link VariableValue | VariableValue} to be added to the
      * context.
      * @returns The extended {@link IJsonContext | context}.
@@ -1161,10 +1161,10 @@ declare class MultiValueJsonEditorRule extends JsonEditorRuleBase {
     /**
      * Determines if a given property key is multi-value. Derived classes can override this
      * method to use a different format for multi-value properties.
-     * @param value - The {@link JsonValue | value} of the property to be considered.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
      * @returns `Success` with detail `'deferred'` and an
-     * {@link Editor.Rules.IMultiValuePropertyParts | IMultiValuePropertyParts}
+     * {@link EditorRules.IMultiValuePropertyParts | IMultiValuePropertyParts}
      * describing the match for matching multi-value property.  Returns `Failure` with detail `'error'` if an error occurs
      * or with detail `'inapplicable'` if the key does not represent a multi-value property.
      * @public
@@ -1181,18 +1181,18 @@ export declare class PrefixedJsonMap extends SimpleJsonMap {
     /**
      * Constructs a new {@link PrefixedJsonMap | PrefixedJsonMap} from the supplied values
      * @param prefix - A string prefix to be enforced for and added to key names as necessary
-     * @param values - A string-keyed Map or Record of the {@link JsonValue | JsonValue} to be returned
+     * @param values - A string-keyed Map or Record of the `JsonValue` to be returned
      * @param context - Optional {@link IJsonContext | JSON Context} used to format returned values
-     * @param editor - Optional {@link Editor.JsonEditor | JsonEditor} used to format returned values
+     * @param editor - Optional {@link JsonEditor | JsonEditor} used to format returned values
      * @public
      */
     protected constructor(values?: MapOrRecord<JsonValue>, context?: IJsonContext, options?: ISimpleJsonMapOptions);
     /**
      * Creates a new {@link PrefixedJsonMap | PrefixedJsonMap} from the supplied values
      * @param prefix - A string prefix to be enforced for and added to key names as necessary
-     * @param values - A string-keyed Map or Record of the {@link JsonValue | JsonValue} to be returned
+     * @param values - A string-keyed Map or Record of the `JsonValue` to be returned
      * @param context - Optional {@link IJsonContext | JSON Context} used to format returned values
-     * @param editor - Optional {@link Editor.JsonEditor | JsonEditor} used to format returned values
+     * @param editor - Optional {@link JsonEditor | JsonEditor} used to format returned values
      * @returns `Success` with a {@link PrefixedJsonMap | PrefixedJsonMap} or `Failure` with a message
      * if an error occurs.
      */
@@ -1201,9 +1201,9 @@ export declare class PrefixedJsonMap extends SimpleJsonMap {
      * Creates a new {@link PrefixedJsonMap | PrefixedJsonMap} from the supplied values
      * @param prefixOptions - A KeyPrefixOptions indicating the prefix to enforce and whether that prefix should
      * be added automatically if necessary (default true)
-     * @param values - A string-keyed Map or record of the {@link JsonValue | JsonValue} to be returned
+     * @param values - A string-keyed Map or record of the `JsonValue` to be returned
      * @param context - Optional {@link IJsonContext | JSON Context} used to format returned values
-     * @param editor - Optional {@link Editor.JsonEditor | JsonEditor} used to format returned values
+     * @param editor - Optional {@link JsonEditor | JsonEditor} used to format returned values
      */
     static createPrefixed(prefixOptions: IKeyPrefixOptions, values?: MapOrRecord<JsonValue>, context?: IJsonContext, editor?: JsonEditor): Result<PrefixedJsonMap>;
     /**
@@ -1219,7 +1219,7 @@ export declare class PrefixedJsonMap extends SimpleJsonMap {
 }
 
 /**
- * The {@link Editor.Rules.ReferenceJsonEditorRule | Reference JSON editor rule} replaces property
+ * The {@link EditorRules.ReferenceJsonEditorRule | Reference JSON editor rule} replaces property
  * keys or values that match some known object with a copy of that referenced object, formatted
  * according to the current context.
  *
@@ -1241,40 +1241,40 @@ export declare class PrefixedJsonMap extends SimpleJsonMap {
  */
 declare class ReferenceJsonEditorRule extends JsonEditorRuleBase {
     /**
-     * Stored fully-resolved {@link Editor.IJsonEditorOptions | editor options} for this rule.
+     * Stored fully-resolved {@link IJsonEditorOptions | editor options} for this rule.
      * @public
      */
     protected _options?: IJsonEditorOptions;
     /**
-     * Creates a new {@link Editor.Rules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
-     * @param options - Optional {@link Editor.IJsonEditorOptions | configuration options} for this rule.
+     * Creates a new {@link EditorRules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options} for this rule.
      */
     constructor(options?: IJsonEditorOptions);
     /**
-     * Creates a new {@link Editor.Rules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
-     * @param options - Optional {@link Editor.IJsonEditorOptions | configuration options} for this rule.
+     * Creates a new {@link EditorRules.ReferenceJsonEditorRule | ReferenceJsonEditorRule}.
+     * @param options - Optional {@link IJsonEditorOptions | configuration options} for this rule.
      */
     static create(options?: IJsonEditorOptions): Result<ReferenceJsonEditorRule>;
     /**
      * Evaluates a property for reference expansion.
      * @param key - The key of the property to be considered.
-     * @param value - The {@link JsonValue | value} of the property to be considered.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
-     * @returns If the reference is successful, returns `Success` with a {@link JsonObject | JsonObject}
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+     * @returns If the reference is successful, returns `Success` with a `JsonObject`
      * to be flattened and merged into the current object. Returns `Failure` with detail `'inapplicable'`
      * for non-reference keys or with detail `'error'` if an error occurs.
      */
     editProperty(key: string, value: JsonValue, state: JsonEditorState): DetailedResult<JsonObject, JsonPropertyEditFailureReason>;
     /**
      * Evaluates a property, array or literal value for reference replacement.
-     * @param value - The {@link JsonValue | value} of the property to be considered.
-     * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+     * @param value - The `JsonValue` of the property to be considered.
+     * @param state - The {@link JsonEditorState | editor state} for the object being edited.
      */
     editValue(value: JsonValue, state: JsonEditorState): DetailedResult<JsonValue, JsonEditFailureReason>;
     /**
      * Gets the template variables to use given the value of some property whose name matched a
      * resource plus the base template context.
-     * @param state - The {@link Editor.JsonEditorState | editor state} to be extended.
+     * @param state - The {@link JsonEditorState | editor state} to be extended.
      * @param supplied - The string or object supplied in the source json.
      * @internal
      */
@@ -1391,7 +1391,7 @@ export declare type RichJsonConverterOptions = Omit<ConditionalJsonConverterOpti
 
 /**
  * A {@link SimpleJsonMap | SimpleJsonMap } presents a view of a simple map
- * of {@link JsonValue | JSON values}.
+ * of JSON values.
  * @public
  */
 export declare class SimpleJsonMap extends SimpleJsonMapBase<JsonValue> {
@@ -1401,7 +1401,7 @@ export declare class SimpleJsonMap extends SimpleJsonMapBase<JsonValue> {
     protected _editor?: JsonEditor;
     /**
      * Constructs a new {@link SimpleJsonMap | SimpleJsonMap} from the supplied objects
-     * @param values - A string-keyed `Map` or `Record` of the {@link JsonValue | JSON values}
+     * @param values - A string-keyed `Map` or `Record` of the `JsonValue`
      * to be returned.
      * @param context - Optional {@link IJsonContext | IJsonContext} used to format returned values.
      * @param options - Optional {@link ISimpleJsonMapOptions | ISimpleJsonMapOptions} for initialization.
@@ -1410,7 +1410,7 @@ export declare class SimpleJsonMap extends SimpleJsonMapBase<JsonValue> {
     protected constructor(values?: MapOrRecord<JsonValue>, context?: IJsonContext, options?: ISimpleJsonMapOptions);
     /**
      * Creates a new {@link SimpleJsonMap | SimpleJsonMap} from the supplied objects
-     * @param values - A string-keyed `Map` or `Record` of the {@link JsonValue | JSON values}
+     * @param values - A string-keyed `Map` or `Record` of the `JsonValue`
      * to be returned.
      * @param context - Optional {@link IJsonContext | IJsonContext} used to format returned values.
      * @param options - Optional {@link ISimpleJsonMapOptions | ISimpleJsonMapOptions} for initialization.
@@ -1419,7 +1419,7 @@ export declare class SimpleJsonMap extends SimpleJsonMapBase<JsonValue> {
      */
     static createSimple(values?: MapOrRecord<JsonValue>, context?: IJsonContext, options?: ISimpleJsonMapOptions): Result<SimpleJsonMap>;
     /**
-     * Gets a {@link JsonValue | JSON value} specified by key.
+     * Gets a `JsonValue` specified by key.
      * @param key - key of the value to be retrieved
      * @param context - Optional {@link IJsonContext | JSON context} used to format the value
      * @returns Success with the formatted object if successful. Failure with detail 'unknown'
@@ -1436,7 +1436,6 @@ export declare class SimpleJsonMap extends SimpleJsonMapBase<JsonValue> {
 /**
  * Abstract base class with common functionality for simple
  * {@link IJsonReferenceMap | reference map} implementations.
- * {@link JsonValue | json values}.
  * @public
  */
 declare abstract class SimpleJsonMapBase<T> implements IJsonReferenceMap {
@@ -1487,7 +1486,7 @@ declare abstract class SimpleJsonMapBase<T> implements IJsonReferenceMap {
      */
     has(key: string): boolean;
     /**
-     * Gets a {@link JsonObject | JSON object} specified by key.
+     * Gets a `JsonObject` specified by key.
      * @param key - key of the object to be retrieved
      * @param context - optional {@link IJsonContext | JSON context} used to format the
      * returned object.
@@ -1498,7 +1497,7 @@ declare abstract class SimpleJsonMapBase<T> implements IJsonReferenceMap {
          */
      getJsonObject(key: string, context?: IJsonContext): DetailedResult<JsonObject, JsonReferenceMapFailureReason>;
      /**
-      * Gets a {@link JsonValue | JSON value} specified by key.
+      * Gets a `JsonValue` specified by key.
       * @param key - key of the value to be retrieved
       * @param context - Optional {@link IJsonContext | JSON context} used to format the value
       * @returns Success with the formatted object if successful. Failure with detail 'unknown'
@@ -1553,34 +1552,34 @@ declare abstract class SimpleJsonMapBase<T> implements IJsonReferenceMap {
     export declare type TemplatedJsonConverterOptions = Omit<IJsonConverterOptions, 'useNameTemplates' | 'useValueTemplates' | 'useMultiValueTemplateNames'>;
 
     /**
-     * The {@link Editor.Rules.TemplatedJsonEditorRule | Templated JSON editor rule} applies mustache rendering as
+     * The {@link EditorRules.TemplatedJsonEditorRule | Templated JSON editor rule} applies mustache rendering as
      * appropriate to any keys or values in the object being edited.
      * @public
      */
     declare class TemplatedJsonEditorRule extends JsonEditorRuleBase {
         /**
-         * Fully-resolved {@link Editor.Rules.ITemplatedJsonRuleOptions | configuration options} for this rule.
+         * Fully-resolved {@link EditorRules.ITemplatedJsonRuleOptions | configuration options} for this rule.
          * @public
          */
         protected _options?: ITemplatedJsonRuleOptions;
         /**
-         * Creates a new {@link Editor.Rules.TemplatedJsonEditorRule | TemplatedJsonEditorRule}.
-         * @param options - Optional {@link Editor.Rules.ITemplatedJsonRuleOptions | configuration options}
+         * Creates a new {@link EditorRules.TemplatedJsonEditorRule | TemplatedJsonEditorRule}.
+         * @param options - Optional {@link EditorRules.ITemplatedJsonRuleOptions | configuration options}
          * for this rule.
          */
         constructor(options?: ITemplatedJsonRuleOptions);
         /**
-         * Creates a new {@link Editor.Rules.TemplatedJsonEditorRule | TemplatedJsonEditorRule}.
-         * @param options - Optional {@link Editor.Rules.ITemplatedJsonRuleOptions | configuration options}
+         * Creates a new {@link EditorRules.TemplatedJsonEditorRule | TemplatedJsonEditorRule}.
+         * @param options - Optional {@link EditorRules.ITemplatedJsonRuleOptions | configuration options}
          * for this rule.
          */
         static create(options?: ITemplatedJsonRuleOptions): Result<TemplatedJsonEditorRule>;
         /**
          * Evaluates a property name for template rendering.
          * @param key - The key of the property to be considered.
-         * @param value - The {@link JsonValue | value} of the property to be considered.
-         * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
-         * @returns `Success` with detail `'edited'` and an {@link JsonObject | object} to
+         * @param value - The `JsonValue` of the property to be considered.
+         * @param state - The {@link JsonEditorState | editor state} for the object being edited.
+         * @returns `Success` with detail `'edited'` and an `JsonObject` to
          * be flattened and merged if the key contained a template. Returns `Failure` with detail `'error'`
          * if an error occurred or with detail `'inapplicable'` if the property key does not contain
          * a template or if name rendering is disabled.
@@ -1588,17 +1587,17 @@ declare abstract class SimpleJsonMapBase<T> implements IJsonReferenceMap {
         editProperty(key: string, value: JsonValue, state: JsonEditorState): DetailedResult<JsonObject, JsonPropertyEditFailureReason>;
         /**
          * Evaluates a property, array or literal value for template rendering.
-         * @param value - The {@link JsonValue | value} to be edited.
-         * @param state - The {@link Editor.JsonEditorState | editor state} for the object being edited.
+         * @param value - The `JsonValue` to be edited.
+         * @param state - The {@link JsonEditorState | editor state} for the object being edited.
          * @returns `Success` with detail `'edited'` if the value contained a template and was edited.
          * Returns `Failure` with `'ignore'` if the rendered value should be ignored, with `'error'` if
          * an error occurs, or with `'inapplicable'` if the value was not a string with a template.
          */
         editValue(value: JsonValue, state: JsonEditorState): DetailedResult<JsonValue, JsonEditFailureReason>;
         /**
-         * Renders a single template string for a supplied {@link Editor.JsonEditorState | editor state}.
+         * Renders a single template string for a supplied {@link JsonEditorState | editor state}.
          * @param template - The mustache template to be rendered.
-         * @param state - The {@link Editor.JsonEditorState | editor state} used to render the template.
+         * @param state - The {@link JsonEditorState | editor state} used to render the template.
          * @returns `Success` if the template is rendered.  Returns `Failure` with detail `'error'` if the
          * template could not be rendered (e.g. due to syntax errors) or with detail `'inapplicable'` if the
          * string is not a template.