ibm-cloud-sdk-core 4.3.3 → 4.3.4

package/sdk-test-utilities/node_modules/@sinclair/typebox/value/mutate.js

@@ -0,0 +1,121 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueMutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
+const is_1 = require("./is");
+const pointer_1 = require("./pointer");
+const clone_1 = require("./clone");
+class ValueMutateTypeMismatchError extends Error {
+    constructor() {
+        super('ValueMutate: Cannot assign due type mismatch of assignable values');
+    }
+}
+exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
+class ValueMutateInvalidRootMutationError extends Error {
+    constructor() {
+        super('ValueMutate: Only object and array types can be mutated at the root level');
+    }
+}
+exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
+var ValueMutate;
+(function (ValueMutate) {
+    function Object(root, path, current, next) {
+        if (!is_1.Is.Object(current)) {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+        else {
+            const currentKeys = globalThis.Object.keys(current);
+            const nextKeys = globalThis.Object.keys(next);
+            for (const currentKey of currentKeys) {
+                if (!nextKeys.includes(currentKey)) {
+                    delete current[currentKey];
+                }
+            }
+            for (const nextKey of nextKeys) {
+                if (!currentKeys.includes(nextKey)) {
+                    current[nextKey] = null;
+                }
+            }
+            for (const nextKey of nextKeys) {
+                Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+            }
+        }
+    }
+    function Array(root, path, current, next) {
+        if (!is_1.Is.Array(current)) {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+        else {
+            for (let index = 0; index < next.length; index++) {
+                Visit(root, `${path}/${index}`, current[index], next[index]);
+            }
+            current.splice(next.length);
+        }
+    }
+    function TypedArray(root, path, current, next) {
+        if (is_1.Is.TypedArray(current) && current.length === next.length) {
+            for (let i = 0; i < current.length; i++) {
+                current[i] = next[i];
+            }
+        }
+        else {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+    }
+    function Value(root, path, current, next) {
+        if (current === next)
+            return;
+        pointer_1.ValuePointer.Set(root, path, next);
+    }
+    function Visit(root, path, current, next) {
+        if (is_1.Is.Array(next)) {
+            return Array(root, path, current, next);
+        }
+        else if (is_1.Is.TypedArray(next)) {
+            return TypedArray(root, path, current, next);
+        }
+        else if (is_1.Is.Object(next)) {
+            return Object(root, path, current, next);
+        }
+        else if (is_1.Is.Value(next)) {
+            return Value(root, path, current, next);
+        }
+    }
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current, next) {
+        if (is_1.Is.TypedArray(current) || is_1.Is.Value(current) || is_1.Is.TypedArray(next) || is_1.Is.Value(next)) {
+            throw new ValueMutateInvalidRootMutationError();
+        }
+        if ((is_1.Is.Object(current) && is_1.Is.Array(next)) || (is_1.Is.Array(current) && is_1.Is.Object(next))) {
+            throw new ValueMutateTypeMismatchError();
+        }
+        Visit(current, '', current, next);
+    }
+    ValueMutate.Mutate = Mutate;
+})(ValueMutate = exports.ValueMutate || (exports.ValueMutate = {}));

package/sdk-test-utilities/node_modules/@sinclair/typebox/value/pointer.d.ts

@@ -0,0 +1,24 @@
+export declare class ValuePointerRootSetError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+/** Provides functionality to update values through RFC6901 string pointers */
+export declare namespace ValuePointer {
+    /** Formats the given pointer into navigable key components */
+    function Format(pointer: string): IterableIterator<string>;
+    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+    function Set(value: any, pointer: string, update: unknown): void;
+    /** Deletes a value at the given pointer */
+    function Delete(value: any, pointer: string): void;
+    /** Returns true if a value exists at the given pointer */
+    function Has(value: any, pointer: string): boolean;
+    /** Gets the value at the given pointer */
+    function Get(value: any, pointer: string): any;
+}

package/sdk-test-utilities/node_modules/@sinclair/typebox/value/pointer.js

@@ -0,0 +1,142 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+class ValuePointerRootSetError extends Error {
+    constructor(value, path, update) {
+        super('ValuePointer: Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+exports.ValuePointerRootSetError = ValuePointerRootSetError;
+class ValuePointerRootDeleteError extends Error {
+    constructor(value, path) {
+        super('ValuePointer: Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+/** Provides functionality to update values through RFC6901 string pointers */
+var ValuePointer;
+(function (ValuePointer) {
+    function Escape(component) {
+        return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
+    }
+    /** Formats the given pointer into navigable key components */
+    function* Format(pointer) {
+        if (pointer === '')
+            return;
+        let [start, end] = [0, 0];
+        for (let i = 0; i < pointer.length; i++) {
+            const char = pointer.charAt(i);
+            if (char === '/') {
+                if (i === 0) {
+                    start = i + 1;
+                }
+                else {
+                    end = i;
+                    yield Escape(pointer.slice(start, end));
+                    start = i + 1;
+                }
+            }
+            else {
+                end = i;
+            }
+        }
+        yield Escape(pointer.slice(start));
+    }
+    ValuePointer.Format = Format;
+    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+    function Set(value, pointer, update) {
+        if (pointer === '')
+            throw new ValuePointerRootSetError(value, pointer, update);
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined)
+                next[component] = {};
+            owner = next;
+            next = next[component];
+            key = component;
+        }
+        owner[key] = update;
+    }
+    ValuePointer.Set = Set;
+    /** Deletes a value at the given pointer */
+    function Delete(value, pointer) {
+        if (pointer === '')
+            throw new ValuePointerRootDeleteError(value, pointer);
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined || next[component] === null)
+                return;
+            owner = next;
+            next = next[component];
+            key = component;
+        }
+        if (globalThis.Array.isArray(owner)) {
+            const index = parseInt(key);
+            owner.splice(index, 1);
+        }
+        else {
+            delete owner[key];
+        }
+    }
+    ValuePointer.Delete = Delete;
+    /** Returns true if a value exists at the given pointer */
+    function Has(value, pointer) {
+        if (pointer === '')
+            return true;
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined)
+                return false;
+            owner = next;
+            next = next[component];
+            key = component;
+        }
+        return globalThis.Object.getOwnPropertyNames(owner).includes(key);
+    }
+    ValuePointer.Has = Has;
+    /** Gets the value at the given pointer */
+    function Get(value, pointer) {
+        if (pointer === '')
+            return value;
+        let current = value;
+        for (const component of Format(pointer)) {
+            if (current[component] === undefined)
+                return undefined;
+            current = current[component];
+        }
+        return current;
+    }
+    ValuePointer.Get = Get;
+})(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));

package/sdk-test-utilities/node_modules/@sinclair/typebox/value/value.d.ts

@@ -0,0 +1,39 @@
+import * as Types from '../typebox';
+import { ValueErrorIterator } from '../errors/index';
+import { Mutable } from './mutate';
+import { Edit } from './delta';
+/** Provides functions to perform structural updates to JavaScript values */
+export declare namespace Value {
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+    function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+    function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
+    /** Creates a value from the given type */
+    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
+    /** Creates a value from the given type */
+    function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
+    /** Returns true if the value matches the given type. */
+    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
+    /** Returns true if the value matches the given type. */
+    function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
+    /** Converts any type mismatched values to their target type if a conversion is possible. */
+    function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): unknown;
+    /** Converts any type mismatched values to their target type if a conversion is possible. */
+    function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown;
+    /** Returns a structural clone of the given value */
+    function Clone<T>(value: T): T;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): ValueErrorIterator;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
+    /** Returns true if left and right values are structurally equal */
+    function Equal<T>(left: T, right: unknown): right is T;
+    /** Returns edits to transform the current value into the next value */
+    function Diff(current: unknown, next: unknown): Edit[];
+    /** Returns a FNV1A-64 non cryptographic hash of the given value */
+    function Hash(value: unknown): bigint;
+    /** Returns a new value with edits applied to the given value */
+    function Patch<T = any>(current: unknown, edits: Edit[]): T;
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current: Mutable, next: Mutable): void;
+}

