@fluidframework/presence 2.23.0 → 2.30.0

package/dist/core-interfaces/jsonDeserialized.d.ts

@@ -1,109 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { InternalUtilityTypes } from "./exposedUtilityTypes.js";
-/**
- * Options for {@link JsonDeserialized}.
- *
- * @alpha
- */
-export interface JsonDeserializedOptions {
-    /**
-     * Exact types that are managed by custom deserialization logic (beyond
-     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}
-     * without a reviver). Only exact types matching specification will be
-     * preserved unaltered.
-     *
-     * The default value is `never`.
-     */
-    AllowExactly?: unknown;
-    /**
-     * General types that are managed by custom deserialization logic (beyond
-     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}
-     * without a reviver). Any type satisfying specification will be preserved
-     * unaltered.
-     *
-     * The default value is `never`.
-     */
-    AllowExtensionOf?: unknown;
-}
-/**
- * Produces a type that results from a type `T` serialized and deserialized
- * through JSON using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
- * (without replacer) and {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}
- * (without reviver), respectively as base model.
- *
- * @typeParam T - The type that was serialized.
- * @typeParam Options - Options for the filter. See {@link JsonDeserializedOptions}.
- *
- * @remarks
- * Before adding use of this utility type, consider using a utility like
- * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows
- * for runtime validation.
- *
- * This filter can be used to derive the expected type of a JSON deserialized
- * value whether or not the type of value serialized meets serialization
- * constraints (see {@link JsonSerializable} including serialization pitfalls).
- *
- * When used as a filter to inferred generic `T`, a compile-time error can be
- * produced trying to assign `JsonDeserialized<T>` to `T`.
- *
- * Simply deserialized JSON never contains `bigint`, `undefined`, `symbol`,
- * or function values. (Object properties which had those types before encoding
- * are omitted during serialization and thus won't be present after
- * deserialization.) Therefore, through this filter, such properties:
- *
- * - become optional with those types excluded (when there are other supported
- * types in union)
- *
- * - are removed (when nothing else in union is supported)
- *
- * - in an array are (1) replaced with `null` if `undefined`, `symbol`, and
- * function values or (2) simply removed (become `never`) if `bigint` value as
- * serialization attempts will throw.
- *
- * Examples results:
- *
- * | Before serialization  | After deserialization | After in record    |       After in array |
- * | --------------------- | --------------------- | ------------------ | --------------------:|
- * | `undefined \| number` | `number`              | `prop?: number`    | `(number \| null)[]` |
- * | `symbol \| number`    | `number`              | `prop?: number`    | `(number \| null)[]` |
- * | `bigint \| number`    | `number`              | `prop: number`     |           `number[]` |
- * | `undefined`           | N/A `never`           | (prop not present) |             `null[]` |
- * | `symbol`              | N/A `never`           | (prop not present) |             `null[]` |
- * | `bigint`              | N/A `never`           | N/A (prop not present) |    N/A `never[]` |
- * | `bigint \| symbol`    | N/A `never`           | (prop not present) |             `null[]` |
- * | `bigint \| number \| symbol` | `number`       | `prop?: number`    | `(number \| null)[]` |
- *
- * Setter and getter properties become value properties after filtering
- * although no data will be persisted assuming those properties are backed
- * by functions. If an implementation of getter/setter interface uses a
- * simple data member (of supported type), that will persist.
- *
- * Recursive types without any required modification are preserved intact.
- * Recursive types that require modification are unrolled a limited number of
- * times (currently 4) and then further instances of recursion are replaced with
- * {@link JsonTypeWith|JsonTypeWith<Options.AllowExactly "or" Options.AllowExtensionOf>}.
- *
- * Under basic serialization, class instances become simple data objects that
- * lose hidden properties and prototypes that are required for `instanceof`
- * runtime checks.
- *
- * The optional 'Options.AllowExactly' and 'Options.AllowExtensionOf'
- * parameters may be used to permit additional leaf types handled by custom
- * serialization/deserialization logic.
- *
- * @example Example usage
- *
- * ```typescript
- * function foo<T>(): JsonDeserialized<T> { ... }
- * ```
- *
- * @alpha
- */
-export type JsonDeserialized<T, Options extends JsonDeserializedOptions = {
-    AllowExactly: never;
-    AllowExtensionOf: never;
-}> = InternalUtilityTypes.JsonDeserializedImpl<T, Options>;
-//# sourceMappingURL=jsonDeserialized.d.ts.map

