@ariestools/sdk 7.0.3

package/dist/_pkg/object/neutral/JsonObject.d.ts

@@ -0,0 +1,49 @@
+import * as z from 'zod/mini';
+declare const JsonArrayZod: z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+declare const JsonValueZod: z.ZodMiniType<unknown>;
+/** Zod schema for a JSON object with string keys and recursive JSON values. */
+export declare const JsonObjectZod: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/** A recursive JSON value: string, number, boolean, null, array, or object. */
+export type JsonValue = z.infer<typeof JsonValueZod>;
+/** A JSON object with string keys and JSON values. */
+export type JsonObject = z.infer<typeof JsonObjectZod>;
+/** A JSON array containing JSON values. */
+export type JsonArray = z.infer<typeof JsonArrayZod>;
+/** Type guard that checks if a value is a valid JSON value. */
+export declare const isJsonValue: <T>(value: T) => value is T;
+/** Casts a value to JsonValue or returns undefined if it does not conform. */
+export declare const asJsonValue: {
+    <T>(value: T): T | undefined;
+    <T>(value: T, assert: import("../../zod/neutral/index.ts").ZodFactoryConfig): T;
+};
+/** Parses a value into a JsonValue, throwing if it does not conform. */
+export declare const toJsonValue: {
+    <T>(value: T): T | undefined;
+    <T>(value: T, assert: import("../../zod/neutral/index.ts").ZodFactoryConfig): T;
+};
+/** Type guard that checks if a value is a valid JSON array. */
+export declare const isJsonArray: <T>(value: T) => value is T & unknown[];
+/** Casts a value to JsonArray or returns undefined if it does not conform. */
+export declare const asJsonArray: {
+    <T>(value: T): (T & unknown[]) | undefined;
+    <T>(value: T, assert: import("../../zod/neutral/index.ts").ZodFactoryConfig): T & unknown[];
+};
+/** Parses a value into a JsonArray, throwing if it does not conform. */
+export declare const toJsonArray: {
+    <T>(value: T): (T & unknown[]) | undefined;
+    <T>(value: T, assert: import("../../zod/neutral/index.ts").ZodFactoryConfig): T & unknown[];
+};
+/** Type guard that checks if a value is a valid JSON object. */
+export declare const isJsonObject: <T>(value: T) => value is T & Record<string, unknown>;
+/** Casts a value to JsonObject or returns undefined if it does not conform. */
+export declare const asJsonObject: {
+    <T>(value: T): (T & Record<string, unknown>) | undefined;
+    <T>(value: T, assert: import("../../zod/neutral/index.ts").ZodFactoryConfig): T & Record<string, unknown>;
+};
+/** Parses a value into a JsonObject, throwing if it does not conform. */
+export declare const toJsonObject: {
+    <T>(value: T): (T & Record<string, unknown>) | undefined;
+    <T>(value: T, assert: import("../../zod/neutral/index.ts").ZodFactoryConfig): T & Record<string, unknown>;
+};
+export {};
+//# sourceMappingURL=JsonObject.d.ts.map

package/dist/_pkg/object/neutral/ObjectWrapper.d.ts

@@ -0,0 +1,9 @@
+import type { EmptyObject } from './EmptyObject.ts';
+import type { StringKeyObject } from './StringKeyObject.ts';
+/** Abstract base class that wraps an object and provides typed access to it. */
+export declare abstract class ObjectWrapper<T extends EmptyObject = EmptyObject> {
+    readonly obj: T;
+    constructor(obj: T);
+    protected get stringKeyObj(): StringKeyObject;
+}
+//# sourceMappingURL=ObjectWrapper.d.ts.map

package/dist/_pkg/object/neutral/OmitStartsWith.d.ts