package/sdk-test-utilities/node_modules/@sinclair/typebox/value/value.js

@@ -0,0 +1,99 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Value = void 0;
+const index_1 = require("../errors/index");
+const mutate_1 = require("./mutate");
+const hash_1 = require("./hash");
+const equal_1 = require("./equal");
+const cast_1 = require("./cast");
+const clone_1 = require("./clone");
+const convert_1 = require("./convert");
+const create_1 = require("./create");
+const check_1 = require("./check");
+const delta_1 = require("./delta");
+/** Provides functions to perform structural updates to JavaScript values */
+var Value;
+(function (Value) {
+    function Cast(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return cast_1.ValueCast.Cast(schema, references, value);
+    }
+    Value.Cast = Cast;
+    function Create(...args) {
+        const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []];
+        return create_1.ValueCreate.Create(schema, references);
+    }
+    Value.Create = Create;
+    function Check(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return check_1.ValueCheck.Check(schema, references, value);
+    }
+    Value.Check = Check;
+    function Convert(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return convert_1.ValueConvert.Convert(schema, references, value);
+    }
+    Value.Convert = Convert;
+    /** Returns a structural clone of the given value */
+    function Clone(value) {
+        return clone_1.ValueClone.Clone(value);
+    }
+    Value.Clone = Clone;
+    function Errors(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return index_1.ValueErrors.Errors(schema, references, value);
+    }
+    Value.Errors = Errors;
+    /** Returns true if left and right values are structurally equal */
+    function Equal(left, right) {
+        return equal_1.ValueEqual.Equal(left, right);
+    }
+    Value.Equal = Equal;
+    /** Returns edits to transform the current value into the next value */
+    function Diff(current, next) {
+        return delta_1.ValueDelta.Diff(current, next);
+    }
+    Value.Diff = Diff;
+    /** Returns a FNV1A-64 non cryptographic hash of the given value */
+    function Hash(value) {
+        return hash_1.ValueHash.Create(value);
+    }
+    Value.Hash = Hash;
+    /** Returns a new value with edits applied to the given value */
+    function Patch(current, edits) {
+        return delta_1.ValueDelta.Patch(current, edits);
+    }
+    Value.Patch = Patch;
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current, next) {
+        mutate_1.ValueMutate.Mutate(current, next);
+    }
+    Value.Mutate = Mutate;
+})(Value = exports.Value || (exports.Value = {}));