package/dist/core-interfaces/jsonDeserialized.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonDeserialized.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonDeserialized.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,MAAM,MAAM,gBAAgB,CAC3B,CAAC,EACD,OAAO,SAAS,uBAAuB,GAAG;IACzC,YAAY,EAAE,KAAK,CAAC;IACpB,gBAAgB,EAAE,KAAK,CAAC;CACxB,IACE,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC"}

package/dist/core-interfaces/jsonDeserialized.js

@@ -1,7 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=jsonDeserialized.js.map

package/dist/core-interfaces/jsonDeserialized.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonDeserialized.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonDeserialized.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { InternalUtilityTypes } from \"./exposedUtilityTypes.js\";\n\n/**\n * Options for {@link JsonDeserialized}.\n *\n * @alpha\n */\nexport interface JsonDeserializedOptions {\n\t/**\n\t * Exact types that are managed by custom deserialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}\n\t * without a reviver). Only exact types matching specification will be\n\t * preserved unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExactly?: unknown;\n\n\t/**\n\t * General types that are managed by custom deserialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}\n\t * without a reviver). Any type satisfying specification will be preserved\n\t * unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExtensionOf?: unknown;\n}\n\n/**\n * Produces a type that results from a type `T` serialized and deserialized\n * through JSON using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n * (without replacer) and {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}\n * (without reviver), respectively as base model.\n *\n * @typeParam T - The type that was serialized.\n * @typeParam Options - Options for the filter. See {@link JsonDeserializedOptions}.\n *\n * @remarks\n * Before adding use of this utility type, consider using a utility like\n * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows\n * for runtime validation.\n *\n * This filter can be used to derive the expected type of a JSON deserialized\n * value whether or not the type of value serialized meets serialization\n * constraints (see {@link JsonSerializable} including serialization pitfalls).\n *\n * When used as a filter to inferred generic `T`, a compile-time error can be\n * produced trying to assign `JsonDeserialized<T>` to `T`.\n *\n * Simply deserialized JSON never contains `bigint`, `undefined`, `symbol`,\n * or function values. (Object properties which had those types before encoding\n * are omitted during serialization and thus won't be present after\n * deserialization.) Therefore, through this filter, such properties:\n *\n * - become optional with those types excluded (when there are other supported\n * types in union)\n *\n * - are removed (when nothing else in union is supported)\n *\n * - in an array are (1) replaced with `null` if `undefined`, `symbol`, and\n * function values or (2) simply removed (become `never`) if `bigint` value as\n * serialization attempts will throw.\n *\n * Examples results:\n *\n * | Before serialization  | After deserialization | After in record    |       After in array |\n * | --------------------- | --------------------- | ------------------ | --------------------:|\n * | `undefined \\| number` | `number`              | `prop?: number`    | `(number \\| null)[]` |\n * | `symbol \\| number`    | `number`              | `prop?: number`    | `(number \\| null)[]` |\n * | `bigint \\| number`    | `number`              | `prop: number`     |           `number[]` |\n * | `undefined`           | N/A `never`           | (prop not present) |             `null[]` |\n * | `symbol`              | N/A `never`           | (prop not present) |             `null[]` |\n * | `bigint`              | N/A `never`           | N/A (prop not present) |    N/A `never[]` |\n * | `bigint \\| symbol`    | N/A `never`           | (prop not present) |             `null[]` |\n * | `bigint \\| number \\| symbol` | `number`       | `prop?: number`    | `(number \\| null)[]` |\n *\n * Setter and getter properties become value properties after filtering\n * although no data will be persisted assuming those properties are backed\n * by functions. If an implementation of getter/setter interface uses a\n * simple data member (of supported type), that will persist.\n *\n * Recursive types without any required modification are preserved intact.\n * Recursive types that require modification are unrolled a limited number of\n * times (currently 4) and then further instances of recursion are replaced with\n * {@link JsonTypeWith|JsonTypeWith<Options.AllowExactly \"or\" Options.AllowExtensionOf>}.\n *\n * Under basic serialization, class instances become simple data objects that\n * lose hidden properties and prototypes that are required for `instanceof`\n * runtime checks.\n *\n * The optional 'Options.AllowExactly' and 'Options.AllowExtensionOf'\n * parameters may be used to permit additional leaf types handled by custom\n * serialization/deserialization logic.\n *\n * @example Example usage\n *\n * ```typescript\n * function foo<T>(): JsonDeserialized<T> { ... }\n * ```\n *\n * @alpha\n */\nexport type JsonDeserialized<\n\tT,\n\tOptions extends JsonDeserializedOptions = {\n\t\tAllowExactly: never;\n\t\tAllowExtensionOf: never;\n\t},\n> = InternalUtilityTypes.JsonDeserializedImpl<T, Options>;\n"]}