@@ -0,0 +1,18 @@
+import type { JsonValue } from './JsonObject.ts';
+/** Omits the keys of T that start with the given prefix. */
+export type OmitStartsWith<T, Prefix extends string> = {
+    [K in keyof T as K extends `${Prefix}${string}` ? never : K]: T[K];
+};
+/** Recursively omits keys that start with the given prefix, including in nested objects and arrays. */
+export type DeepOmitStartsWith<T, Prefix extends string> = T extends (infer U)[] ? DeepOmitStartsWith<U, Prefix>[] : T extends object ? {
+    [K in keyof T as K extends string ? K extends `${Prefix}${string}` ? never : K : K]: DeepOmitStartsWith<T[K], Prefix>;
+} : T;
+/** Recursively removes all non-string keys from an object type, including in nested objects and arrays. */
+export type DeepRestrictToStringKeys<T> = {
+    [K in keyof T as K extends string ? K : never]: T[K] extends (infer U)[] ? DeepRestrictToStringKeys<U>[] : T[K] extends object ? DeepRestrictToStringKeys<T[K]> : T[K];
+};
+/** Recursively restricts an object type to only JSON-compatible values, excluding non-serializable types. */
+export type DeepRestrictToJson<T> = {
+    [K in keyof T as K extends string ? K : never]: T[K] extends (infer U)[] ? DeepRestrictToJson<U>[] : T[K] extends object ? DeepRestrictToJson<T[K]> : T[K] extends JsonValue ? T[K] : never;
+};
+//# sourceMappingURL=OmitStartsWith.d.ts.map

package/dist/_pkg/object/neutral/Optional.d.ts

@@ -0,0 +1,3 @@
+/** Makes the specified fields of T optional while keeping the rest required. */
+export type Optional<T extends object, F extends keyof T> = Omit<T, F> & Partial<Pick<T, F>>;
+//# sourceMappingURL=Optional.d.ts.map

package/dist/_pkg/object/neutral/Override.d.ts

@@ -0,0 +1,4 @@
+/** Overrides properties of T1 with those from T2. */
+type Override<T1, T2> = Omit<T1, keyof T2> & T2;
+export type { Override };
+//# sourceMappingURL=Override.d.ts.map

package/dist/_pkg/object/neutral/PartialRecord.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated use Partial<Record<>> instead */
+export type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>;
+//# sourceMappingURL=PartialRecord.d.ts.map

package/dist/_pkg/object/neutral/PickStartsWith.d.ts

@@ -0,0 +1,9 @@
+/** Picks only the keys of T that start with the given prefix. */
+export type PickStartsWith<T, Prefix extends string> = {
+    [K in keyof T as K extends `${Prefix}${string}` ? K : never]: T[K];
+};
+/** Recursively picks only the keys that start with the given prefix, including in nested objects and arrays. */
+export type DeepPickStartsWith<T, Prefix extends string> = T extends (infer U)[] ? DeepPickStartsWith<U, Prefix>[] : T extends object ? {
+    [K in keyof T as K extends string ? K extends `${Prefix}${string}` ? K : never : K]: DeepPickStartsWith<T[K], Prefix>;
+} : T;
+//# sourceMappingURL=PickStartsWith.d.ts.map

package/dist/_pkg/object/neutral/Simplify.d.ts

@@ -0,0 +1,5 @@
+/** Flattens an intersection or complex mapped type into a single object type for better readability. */
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+//# sourceMappingURL=Simplify.d.ts.map

package/dist/_pkg/object/neutral/StringKeyObject.d.ts

@@ -0,0 +1,3 @@
+/** An object type with string keys and values of type T. */
+export type StringKeyObject<T = unknown> = Record<string, T>;
+//# sourceMappingURL=StringKeyObject.d.ts.map

package/dist/_pkg/object/neutral/Validator.d.ts

@@ -0,0 +1,13 @@
+import type { AnyObject } from '../../object-model/neutral/index.ts';
+import type { Promisable } from '../../promise/neutral/index.ts';
+import type { EmptyObject } from './EmptyObject.ts';
+import { ObjectWrapper } from './ObjectWrapper.ts';
+/** Interface for validating objects and returning any errors found. */
+export interface Validator<T extends EmptyObject = AnyObject> {
+    validate(payload: T): Promisable<Error[]>;
+}
+/** Abstract base class for validators that wraps a partial object and provides a validation method. */
+export declare abstract class ValidatorBase<T extends EmptyObject = AnyObject> extends ObjectWrapper<Partial<T>> implements Validator<T> {
+    abstract validate(payload: T): Promisable<Error[]>;
+}
+//# sourceMappingURL=Validator.d.ts.map