package/sdk-test-utilities/node_modules/@types/istanbul-lib-coverage/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/sdk-test-utilities/node_modules/@types/istanbul-lib-coverage/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/istanbul-lib-coverage`
+
+# Summary
+This package contains type definitions for istanbul-lib-coverage (https://istanbul.js.org).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/istanbul-lib-coverage.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Jason Cheatham](https://github.com/jason0x43).

package/sdk-test-utilities/node_modules/@types/istanbul-lib-coverage/index.d.ts

@@ -0,0 +1,111 @@
+export interface CoverageSummaryData {
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+export class CoverageSummary {
+    constructor(data: CoverageSummary | CoverageSummaryData);
+    merge(obj: CoverageSummary): CoverageSummary;
+    toJSON(): CoverageSummaryData;
+    isEmpty(): boolean;
+    data: CoverageSummaryData;
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+export interface CoverageMapData {
+    [key: string]: FileCoverage | FileCoverageData;
+}
+
+export class CoverageMap {
+    constructor(data: CoverageMapData | CoverageMap);
+    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
+    files(): string[];
+    fileCoverageFor(filename: string): FileCoverage;
+    filter(callback: (key: string) => boolean): void;
+    getCoverageSummary(): CoverageSummary;
+    merge(data: CoverageMapData | CoverageMap): void;
+    toJSON(): CoverageMapData;
+    data: CoverageMapData;
+}
+
+export interface Location {
+    line: number;
+    column: number;
+}
+
+export interface Range {
+    start: Location;
+    end: Location;
+}
+
+export interface BranchMapping {
+    loc: Range;
+    type: string;
+    locations: Range[];
+    line: number;
+}
+
+export interface FunctionMapping {
+    name: string;
+    decl: Range;
+    loc: Range;
+    line: number;
+}
+
+export interface FileCoverageData {
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+export interface Totals {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+
+export interface Coverage {
+    covered: number;
+    total: number;
+    coverage: number;
+}
+
+export class FileCoverage implements FileCoverageData {
+    constructor(data: string | FileCoverage | FileCoverageData);
+    merge(other: FileCoverageData): void;
+    getBranchCoverageByLine(): { [line: number]: Coverage };
+    getLineCoverage(): { [line: number]: number };
+    getUncoveredLines(): number[];
+    resetHits(): void;
+    computeBranchTotals(): Totals;
+    computeSimpleTotals(): Totals;
+    toSummary(): CoverageSummary;
+    toJSON(): object;
+
+    data: FileCoverageData;
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+export const classes: {
+    FileCoverage: FileCoverage;
+};
+
+export function createCoverageMap(data?: CoverageMap | CoverageMapData): CoverageMap;
+export function createCoverageSummary(obj?: CoverageSummary | CoverageSummaryData): CoverageSummary;
+export function createFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): FileCoverage;

package/sdk-test-utilities/node_modules/@types/istanbul-lib-coverage/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/istanbul-lib-coverage",
+    "version": "2.0.6",
+    "description": "TypeScript definitions for istanbul-lib-coverage",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/istanbul-lib-coverage",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Jason Cheatham",
+            "githubUsername": "jason0x43",
+            "url": "https://github.com/jason0x43"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/istanbul-lib-coverage"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "36c823c8b3f66dab91254b0f7299de71768ad8836bfbfcaa062409dd86fbbd61",
+    "typeScriptVersion": "4.5"
+}

package/sdk-test-utilities/node_modules/@types/istanbul-lib-report/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/sdk-test-utilities/node_modules/@types/istanbul-lib-report/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/istanbul-lib-report`
+
+# Summary
+This package contains type definitions for istanbul-lib-report (https://istanbul.js.org).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/istanbul-lib-report.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: [@types/istanbul-lib-coverage](https://npmjs.com/package/@types/istanbul-lib-coverage)
+
+# Credits
+These definitions were written by [Jason Cheatham](https://github.com/jason0x43), and [Zacharias Björngren](https://github.com/zache).