package/dist/core-interfaces/jsonSerializable.d.ts

@@ -1,120 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { InternalUtilityTypes } from "./exposedUtilityTypes.js";
-/**
- * Options for {@link JsonSerializable}.
- *
- * @alpha
- */
-export interface JsonSerializableOptions {
-    /**
-     * Exact types that are managed by custom serialization logic (beyond
-     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
-     * without a replacer). Only exact types matching specification will be
-     * preserved unaltered.
-     *
-     * The default value is `never`.
-     */
-    AllowExactly?: unknown;
-    /**
-     * General types that are managed by custom serialization logic (beyond
-     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
-     * without a replacer). Any type satisfying specification will be preserved
-     * unaltered.
-     *
-     * The default value is `never`.
-     */
-    AllowExtensionOf?: unknown;
-    /**
-     * When set, inaccessible (protected and private) members throughout type T are
-     * ignored as if not present.
-     *
-     * The default value is not present.
-     */
-    IgnoreInaccessibleMembers?: "ignore-inaccessible-members";
-}
-/**
- * Used to constrain a type `T` to types that are serializable as JSON
- * using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
- * (without a replacer) as base model.
- *
- * Under typical use a compile-time error is produced if `T` contains
- * non-JsonSerializable members.
- *
- * @typeParam T - The type to be constrained.
- * @typeParam Options - Options for the filter. See {@link JsonSerializableOptions}.
- *
- * @remarks
- * Before adding use of this utility type, consider using a utility like
- * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows
- * for runtime validation.
- *
- * Note that this does NOT prevent use of values with non-JSON compatible data,
- * it only prevents using values with types that include non-JSON compatible data.
- * This means that one can, for example, pass in a value typed with JSON compatible
- * interface into this filter, that could actually be a class with lots on non-JSON
- * compatible fields and methods.
- *
- * Important: `T extends JsonSerializable<T>` is incorrect (does not even compile).
- *
- * The optional `Options.Allow*` parameters may be used to permit additional leaf types
- * to support situations where a `replacer` is used to handle special values (e.g.,
- * `JsonSerializable<{ x: IFluidHandle }, { AllowExtensionOf: IFluidHandle }>`).
- *
- * Note that `JsonSerializable<T>` does not protect against the following pitfalls
- * when serializing with JSON.stringify():
- *
- * - Non-finite numbers (`NaN`, `+/-Infinity`) are coerced to `null`.
- *
- * - Prototypes and non-enumerable properties are lost.
- *
- * - `ArrayLike` types that are not arrays and are serialized as `{ length: number }`.
- *
- * - Getter and setters properties are lost. (Though appear supported.)
- *
- * - Functions with properties may be absent or the properties may be perserved
- * depending on the runtime typo of the value. (If built via Object.assign the
- * target member's type is preserved.) typeof =\> 'function' is lost whereas when
- * typeof =\> 'object' the properties are preserved.
- *
- * - Sparse arrays are filled with `null`.
- *
- * Also, `JsonSerializable<T>` does not prevent the construction of circular references.
- *
- * Specifying `JsonSerializable<unknown>` or `JsonSerializable<any>` yields a type
- * alias for {@link JsonTypeWith}`<never>` and should not be used if precise type
- * safety is desired.
- *
- * Class instances are indistinguishable from general objects by type checking
- * unless they have non-public members.
- * Unless `Option.IgnoreInaccessibleMembers` is used, types with non-public
- * members will result in {@link SerializationErrorPerNonPublicProperties}.
- * When `Option.IgnoreInaccessibleMembers` is `ignore-inaccessible-members`,
- * non-public (non-function) members are preserved without error, but they are
- * filtered away by the type filters and thus produce an incorrectly narrowed
- * type compared to actual data. Though such a result may be customer desired.
- *
- * Perhaps a https://github.com/microsoft/TypeScript/issues/22677 fix will
- * enable better support.
- *
- * @example Typical usage
- *
- * ```typescript
- * function foo<T>(value: JsonSerializable<T>) { ... }
- * ```
- *
- * @privateRemarks
- * Upon recursion, the original type T is preserved intact. This is done to prevent
- * infinite recursion and produces a technically incorrect result type. However, with
- * proper use, that will never be an issue as any filtering of types will happen
- * before T recursion.
- *
- * @alpha
- */
-export type JsonSerializable<T, Options extends JsonSerializableOptions = {
-    AllowExactly: never;
-    AllowExtensionOf: never;
-}> = InternalUtilityTypes.JsonSerializableImpl<T, Options>;
-//# sourceMappingURL=jsonSerializable.d.ts.map