package/dist/_pkg/object/neutral/WithAdditional.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyObject } from './EmptyObject.ts';
+/** Intersects T with TAdditional if TAdditional is an object, otherwise returns T unchanged. */
+export type WithAdditional<T extends EmptyObject | void, TAdditional extends EmptyObject | void = void> = TAdditional extends EmptyObject ? T & TAdditional : T;
+//# sourceMappingURL=WithAdditional.d.ts.map

package/dist/_pkg/object/neutral/asObject.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from '../../object-model/neutral/index.ts';
+/** Type-narrowing function that casts a value to AnyObject if it is a plain object, or returns undefined. */
+export declare const asAnyObject: import("../../object-model/neutral/index.ts").AsTypeFunction<AnyObject>;
+//# sourceMappingURL=asObject.d.ts.map

package/dist/_pkg/object/neutral/deepMerge.d.ts

@@ -0,0 +1,49 @@
+import type { AnyObject } from '../../object-model/neutral/index.ts';
+/**
+ * Deeply merges two types into a new type.
+ */
+type DeepMerge<A, B> = {
+    [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? A[K] extends object ? B[K] extends object ? DeepMerge<A[K], B[K]> : B[K] : B[K] : B[K] : K extends keyof A ? A[K] : never;
+};
+/**
+ * Merges multiple types into a new type.
+ */
+type MergeAll<T extends object[], R = {}> = T extends [infer First extends object, ...infer Rest extends object[]] ? MergeAll<Rest, DeepMerge<R, First>> : R;
+/**
+ * Options for merging objects in the deep merge function.
+ */
+interface MergeOptions {
+    /**
+     * Strategy for merging arrays.
+     * - 'overwrite': Overwrites the array with the last object's value.
+     * - 'concat': Concatenates arrays from all objects.
+     * @default 'overwrite'
+     */
+    arrayStrategy?: 'overwrite' | 'concat';
+    /**
+     * Mutate the first object in the list instead of creating a new one.
+     * @default false
+     */
+    mutate?: boolean;
+}
+/**
+ * Creates a deep merge function with the specified options.
+ * @param options Options for merging.
+ * @returns A deep merge function configured for the specified options.
+ */
+export declare function createDeepMerge(options: MergeOptions): <T extends AnyObject[]>(...objects: T) => MergeAll<T>;
+/**
+ * Deeply merges multiple objects into a new object.
+ * @param objects Multiple objects to merge deeply.
+ * The function merges properties from all objects into a new object.
+ * If a property exists in multiple objects, the last object's value will be used.
+ * If a property is an object, it will be merged recursively.
+ * If a property is an array, it will be overwritten by the last object's value.
+ * If a property is a primitive value, it will be overwritten by the last object's value.
+ * If a property is undefined in the source, it will be skipped.
+ * If a property is a symbol, it will be merged as well.
+ * @returns A new object with the merged properties.
+ */
+export declare const deepMerge: <T extends AnyObject[]>(...objects: T) => MergeAll<T>;
+export {};
+//# sourceMappingURL=deepMerge.d.ts.map

package/dist/_pkg/object/neutral/index-deprecated.d.ts

@@ -0,0 +1,2 @@
+export * from './isType.ts';
+//# sourceMappingURL=index-deprecated.d.ts.map

package/dist/_pkg/object/neutral/index-un-deprecated.d.ts

@@ -0,0 +1,22 @@
+export * from './asObject.ts';
+export * from './AsObjectFactory.ts';
+export * from './AsTypeFactory.ts';
+export * from './deepMerge.ts';
+export * from './IsObjectFactory.ts';
+export * from './JsonObject.ts';
+export * from './ObjectWrapper.ts';
+export * from './omitBy.ts';
+export * from './OmitStartsWith.ts';
+export * from './Optional.ts';
+export * from './Override.ts';
+export * from './PartialRecord.ts';
+export * from './pickBy.ts';
+export * from './PickStartsWith.ts';
+export * from './removeFields.ts';
+export * from './Simplify.ts';
+export * from './StringKeyObject.ts';
+export * from './toSafeJson.ts';
+export * from './Validator.ts';
+export * from './WithAdditional.ts';
+export * from '../../object-model/neutral/index.ts';
+//# sourceMappingURL=index-un-deprecated.d.ts.map

package/dist/_pkg/object/neutral/index-un-deprecated.mjs

@@ -0,0 +1,320 @@
+// src/asObject.ts
+import { isObject } from "../../typeof/neutral/index.mjs";
+
+// src/AsTypeFactory.ts
+import { assertDefinedEx } from "../../assert/neutral/index.mjs";
+import { isPromise, isTruthy } from "../../typeof/neutral/index.mjs";
+var AsTypeFactory = {
+  create: (typeCheck) => {
+    const func = (value, assertOrConfig, config) => {
+      const isPredicate = typeof assertOrConfig === "number";
+      const resolvedAssert = isPredicate || typeof assertOrConfig === "object" ? void 0 : assertOrConfig;
+      const resolvedConfig = isPredicate ? void 0 : typeof assertOrConfig === "object" ? assertOrConfig : config;
+      const isRequired = isTruthy(resolvedConfig?.required);
+      if (!isRequired && (value === void 0 || value === null)) {
+        return void 0;
+      }
+      if (isPromise(value)) {
+        throw new TypeError('un-awaited promises may not be sent to "as" functions');
+      }
+      const result = typeCheck(value, resolvedConfig) ? value : void 0;
+      if (resolvedAssert !== void 0) {
+        const message = typeof resolvedAssert === "function" ? resolvedAssert : () => resolvedAssert;
+        return assertDefinedEx(result, message);
+      }
+      return result;
+    };
+    return func;
+  },
+  createOptional: (typeCheck) => {
+    const func = (value) => {
+      if (value === void 0 || value === null) return void 0;
+      if (isPromise(value)) {
+        throw new TypeError('un-awaited promises may not be sent to "as" functions');
+      }
+      return typeCheck(value) ? value : void 0;
+    };
+    return func;
+  }
+};
+
+// src/AsObjectFactory.ts
+var AsObjectFactory = {
+  create: (typeCheck) => {
+    return AsTypeFactory.create(typeCheck);
+  },
+  createOptional: (typeCheck) => {
+    return AsTypeFactory.createOptional(typeCheck);
+  }
+};
+
+// src/asObject.ts
+var asAnyObject = (() => AsObjectFactory.create((obj) => isObject(obj)))();
+
+// src/deepMerge.ts
+var isUnsafeKey = (key) => typeof key === "string" && ["__proto__", "constructor", "prototype"].includes(key);
+var isPlainObject = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+function merge(target, source, options) {
+  if (!source || typeof source !== "object") return target;
+  for (const key of Reflect.ownKeys(source)) {
+    if (isUnsafeKey(key)) {
+      continue;
+    }
+    const value = source[key];
+    if (Array.isArray(value)) {
+      const targetValue = target[key];
+      target[key] = options?.arrayStrategy === "concat" && Array.isArray(targetValue) ? [...targetValue, ...value] : value;
+    } else if (value !== null && typeof value === "object" && isPlainObject(value)) {
+      const targetValue = target[key];
+      if (targetValue === void 0 || targetValue === null || typeof targetValue !== "object" || !isPlainObject(targetValue)) {
+        target[key] = {};
+      }
+      merge(target[key], value, options);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+function createDeepMerge(options) {
+  return function deepMerge2(...objects) {
+    const result = options.mutate === true ? objects[0] ?? {} : {};
+    for (const obj of objects) {
+      merge(result, obj, options);
+    }
+    return result;
+  };
+}
+var deepMerge = createDeepMerge({ arrayStrategy: "overwrite", mutate: false });
+
+// src/IsObjectFactory.ts
+import {
+  isObject as isObject2,
+  isTruthy as isTruthy2
+} from "../../typeof/neutral/index.mjs";
+import { isType } from "../../typeof/neutral/index.mjs";
+var IsObjectFactory = class {
+  /**
+   * Creates a type-guard function that validates an object matches the given shape and passes additional checks.
+   * @param shape - An optional map of property names to expected types.
+   * @param additionalChecks - Optional extra type-check functions to run after shape validation.
+   * @returns A type-guard function for type T.
+   */
+  create(shape, additionalChecks) {
+    return (obj, config) => {
+      if (!isObject2(obj)) {
+        return false;
+      }
+      const log = typeof config === "object" ? config.log : void 0;
+      return (
+        // do primary check
+        Object.entries(shape ?? {}).filter(([key, type]) => {
+          const isResult = isType(obj[key], type);
+          if (!isResult && isTruthy2(log)) {
+            const logger = typeof log === "object" ? log : console;
+            logger.warn(`isType Failed: ${key}: ${type}`);
+          }
+          return !isResult;
+        }).length === 0 && (additionalChecks?.reduce((prev, check) => prev && check(obj, { log }), true) ?? true)
+      );
+    };
+  }
+};
+
+// src/JsonObject.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "../../zod/neutral/index.mjs";
+import * as z from "zod/mini";
+var JsonArrayZod = z.array(z.lazy(() => JsonValueZod));
+var JsonValueZod = z.lazy(() => z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.array(JsonValueZod),
+  z.record(z.string(), JsonValueZod)
+  // object with string keys and JSON values
+]));
+var JsonObjectZod = z.record(z.string(), JsonValueZod);
+var isJsonValue = zodIsFactory(JsonValueZod);
+var asJsonValue = zodAsFactory(JsonValueZod, "asJsonValue");
+var toJsonValue = zodToFactory(JsonValueZod, "toJsonValue");
+var isJsonArray = zodIsFactory(JsonArrayZod);
+var asJsonArray = zodAsFactory(JsonArrayZod, "asJsonArray");
+var toJsonArray = zodToFactory(JsonArrayZod, "toJsonArray");
+var isJsonObject = zodIsFactory(JsonObjectZod);
+var asJsonObject = zodAsFactory(JsonObjectZod, "asJsonObject");
+var toJsonObject = zodToFactory(JsonObjectZod, "toJsonObject");
+
+// src/ObjectWrapper.ts
+var ObjectWrapper = class {
+  obj;
+  constructor(obj) {
+    this.obj = obj;
+  }
+  get stringKeyObj() {
+    return this.obj;
+  }
+};
+
+// src/omitBy.ts
+import { assertEx } from "../../assert/neutral/index.mjs";
+var omitByArray = (obj, predicate, maxDepth) => {
+  return obj.map((value) => {
+    return value !== null && typeof value === "object" ? omitBy(value, predicate, maxDepth) : value;
+  });
+};
+var omitByObject = (obj, predicate, maxDepth) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (!predicate(value, key)) {
+      result[key] = value !== null && typeof value === "object" ? omitBy(value, predicate, maxDepth - 1) : value;
+    }
+  }
+  return result;
+};
+var omitBy = (obj, predicate, maxDepth = 1) => {
+  if (maxDepth <= 0) {
+    return obj;
+  }
+  return Array.isArray(obj) ? omitByArray(obj, predicate, maxDepth - 1) : omitByObject(obj, predicate, maxDepth - 1);
+};
+var omitByPrefixPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${key}, ${typeof key}]`);
+  return key.startsWith(prefix);
+};
+var omitByPrefix = (payload, prefix, maxDepth = 100) => {
+  return omitBy(payload, omitByPrefixPredicate(prefix), maxDepth);
+};
+
+// src/pickBy.ts
+import { assertEx as assertEx2 } from "../../assert/neutral/index.mjs";
+var pickByArray = (obj, predicate, maxDepth) => {
+  return obj.map((value) => {
+    return value !== null && typeof value === "object" ? pickBy(value, predicate, maxDepth) : value;
+  });
+};
+var pickByObject = (obj, predicate, maxDepth) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (predicate(value, key)) {
+      result[key] = value !== null && typeof value === "object" ? pickBy(value, predicate, maxDepth - 1) : value;
+    }
+  }
+  return result;
+};
+var pickBy = (obj, predicate, maxDepth = 1) => {
+  if (maxDepth <= 0) {
+    return obj;
+  }
+  return Array.isArray(obj) ? pickByArray(obj, predicate, maxDepth - 1) : pickByObject(obj, predicate, maxDepth - 1);
+};
+var pickByPrefixPredicate = (prefix) => (_, key) => {
+  assertEx2(typeof key === "string", () => `Invalid key type [${key}, ${typeof key}]`);
+  return key.startsWith(prefix);
+};
+var pickByPrefix = (payload, prefix, maxDepth = 100) => {
+  return pickBy(payload, pickByPrefixPredicate(prefix), maxDepth);
+};
+
+// src/removeFields.ts
+var removeFields = (obj, fields) => {
+  const clone = { ...obj };
+  for (const field of fields) {
+    delete clone[field];
+  }
+  return clone;
+};
+
+// src/toSafeJson.ts
+var toSafeJsonArray = (value, cycleList, maxDepth = 3) => {
+  return value.map((item) => toSafeJsonValue(item, cycleList, maxDepth));
+};
+var toSafeJsonObject = (value, cycleList, maxDepth = 3) => {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = entry === void 0 ? "[Undefined]" : toSafeJsonValue(entry, cycleList, maxDepth);
+  }
+  return result;
+};
+var toSafeJsonValue = (value, cycleList, maxDepth = 3) => {
+  if (maxDepth <= 0 && typeof value === "object") {
+    return "[MaxDepth]";
+  }
+  if (cycleList?.includes(value) === true) {
+    return "[Circular]";
+  }
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+    case "number": {
+      return value;
+    }
+    case "object": {
+      if (value === null) {
+        return null;
+      }
+      const newCycleList = cycleList ?? [];
+      newCycleList.push(value);
+      if (Array.isArray(value)) {
+        return toSafeJsonArray(value, newCycleList, maxDepth - 1);
+      }
+      return toSafeJsonObject(value, newCycleList, maxDepth - 1);
+    }
+    default: {
+      return `[${typeof value}]`;
+    }
+  }
+};
+var toSafeJsonString = (value, maxDepth = 3) => {
+  return JSON.stringify(toSafeJson(value, maxDepth), null, 2);
+};
+var toSafeJson = (value, maxDepth = 3) => {
+  return toSafeJsonValue(value, void 0, maxDepth);
+};
+
+// src/Validator.ts
+var ValidatorBase = class extends ObjectWrapper {
+};
+
+// src/index-un-deprecated.ts
+export * from "../../object-model/neutral/index.mjs";
+export {
+  AsObjectFactory,
+  AsTypeFactory,
+  IsObjectFactory,
+  JsonObjectZod,
+  ObjectWrapper,
+  ValidatorBase,
+  asAnyObject,
+  asJsonArray,
+  asJsonObject,
+  asJsonValue,
+  createDeepMerge,
+  deepMerge,
+  isJsonArray,
+  isJsonObject,
+  isJsonValue,
+  omitBy,
+  omitByPrefix,
+  pickBy,
+  pickByPrefix,
+  removeFields,
+  toJsonArray,
+  toJsonObject,
+  toJsonValue,
+  toSafeJson,
+  toSafeJsonArray,
+  toSafeJsonObject,
+  toSafeJsonString,
+  toSafeJsonValue
+};
+//# sourceMappingURL=index-un-deprecated.mjs.map

package/dist/_pkg/object/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './index-deprecated.ts';
+export * from './index-un-deprecated.ts';
+//# sourceMappingURL=index.d.ts.map