@ariestools/sdk 7.0.3

package/dist/_pkg/object/neutral/index.mjs

@@ -0,0 +1,435 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AsObjectFactory: () => AsObjectFactory,
+  AsTypeFactory: () => AsTypeFactory,
+  IsObjectFactory: () => IsObjectFactory,
+  JsonObjectZod: () => JsonObjectZod,
+  ObjectWrapper: () => ObjectWrapper,
+  ValidatorBase: () => ValidatorBase,
+  asAnyObject: () => asAnyObject,
+  asJsonArray: () => asJsonArray,
+  asJsonObject: () => asJsonObject,
+  asJsonValue: () => asJsonValue,
+  createDeepMerge: () => createDeepMerge,
+  deepMerge: () => deepMerge,
+  isJsonArray: () => isJsonArray,
+  isJsonObject: () => isJsonObject,
+  isJsonValue: () => isJsonValue,
+  isType: () => isType,
+  omitBy: () => omitBy,
+  omitByPrefix: () => omitByPrefix,
+  pickBy: () => pickBy,
+  pickByPrefix: () => pickByPrefix,
+  removeFields: () => removeFields,
+  toJsonArray: () => toJsonArray,
+  toJsonObject: () => toJsonObject,
+  toJsonValue: () => toJsonValue,
+  toSafeJson: () => toSafeJson,
+  toSafeJsonArray: () => toSafeJsonArray,
+  toSafeJsonObject: () => toSafeJsonObject,
+  toSafeJsonString: () => toSafeJsonString,
+  toSafeJsonValue: () => toSafeJsonValue
+});
+
+// src/isType.ts
+var isType = (value, expectedType) => {
+  const typeofValue = typeof value;
+  switch (expectedType) {
+    case "array": {
+      return Array.isArray(value);
+    }
+    case "null": {
+      return value === null;
+    }
+    case "undefined": {
+      return value === void 0;
+    }
+    case "object": {
+      if (value === null) {
+        return false;
+      }
+      return typeofValue === "object" && !Array.isArray(value);
+    }
+    default: {
+      return typeofValue === expectedType;
+    }
+  }
+};
+
+// src/index-un-deprecated.ts
+var index_un_deprecated_exports = {};
+__export(index_un_deprecated_exports, {
+  AsObjectFactory: () => AsObjectFactory,
+  AsTypeFactory: () => AsTypeFactory,
+  IsObjectFactory: () => IsObjectFactory,
+  JsonObjectZod: () => JsonObjectZod,
+  ObjectWrapper: () => ObjectWrapper,
+  ValidatorBase: () => ValidatorBase,
+  asAnyObject: () => asAnyObject,
+  asJsonArray: () => asJsonArray,
+  asJsonObject: () => asJsonObject,
+  asJsonValue: () => asJsonValue,
+  createDeepMerge: () => createDeepMerge,
+  deepMerge: () => deepMerge,
+  isJsonArray: () => isJsonArray,
+  isJsonObject: () => isJsonObject,
+  isJsonValue: () => isJsonValue,
+  omitBy: () => omitBy,
+  omitByPrefix: () => omitByPrefix,
+  pickBy: () => pickBy,
+  pickByPrefix: () => pickByPrefix,
+  removeFields: () => removeFields,
+  toJsonArray: () => toJsonArray,
+  toJsonObject: () => toJsonObject,
+  toJsonValue: () => toJsonValue,
+  toSafeJson: () => toSafeJson,
+  toSafeJsonArray: () => toSafeJsonArray,
+  toSafeJsonObject: () => toSafeJsonObject,
+  toSafeJsonString: () => toSafeJsonString,
+  toSafeJsonValue: () => toSafeJsonValue
+});
+
+// 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 as isType2 } 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 = isType2(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
+__reExport(index_un_deprecated_exports, object_model_star);
+import * as object_model_star from "../../object-model/neutral/index.mjs";
+
+// src/index.ts
+__reExport(index_exports, index_un_deprecated_exports);
+export {
+  AsObjectFactory,
+  AsTypeFactory,
+  IsObjectFactory,
+  JsonObjectZod,
+  ObjectWrapper,
+  ValidatorBase,
+  asAnyObject,
+  asJsonArray,
+  asJsonObject,
+  asJsonValue,
+  createDeepMerge,
+  deepMerge,
+  isJsonArray,
+  isJsonObject,
+  isJsonValue,
+  isType,
+  omitBy,
+  omitByPrefix,
+  pickBy,
+  pickByPrefix,
+  removeFields,
+  toJsonArray,
+  toJsonObject,
+  toJsonValue,
+  toSafeJson,
+  toSafeJsonArray,
+  toSafeJsonObject,
+  toSafeJsonString,
+  toSafeJsonValue
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,4 @@
+import type { FieldType } from '../../typeof/neutral/index.ts';
+/** @deprecated use from @internal/typeof instead */
+export declare const isType: (value: unknown, expectedType: FieldType) => boolean;
+//# sourceMappingURL=isType.d.ts.map

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

@@ -0,0 +1,14 @@
+export type { ObjectTypeConfig } from './IsObjectFactory.ts';
+export type { JsonArray, JsonObject, JsonValue, } from './JsonObject.ts';
+export type { OmitByPredicate } from './omitBy.ts';
+export type * from './OmitStartsWith.ts';
+export type * from './Optional.ts';
+export type * from './Override.ts';
+export type * from './PartialRecord.ts';
+export type * from './PickStartsWith.ts';
+export type * from './Simplify.ts';
+export type * from './StringKeyObject.ts';
+export type { Validator } from './Validator.ts';
+export type * from './WithAdditional.ts';
+export type * from '../../object-model/neutral/model.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/object/neutral/model.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=model.mjs.map

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

@@ -0,0 +1,21 @@
+import type { EmptyObject } from './EmptyObject.ts';
+import type { DeepOmitStartsWith } from './OmitStartsWith.ts';
+/** A predicate function used to determine which properties to omit from an object. */
+export type OmitByPredicate<T extends EmptyObject = Record<string, unknown>> = (value: T[keyof T], key: keyof T) => boolean;
+/**
+ * Creates a new object excluding properties that satisfy the predicate, with optional recursive depth.
+ * @param obj - The source object to omit properties from.
+ * @param predicate - A function that returns true for properties to exclude.
+ * @param maxDepth - Maximum recursion depth for nested objects.
+ * @returns A partial copy of the object without matching properties.
+ */
+export declare const omitBy: <T extends EmptyObject>(obj: T, predicate: OmitByPredicate, maxDepth?: number) => Partial<T>;
+/**
+ * Omits all properties whose keys start with the given prefix, recursively through nested objects.
+ * @param payload - The source object.
+ * @param prefix - The string prefix to match keys against.
+ * @param maxDepth - Maximum recursion depth.
+ * @returns A new object without properties that have matching prefixed keys.
+ */
+export declare const omitByPrefix: <T extends EmptyObject, P extends string>(payload: T, prefix: P, maxDepth?: number) => DeepOmitStartsWith<T, P>;
+//# sourceMappingURL=omitBy.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { EmptyObject } from './EmptyObject.ts';
+import type { DeepPickStartsWith } from './PickStartsWith.ts';
+/** A predicate function used to determine which properties to pick from an object. */
+export type PickByPredicate<T extends EmptyObject = Record<string, unknown>> = (value: T[keyof T], key: keyof T) => boolean;
+/**
+ * Creates a new object containing only the properties that satisfy the predicate, with optional recursive depth.
+ * @param obj - The source object to pick properties from.
+ * @param predicate - A function that returns true for properties to include.
+ * @param maxDepth - Maximum recursion depth for nested objects.
+ * @returns A partial copy of the object with only matching properties.
+ */
+export declare const pickBy: <T extends EmptyObject>(obj: T, predicate: PickByPredicate, maxDepth?: number) => Partial<T>;
+/**
+ * Picks all properties whose keys start with the given prefix, recursively through nested objects.
+ * @param payload - The source object.
+ * @param prefix - The string prefix to match keys against.
+ * @param maxDepth - Maximum recursion depth.
+ * @returns A new object containing only properties with matching prefixed keys.
+ */
+export declare const pickByPrefix: <T extends EmptyObject, P extends string>(payload: T, prefix: P, maxDepth?: number) => DeepPickStartsWith<T, P>;
+//# sourceMappingURL=pickBy.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { EmptyObject } from './EmptyObject.ts';
+/**
+ * Returns a shallow copy of the object with the specified fields removed.
+ * @param obj - The source object.
+ * @param fields - An array of keys to remove.
+ * @returns A new object without the specified fields.
+ */
+export declare const removeFields: <T extends EmptyObject, K extends keyof T>(obj: T, fields: K[]) => Omit<T, K>;
+//# sourceMappingURL=removeFields.d.ts.map

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

@@ -0,0 +1,41 @@
+import type { JsonArray, JsonObject, JsonValue } from './JsonObject.ts';
+/**
+ * Converts an array to a JSON-safe array, handling circular references and depth limits.
+ * @param value - The array to convert.
+ * @param cycleList - Tracks visited objects to detect circular references.
+ * @param maxDepth - Maximum recursion depth before truncating.
+ * @returns A JSON-safe array representation.
+ */
+export declare const toSafeJsonArray: (value: unknown[], cycleList?: unknown[], maxDepth?: number) => JsonArray;
+/**
+ * Converts an object to a JSON-safe object, handling circular references and depth limits.
+ * @param value - The object to convert.
+ * @param cycleList - Tracks visited objects to detect circular references.
+ * @param maxDepth - Maximum recursion depth before truncating.
+ * @returns A JSON-safe object representation.
+ */
+export declare const toSafeJsonObject: (value: object, cycleList?: unknown[], maxDepth?: number) => JsonObject;
+/**
+ * Converts an unknown value to a JSON-safe value, replacing circular references with '[Circular]' and
+ * non-JSON types with descriptive placeholder strings.
+ * @param value - The value to convert.
+ * @param cycleList - Tracks visited objects to detect circular references.
+ * @param maxDepth - Maximum recursion depth before truncating with '[MaxDepth]'.
+ * @returns A JSON-safe representation of the value.
+ */
+export declare const toSafeJsonValue: (value: unknown, cycleList?: unknown[], maxDepth?: number) => JsonValue;
+/**
+ * Converts a value to a pretty-printed JSON string, safely handling circular references and non-JSON types.
+ * @param value - The value to serialize.
+ * @param maxDepth - Maximum recursion depth.
+ * @returns A formatted JSON string.
+ */
+export declare const toSafeJsonString: (value: unknown, maxDepth?: number) => string;
+/**
+ * Converts a value to a JSON-safe representation, handling circular references and non-serializable types.
+ * @param value - The value to convert.
+ * @param maxDepth - Maximum recursion depth.
+ * @returns A JSON-safe value.
+ */
+export declare const toSafeJson: (value: unknown, maxDepth?: number) => JsonValue;
+//# sourceMappingURL=toSafeJson.d.ts.map

package/dist/_pkg/object-model/neutral/AnyObject.d.ts

@@ -0,0 +1,8 @@
+import type { TypedKey } from '../../typeof/neutral/index.ts';
+import type { EmptyObject } from './EmptyObject.ts';
+/**
+ * Any object, which means that it does not enforce the set of fields that it has.  Extending from AnyObject
+ * will result in a type that includes the universal set of field names
+ */
+export type AnyObject = EmptyObject & Partial<Record<TypedKey, unknown>>;
+//# sourceMappingURL=AnyObject.d.ts.map

package/dist/_pkg/object-model/neutral/AsTypeFactory.d.ts

@@ -0,0 +1,12 @@
+import type { AnyNonPromise } from '../../promise/neutral/index.ts';
+import type { AsTypeFunction } from './AsTypeFunction.ts';
+import type { TypeCheck } from './types.ts';
+/**
+ * Factory for creating type-narrowing 'as' functions that cast a value to T or return undefined.
+ * Supports optional assertion messages and configuration for required/optional behavior.
+ */
+export declare const AsTypeFactory: {
+    create: <T extends AnyNonPromise>(typeCheck: TypeCheck<T>) => AsTypeFunction<T>;
+    createOptional: <T extends AnyNonPromise>(typeCheck: TypeCheck<T>) => (value: AnyNonPromise) => T | undefined;
+};
+//# sourceMappingURL=AsTypeFactory.d.ts.map

package/dist/_pkg/object-model/neutral/AsTypeFunction.d.ts

@@ -0,0 +1,14 @@
+import type { AnyNonPromise } from '../../promise/neutral/index.ts';
+import type { StringOrAlertFunction, TypeCheckConfig, TypeCheckOptionalConfig, TypeCheckRequiredConfig } from './types.ts';
+/** A type-narrowing function that attempts to cast a value to T, with optional assertion and configuration overloads. */
+export interface AsTypeFunction<T extends AnyNonPromise = AnyNonPromise> {
+    <TType extends T>(value: AnyNonPromise): TType | undefined;
+    <TType extends T>(value: AnyNonPromise, config: TypeCheckRequiredConfig): TType;
+    <TType extends T>(value: AnyNonPromise, config: TypeCheckConfig | TypeCheckOptionalConfig): TType | undefined;
+    <TType extends T>(value: AnyNonPromise, assert: StringOrAlertFunction<TType>): TType | undefined;
+    <TType extends T>(value: AnyNonPromise, assert: StringOrAlertFunction<TType>, config: TypeCheckRequiredConfig): TType;
+    <TType extends T>(value: AnyNonPromise, assert: StringOrAlertFunction<TType>, config: TypeCheckConfig | TypeCheckOptionalConfig): TType | undefined;
+}
+/** A simplified type-narrowing function that returns T or undefined, without assertion support. */
+export type AsOptionalTypeFunction<T extends AnyNonPromise = AnyNonPromise> = <TType extends T>(value: AnyNonPromise) => TType | undefined;
+//# sourceMappingURL=AsTypeFunction.d.ts.map

package/dist/_pkg/object-model/neutral/Compare.d.ts

@@ -0,0 +1,3 @@
+/** A comparator function that returns a negative number if a < b, zero if a == b, and a positive number if a > b. */
+export type Compare<T> = (a: T, b: T) => number;
+//# sourceMappingURL=Compare.d.ts.map

package/dist/_pkg/object-model/neutral/EmptyObject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An empty object, which means that it does enforce the set of field names, defaulting to an empty set until
+ * extended from, which then adds only those additional fields
+ */
+export type EmptyObject<T extends object = object> = Exclude<{
+    [K in keyof T]?: never;
+}, unknown[] | ((...args: unknown[]) => unknown) | null>;
+//# sourceMappingURL=EmptyObject.d.ts.map

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

@@ -0,0 +1,6 @@
+export * from './AnyObject.ts';
+export * from './AsTypeFunction.ts';
+export * from './Compare.ts';
+export * from './EmptyObject.ts';
+export * from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/object-model/neutral/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/object-model/neutral/model.d.ts

@@ -0,0 +1,6 @@
+export type * from './AnyObject.ts';
+export type * from './AsTypeFunction.ts';
+export type * from './Compare.ts';
+export type * from './EmptyObject.ts';
+export type * from './types.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/object-model/neutral/model.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/object-model/neutral/types.d.ts

@@ -0,0 +1,25 @@
+import type { AssertExMessageFunc } from '../../assert/neutral/index.ts';
+import type { Logger } from '../../logger/neutral/index.ts';
+import type { AnyNonPromise } from '../../promise/neutral/index.ts';
+import type { TypedValue } from '../../typeof/neutral/index.ts';
+/** Configuration options for type check functions, with optional logging. */
+export interface TypeCheckConfig {
+    log?: boolean | Logger;
+}
+/** Type check configuration that marks the value as required, causing assertions on failure. */
+export interface TypeCheckRequiredConfig extends TypeCheckConfig {
+    required: true;
+}
+/** Type check configuration that marks the value as optional, returning undefined on failure. */
+export interface TypeCheckOptionalConfig extends TypeCheckConfig {
+    required: false;
+}
+/** A string message or function that produces an assertion error message for a failed type check. */
+export type StringOrAlertFunction<T extends AnyNonPromise> = string | AssertExMessageFunc<T>;
+/** A type guard function that checks whether a value conforms to type T, with optional configuration. */
+export interface TypeCheck<T extends TypedValue> {
+    (obj: AnyNonPromise): obj is T;
+    (obj: AnyNonPromise, config: TypeCheckConfig): obj is T;
+    (obj: AnyNonPromise, config: TypeCheckConfig | number | undefined): obj is T;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_pkg/platform/browser/browser/index.d.ts

@@ -0,0 +1,9 @@
+/** Returns whether the current environment is a browser window (not a web worker). */
+export declare const isBrowser: () => boolean;
+/** Returns whether the current environment is a dedicated web worker. */
+export declare const isWebworker: () => boolean;
+/** Returns whether the current environment is Node.js. Always returns false in the browser entry point. */
+export declare const isNode: () => boolean;
+/** The Web Crypto API's SubtleCrypto interface, sourced from the browser's globalThis.crypto. */
+export declare const subtle: SubtleCrypto;
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/platform/browser/index-browser.d.ts

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