package/dist/core-interfaces/jsonSerializable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSerializable.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,6BAA6B,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,MAAM,MAAM,gBAAgB,CAC3B,CAAC,EACD,OAAO,SAAS,uBAAuB,GAAG;IACzC,YAAY,EAAE,KAAK,CAAC;IACpB,gBAAgB,EAAE,KAAK,CAAC;CACxB,IACE,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC"}

package/dist/core-interfaces/jsonSerializable.js

@@ -1,7 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=jsonSerializable.js.map

package/dist/core-interfaces/jsonSerializable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSerializable.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializable.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { InternalUtilityTypes } from \"./exposedUtilityTypes.js\";\n\n/**\n * Options for {@link JsonSerializable}.\n *\n * @alpha\n */\nexport interface JsonSerializableOptions {\n\t/**\n\t * Exact types that are managed by custom serialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n\t * without a replacer). Only exact types matching specification will be\n\t * preserved unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExactly?: unknown;\n\n\t/**\n\t * General types that are managed by custom serialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n\t * without a replacer). Any type satisfying specification will be preserved\n\t * unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExtensionOf?: unknown;\n\n\t/**\n\t * When set, inaccessible (protected and private) members throughout type T are\n\t * ignored as if not present.\n\t *\n\t * The default value is not present.\n\t */\n\tIgnoreInaccessibleMembers?: \"ignore-inaccessible-members\";\n}\n\n/**\n * Used to constrain a type `T` to types that are serializable as JSON\n * using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n * (without a replacer) as base model.\n *\n * Under typical use a compile-time error is produced if `T` contains\n * non-JsonSerializable members.\n *\n * @typeParam T - The type to be constrained.\n * @typeParam Options - Options for the filter. See {@link JsonSerializableOptions}.\n *\n * @remarks\n * Before adding use of this utility type, consider using a utility like\n * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows\n * for runtime validation.\n *\n * Note that this does NOT prevent use of values with non-JSON compatible data,\n * it only prevents using values with types that include non-JSON compatible data.\n * This means that one can, for example, pass in a value typed with JSON compatible\n * interface into this filter, that could actually be a class with lots on non-JSON\n * compatible fields and methods.\n *\n * Important: `T extends JsonSerializable<T>` is incorrect (does not even compile).\n *\n * The optional `Options.Allow*` parameters may be used to permit additional leaf types\n * to support situations where a `replacer` is used to handle special values (e.g.,\n * `JsonSerializable<{ x: IFluidHandle }, { AllowExtensionOf: IFluidHandle }>`).\n *\n * Note that `JsonSerializable<T>` does not protect against the following pitfalls\n * when serializing with JSON.stringify():\n *\n * - Non-finite numbers (`NaN`, `+/-Infinity`) are coerced to `null`.\n *\n * - Prototypes and non-enumerable properties are lost.\n *\n * - `ArrayLike` types that are not arrays and are serialized as `{ length: number }`.\n *\n * - Getter and setters properties are lost. (Though appear supported.)\n *\n * - Functions with properties may be absent or the properties may be perserved\n * depending on the runtime typo of the value. (If built via Object.assign the\n * target member's type is preserved.) typeof =\\> 'function' is lost whereas when\n * typeof =\\> 'object' the properties are preserved.\n *\n * - Sparse arrays are filled with `null`.\n *\n * Also, `JsonSerializable<T>` does not prevent the construction of circular references.\n *\n * Specifying `JsonSerializable<unknown>` or `JsonSerializable<any>` yields a type\n * alias for {@link JsonTypeWith}`<never>` and should not be used if precise type\n * safety is desired.\n *\n * Class instances are indistinguishable from general objects by type checking\n * unless they have non-public members.\n * Unless `Option.IgnoreInaccessibleMembers` is used, types with non-public\n * members will result in {@link SerializationErrorPerNonPublicProperties}.\n * When `Option.IgnoreInaccessibleMembers` is `ignore-inaccessible-members`,\n * non-public (non-function) members are preserved without error, but they are\n * filtered away by the type filters and thus produce an incorrectly narrowed\n * type compared to actual data. Though such a result may be customer desired.\n *\n * Perhaps a https://github.com/microsoft/TypeScript/issues/22677 fix will\n * enable better support.\n *\n * @example Typical usage\n *\n * ```typescript\n * function foo<T>(value: JsonSerializable<T>) { ... }\n * ```\n *\n * @privateRemarks\n * Upon recursion, the original type T is preserved intact. This is done to prevent\n * infinite recursion and produces a technically incorrect result type. However, with\n * proper use, that will never be an issue as any filtering of types will happen\n * before T recursion.\n *\n * @alpha\n */\nexport type JsonSerializable<\n\tT,\n\tOptions extends JsonSerializableOptions = {\n\t\tAllowExactly: never;\n\t\tAllowExtensionOf: never;\n\t},\n> = InternalUtilityTypes.JsonSerializableImpl<T, Options>;\n"]}

package/dist/core-interfaces/jsonSerializationErrors.d.ts

@@ -1,31 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Type resulting from {@link JsonSerializable} use given an array with
- * `undefined` elements.
- *
- * @privateRemarks type is used over interface; so inspection of type
- * result can be more informative than just the type name.
- *
- * @alpha
- * @system
- */
-export type SerializationErrorPerUndefinedArrayElement = {
-    "array serialization error": "undefined elements are not supported";
-};
-/**
- * Type resulting from {@link JsonSerializable} use given a class with
- * non-public properties.
- *
- * @privateRemarks type is used over interface; so inspection of type
- * result can be more informative than just the type name.
- *
- * @alpha
- * @system
- */
-export type SerializationErrorPerNonPublicProperties = {
-    "object serialization error": "non-public properties are not supported";
-};
-//# sourceMappingURL=jsonSerializationErrors.d.ts.map

package/dist/core-interfaces/jsonSerializationErrors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSerializationErrors.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializationErrors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,MAAM,MAAM,0CAA0C,GAAG;IACxD,2BAA2B,EAAE,sCAAsC,CAAC;CACpE,CAAC;AAEF;;;;;;;;;GASG;AAEH,MAAM,MAAM,wCAAwC,GAAG;IACtD,4BAA4B,EAAE,yCAAyC,CAAC;CACxE,CAAC"}

package/dist/core-interfaces/jsonSerializationErrors.js

@@ -1,7 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=jsonSerializationErrors.js.map

package/dist/core-interfaces/jsonSerializationErrors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSerializationErrors.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializationErrors.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Type resulting from {@link JsonSerializable} use given an array with\n * `undefined` elements.\n *\n * @privateRemarks type is used over interface; so inspection of type\n * result can be more informative than just the type name.\n *\n * @alpha\n * @system\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport type SerializationErrorPerUndefinedArrayElement = {\n\t\"array serialization error\": \"undefined elements are not supported\";\n};\n\n/**\n * Type resulting from {@link JsonSerializable} use given a class with\n * non-public properties.\n *\n * @privateRemarks type is used over interface; so inspection of type\n * result can be more informative than just the type name.\n *\n * @alpha\n * @system\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport type SerializationErrorPerNonPublicProperties = {\n\t\"object serialization error\": \"non-public properties are not supported\";\n};\n"]}

package/dist/core-interfaces/jsonType.d.ts

@@ -1,29 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Type constraint for types that are likely encodable as JSON, deserializable from JSON,
- * or have a custom alternate type.
- *
- * @remarks
- * Use `JsonTypeWith<never>` for just JSON encodable/deserializable types.
- * See {@link JsonSerializable} for encoding pitfalls.
- *
- * @privateRemarks
- * Prefer using `JsonSerializable<unknown>` or `JsonDeserialized<unknown>` over this type that
- * is an implementation detail.
- * @alpha
- */
-export type JsonTypeWith<T> = null | boolean | number | string | T | {
-    [key: string | number]: JsonTypeWith<T>;
-} | JsonTypeWith<T>[];
-/**
- * Portion of {@link JsonTypeWith} that is an object (including array) and not null.
- *
- * @alpha
- */
-export type NonNullJsonObjectWith<T> = {
-    [key: string | number]: JsonTypeWith<T>;
-} | JsonTypeWith<T>[];
-//# sourceMappingURL=jsonType.d.ts.map

package/dist/core-interfaces/jsonType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonType.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAEvB,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,CAAC,GACD;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,GAC3C,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;AAErB;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAChC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,GAC3C,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC"}

package/dist/core-interfaces/jsonType.js

@@ -1,7 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=jsonType.js.map

package/dist/core-interfaces/jsonType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonType.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonType.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Type constraint for types that are likely encodable as JSON, deserializable from JSON,\n * or have a custom alternate type.\n *\n * @remarks\n * Use `JsonTypeWith<never>` for just JSON encodable/deserializable types.\n * See {@link JsonSerializable} for encoding pitfalls.\n *\n * @privateRemarks\n * Prefer using `JsonSerializable<unknown>` or `JsonDeserialized<unknown>` over this type that\n * is an implementation detail.\n * @alpha\n */\nexport type JsonTypeWith<T> =\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| boolean\n\t| number\n\t| string\n\t| T\n\t| { [key: string | number]: JsonTypeWith<T> }\n\t| JsonTypeWith<T>[];\n\n/**\n * Portion of {@link JsonTypeWith} that is an object (including array) and not null.\n *\n * @alpha\n */\nexport type NonNullJsonObjectWith<T> =\n\t| { [key: string | number]: JsonTypeWith<T> }\n\t| JsonTypeWith<T>[];\n"]}