@ariestools/sdk 7.0.3

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

@@ -0,0 +1,381 @@
+// src/address/address.ts
+import * as z from "zod/mini";
+
+// src/HexRegEx.ts
+var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegEx = /^[0-9a-f]+$/;
+var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
+
+// src/address/address.ts
+var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
+var ADDRESS_LENGTH = 40;
+var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+var AddressZod = z.pipe(
+  z.string().check(z.regex(AddressRegEx)),
+  z.transform((v) => v)
+);
+
+// src/address/AddressTransformZod.ts
+import * as z4 from "zod/mini";
+
+// src/address/AddressValidationZod.ts
+import * as z3 from "zod/mini";
+
+// src/hex/as.ts
+import { assertError } from "../../error/neutral/index.mjs";
+
+// src/hex/from/fromHexString.ts
+import { isNumber } from "../../typeof/neutral/index.mjs";
+
+// src/hex/nibble.ts
+var bitsToNibbles = (value) => {
+  const nibbles = value >> 2;
+  if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
+  return nibbles;
+};
+var nibblesToBits = (value) => {
+  return value << 2;
+};
+
+// src/hex/is.ts
+var isHex = (value, config) => {
+  if (typeof value !== "string") return false;
+  const valueCharLength = value.length - (config?.prefix === true ? 2 : 0);
+  if (config?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config?.bitLength)) return false;
+  const regex5 = config?.prefix === true ? HexRegExWithPrefix : HexRegEx;
+  return regex5.test(value);
+};
+
+// src/hex/from/fromHexString.ts
+var hexFromHexString = (value, config = {}) => {
+  const {
+    prefix: isPrefix = false,
+    byteSize = 8,
+    bitLength
+  } = config;
+  const nibbleBoundary = bitsToNibbles(byteSize);
+  const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+  if (isHex(unEvened)) {
+    const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, "0");
+    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
+    return (isPrefix ? `0x${padded}` : padded).toLowerCase();
+  }
+  throw new Error("Received string is not a value hex");
+};
+
+// src/hex/from/fromArrayBuffer.ts
+var hexFromArrayBuffer = (buffer, config) => {
+  const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hexFromHexString(unPadded, config);
+};
+
+// src/hex/from/fromBigInt.ts
+var hexFromBigInt = (value, config = {}) => {
+  const unPadded = value.toString(16);
+  return hexFromHexString(unPadded, config);
+};
+
+// src/hex/from/fromNumber.ts
+var hexFromNumber = (value, config) => {
+  return hexFromBigInt(BigInt(value), config);
+};
+
+// src/hex/from/from.ts
+var hexFrom = (value, config) => {
+  switch (typeof value) {
+    case "string": {
+      return hexFromHexString(value, config);
+    }
+    case "bigint": {
+      return hexFromBigInt(value, config);
+    }
+    case "number": {
+      return hexFromNumber(value, config);
+    }
+    case "object": {
+      return hexFromArrayBuffer(value, config);
+    }
+    default: {
+      throw new Error(`Invalid type: ${typeof value}`);
+    }
+  }
+};
+
+// src/hex/as.ts
+function asHex(value, assert) {
+  switch (typeof value) {
+    case "string": {
+      const stringValue = hexFromHexString(value);
+      return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`);
+    }
+    default: {
+      return assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+}
+
+// src/hex/hex.ts
+import * as z2 from "zod/mini";
+var HexZod = z2.pipe(
+  z2.string().check(z2.regex(HexRegEx, { error: "Invalid hex format" })),
+  z2.transform((val) => val)
+);
+
+// src/hex/isHexZero.ts
+import { isString } from "../../typeof/neutral/index.mjs";
+var isHexZero = (value) => {
+  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : void 0;
+};
+
+// src/hex/legacy.ts
+var toHexLegacy = (buffer) => {
+  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+};
+
+// src/hex/to.ts
+var toHex = (value, config = {}) => {
+  const { prefix: isPrefix = false } = config;
+  return hexFrom(value, { prefix: isPrefix, ...config });
+};
+
+// src/address/AddressValidationZod.ts
+var AddressValidationZod = z3.pipe(
+  z3.string().check(
+    z3.refine((x) => HexZod.safeParse(x).success),
+    z3.refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${String(e.input)}]`) })
+  ),
+  z3.transform((v) => v)
+);
+
+// src/address/AddressTransformZod.ts
+var AddressTransformZod = z4.pipe(
+  z4.pipe(
+    z4.union([z4.string(), z4.bigint(), z4.number()]),
+    z4.transform((value) => {
+      if (typeof value === "bigint") {
+        return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+      }
+      if (typeof value === "string") {
+        return value.startsWith("0x") ? value.slice(2) : value;
+      }
+      return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
+    })
+  ).check(z4.refine((x) => AddressValidationZod.safeParse(x).success)),
+  z4.transform((x) => x)
+);
+
+// src/address/as.ts
+import { assertError as assertError2 } from "../../error/neutral/index.mjs";
+import { isObject } from "../../typeof/neutral/index.mjs";
+
+// src/address/is.ts
+var isAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return isHex(value, { bitLength, prefix: isPrefix });
+};
+function isAddressV2(value) {
+  return AddressValidationZod.safeParse(value).success;
+}
+
+// src/address/as.ts
+function asAddress(value, assert) {
+  try {
+    let stringValue;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: false, byteSize: 4 });
+        break;
+      }
+      default: {
+        return isObject(assert) ? assertError2(value, assert, `Unsupported type [${typeof value}]`) : void 0;
+      }
+    }
+    return isAddress(stringValue) ? stringValue : assertError2(value, assert, `Value is not an Address [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError2(void 0, assert, error.message);
+  }
+}
+function asAddressV2(value, assert = false) {
+  return assert ? AddressValidationZod.parse(value) : AddressValidationZod.safeParse(value).data;
+}
+
+// src/address/to.ts
+var toAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return hexFrom(value, {
+    bitLength,
+    prefix: isPrefix,
+    ...config
+  });
+};
+function toAddressV2(value, assert = false) {
+  return assert ? AddressTransformZod.parse(value) : AddressTransformZod.safeParse(value).data;
+}
+
+// src/ethAddress.ts
+import { assertError as assertError3 } from "../../error/neutral/index.mjs";
+import * as z5 from "zod/mini";
+var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
+var EthAddressToStringZod = z5.string().check(z5.regex(EthAddressRegEx));
+var EthAddressToStringSchema = EthAddressToStringZod;
+var EthAddressFromStringZod = z5.pipe(
+  z5.string().check(z5.regex(EthAddressRegEx)),
+  z5.transform((v) => toEthAddress(v))
+);
+var EthAddressFromStringSchema = EthAddressFromStringZod;
+var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var toEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return `0x${hexFrom(value, {
+    bitLength,
+    prefix: isPrefix,
+    ...config
+  })}`;
+};
+var isEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = true } = config;
+  const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
+  return isHex(loweredValue, { bitLength, prefix: isPrefix });
+};
+var EthAddressZod = z5.string().check(
+  z5.regex(EthAddressRegEx, { error: "Invalid address format" }),
+  z5.refine(isEthAddress)
+);
+function asEthAddress(value, assert) {
+  try {
+    let stringValue;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: true, byteSize: 4 });
+        break;
+      }
+      default: {
+        if (value !== void 0) {
+          return assertError3(value, assert, `Unsupported type [${typeof value}]`);
+        }
+      }
+    }
+    return isEthAddress(stringValue) ? stringValue : assertError3(value, assert, `Value is not an EthAddress [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError3(void 0, assert, error.message);
+  }
+}
+
+// src/hash/as.ts
+import { assertError as assertError4 } from "../../error/neutral/index.mjs";
+import { isUndefined } from "../../typeof/neutral/index.mjs";
+
+// src/hash/is.ts
+var isHash = (value, bitLength = 256) => {
+  return isHex(value, { bitLength });
+};
+
+// src/hash/as.ts
+function asHash(value, assert) {
+  switch (typeof value) {
+    case "string": {
+      const stringValue = hexFromHexString(value);
+      return isHash(stringValue) ? stringValue : assertError4(value, assert, `Value is not a Hash [${value}]`);
+    }
+    default: {
+      return isUndefined(assert) ? void 0 : assertError4(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+}
+
+// src/hash/hash.ts
+import * as z6 from "zod/mini";
+var HASH_LENGTH = 32;
+var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
+var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
+var isHashBitLength = (value) => {
+  return typeof value === "number" && HashBitLength.includes(value);
+};
+var HashZod = z6.pipe(
+  z6.string().check(z6.regex(HashRegEx, { error: "Invalid hex format" })),
+  z6.transform((val) => val)
+);
+
+// src/hash/zod.ts
+import * as z7 from "zod/mini";
+var HashToJsonZod = z7.pipe(HashZod, z7.transform((v) => v));
+var JsonToHashZod = z7.pipe(z7.string(), z7.transform((v) => asHash(v, true)));
+
+// src/hexToBigInt.ts
+function hexToBigInt(hex) {
+  return BigInt(hexFromHexString(hex, { prefix: true }));
+}
+
+// src/zod.ts
+import * as z8 from "zod/mini";
+var BigIntToJsonZod = z8.pipe(
+  z8.bigint().check(z8.nonnegative()),
+  z8.transform((x) => toHex(x))
+);
+var JsonToBigIntZod = z8.pipe(
+  z8.string(),
+  z8.transform((x) => hexToBigInt(toHex(x)))
+);
+export {
+  ADDRESS_LENGTH,
+  AddressRegEx,
+  AddressTransformZod,
+  AddressValidationZod,
+  AddressZod,
+  BigIntToJsonZod,
+  ETH_ZERO_ADDRESS,
+  EthAddressFromStringSchema,
+  EthAddressFromStringZod,
+  EthAddressRegEx,
+  EthAddressToStringSchema,
+  EthAddressToStringZod,
+  EthAddressZod,
+  HASH_LENGTH,
+  HashBitLength,
+  HashRegEx,
+  HashToJsonZod,
+  HashZod,
+  HexRegEx,
+  HexRegExMinMax,
+  HexRegExMinMaxMixedCaseWithPrefix,
+  HexRegExWithPrefix,
+  HexZod,
+  JsonToBigIntZod,
+  JsonToHashZod,
+  ZERO_ADDRESS,
+  ZERO_HASH,
+  asAddress,
+  asAddressV2,
+  asEthAddress,
+  asHash,
+  asHex,
+  bitsToNibbles,
+  hexFrom,
+  hexFromArrayBuffer,
+  hexFromBigInt,
+  hexFromHexString,
+  hexFromNumber,
+  hexToBigInt,
+  isAddress,
+  isAddressV2,
+  isEthAddress,
+  isHash,
+  isHashBitLength,
+  isHex,
+  isHexZero,
+  nibblesToBits,
+  toAddress,
+  toAddressV2,
+  toEthAddress,
+  toHex,
+  toHexLegacy
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,3 @@
+export type { EthAddress } from './ethAddress.ts';
+export type { BrandedHex, Hex, HexConfig, } from './hex/index.ts';
+//# sourceMappingURL=model.d.ts.map

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

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

package/dist/_pkg/hex/neutral/zod.d.ts

@@ -0,0 +1,6 @@
+import * as z from 'zod/mini';
+/** Zod schema that transforms a non-negative BigInt into a hex string for JSON serialization. */
+export declare const BigIntToJsonZod: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("./hex/hex.ts").BrandedHex, bigint>>;
+/** Zod schema that parses a JSON hex string into a BigInt. */
+export declare const JsonToBigIntZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>;
+//# sourceMappingURL=zod.d.ts.map

package/dist/_pkg/logger/neutral/ConsoleLogger.d.ts

@@ -0,0 +1,7 @@
+import type { LogLevelValue } from './LevelLogger.ts';
+import { LevelLogger } from './LevelLogger.ts';
+/** A LevelLogger that delegates to the global `console` object. */
+export declare class ConsoleLogger extends LevelLogger {
+    constructor(level?: LogLevelValue);
+}
+//# sourceMappingURL=ConsoleLogger.d.ts.map

package/dist/_pkg/logger/neutral/IdLogger.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from './LevelLogger.ts';
+/**
+ * A logger wrapper that prefixes every log message with a bracketed identifier.
+ * Useful for distinguishing log output from different components or instances.
+ */
+export declare class IdLogger implements Logger {
+    private _id?;
+    private _logger;
+    constructor(logger: Logger, id?: () => string);
+    set id(id: string);
+    debug(...data: unknown[]): void;
+    error(...data: unknown[]): void;
+    info(...data: unknown[]): void;
+    log(...data: unknown[]): void;
+    trace(...data: unknown[]): void;
+    warn(...data: unknown[]): void;
+    private prefix;
+}
+//# sourceMappingURL=IdLogger.d.ts.map

package/dist/_pkg/logger/neutral/LevelLogger.d.ts

@@ -0,0 +1,47 @@
+import type { EnumKey, EnumValue } from '../../enum/neutral/index.ts';
+import { Enum } from '../../enum/neutral/index.ts';
+/** A generic logging function that accepts any number of arguments. */
+export type LogFunction = (...data: unknown[]) => void;
+/**
+ * Interface to handle overlap between Winston &
+ * `console` with as much congruency as possible.
+ */
+export interface Logger {
+    debug: LogFunction;
+    error: LogFunction;
+    info: LogFunction;
+    log: LogFunction;
+    trace: LogFunction;
+    warn: LogFunction;
+}
+/** Numeric log level values, from least verbose (error=1) to most verbose (trace=6). */
+export declare const LogLevel: Enum<{
+    error: 1;
+    warn: 2;
+    info: 3;
+    log: 4;
+    debug: 5;
+    trace: 6;
+}>;
+/** String key for a log level (e.g. 'error', 'warn', 'info'). */
+export type LogLevelKey = EnumKey<typeof LogLevel>;
+/** Alias for LogLevelKey, representing the verbosity setting as a string. */
+export type LogVerbosity = LogLevelKey;
+/** Numeric value of a log level (1 through 6). */
+export type LogLevelValue = EnumValue<typeof LogLevel>;
+/**
+ * A logger that filters messages based on a configured log level.
+ * Methods for levels above the configured threshold return a no-op function.
+ */
+export declare class LevelLogger implements Logger {
+    readonly level: LogLevelValue;
+    readonly logger: Logger;
+    constructor(logger: Logger, level?: LogLevelValue);
+    get debug(): LogFunction;
+    get error(): LogFunction;
+    get info(): LogFunction;
+    get log(): LogFunction;
+    get trace(): LogFunction;
+    get warn(): LogFunction;
+}
+//# sourceMappingURL=LevelLogger.d.ts.map

package/dist/_pkg/logger/neutral/NoOpLogFunction.d.ts

@@ -0,0 +1,3 @@
+/** A log function that silently discards all arguments. */
+export declare const NoOpLogFunction: (..._data: unknown[]) => undefined;
+//# sourceMappingURL=NoOpLogFunction.d.ts.map

package/dist/_pkg/logger/neutral/SilentLogger.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from './LevelLogger.ts';
+/**
+ * A logger that does not log anything.
+ * This is useful when you want to disable logging
+ * like when running unit tests or in silent mode.
+ * It implements the `Logger` interface but all methods
+ * are no-op functions.
+ */
+export declare class SilentLogger implements Logger {
+    readonly debug: (..._data: unknown[]) => undefined;
+    readonly error: (..._data: unknown[]) => undefined;
+    readonly info: (..._data: unknown[]) => undefined;
+    readonly log: (..._data: unknown[]) => undefined;
+    readonly trace: (..._data: unknown[]) => undefined;
+    readonly warn: (..._data: unknown[]) => undefined;
+}
+//# sourceMappingURL=SilentLogger.d.ts.map

package/dist/_pkg/logger/neutral/getFunctionName.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Retrieves the name of the calling function by inspecting the stack trace.
+ * @param depth - The stack frame depth to inspect (default: 2, the caller's caller).
+ * @returns The function name, or '<unknown>' if it cannot be determined.
+ */
+export declare const getFunctionName: (depth?: number) => string;
+//# sourceMappingURL=getFunctionName.d.ts.map

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

@@ -0,0 +1,7 @@
+export * from './ConsoleLogger.ts';
+export * from './getFunctionName.ts';
+export * from './IdLogger.ts';
+export * from './LevelLogger.ts';
+export * from './NoOpLogFunction.ts';
+export * from './SilentLogger.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,126 @@
+// src/LevelLogger.ts
+import { Enum } from "../../enum/neutral/index.mjs";
+
+// src/NoOpLogFunction.ts
+var NoOpLogFunction = (..._data) => void {};
+
+// src/LevelLogger.ts
+var LogLevel = Enum({
+  error: 1,
+  warn: 2,
+  info: 3,
+  log: 4,
+  debug: 5,
+  trace: 6
+});
+var LevelLogger = class {
+  level;
+  logger;
+  constructor(logger, level = LogLevel.warn) {
+    this.level = level;
+    this.logger = logger;
+  }
+  get debug() {
+    return this.level >= LogLevel.debug ? this.logger.debug : NoOpLogFunction;
+  }
+  get error() {
+    return this.level >= LogLevel.error ? this.logger.error : NoOpLogFunction;
+  }
+  get info() {
+    return this.level >= LogLevel.info ? this.logger.info : NoOpLogFunction;
+  }
+  get log() {
+    return this.level >= LogLevel.log ? this.logger.log : NoOpLogFunction;
+  }
+  get trace() {
+    return this.level >= LogLevel.trace ? this.logger.trace : NoOpLogFunction;
+  }
+  get warn() {
+    return this.level >= LogLevel.warn ? this.logger.warn : NoOpLogFunction;
+  }
+};
+
+// src/ConsoleLogger.ts
+var ConsoleLogger = class extends LevelLogger {
+  constructor(level = LogLevel.warn) {
+    super(console, level);
+  }
+};
+
+// src/getFunctionName.ts
+import { handleError } from "../../error/neutral/index.mjs";
+import { isNumber } from "../../typeof/neutral/index.mjs";
+var getFunctionName = (depth = 2) => {
+  try {
+    throw new Error("Getting function name");
+  } catch (ex) {
+    return handleError(ex, (error) => {
+      let newIndex;
+      const stackParts = error.stack?.split("\n")[depth]?.split(" ");
+      const funcName = stackParts?.find((item, index) => {
+        if (!(item.length > 0 && item !== "at")) {
+          return;
+        }
+        if (item === "new") {
+          newIndex = index;
+        }
+        return true;
+      }) ?? "<unknown>";
+      return isNumber(newIndex) ? `${funcName} ${stackParts?.[newIndex + 1]}` : funcName;
+    });
+  }
+};
+
+// src/IdLogger.ts
+var IdLogger = class {
+  _id;
+  _logger;
+  constructor(logger, id) {
+    this._logger = logger;
+    this._id = id;
+  }
+  set id(id) {
+    this._id = () => id;
+  }
+  debug(...data) {
+    this._logger?.debug(this.prefix(), ...data);
+  }
+  error(...data) {
+    this._logger?.error(this.prefix(), ...data);
+  }
+  info(...data) {
+    this._logger?.info(this.prefix(), ...data);
+  }
+  log(...data) {
+    this._logger?.log(this.prefix(), ...data);
+  }
+  trace(...data) {
+    this._logger?.trace(this.prefix(), ...data);
+  }
+  warn(...data) {
+    this._logger?.warn(this.prefix(), ...data);
+  }
+  prefix() {
+    return `[${this._id?.()}]`;
+  }
+};
+
+// src/SilentLogger.ts
+var SilentLogger = class {
+  debug = NoOpLogFunction;
+  error = NoOpLogFunction;
+  info = NoOpLogFunction;
+  log = NoOpLogFunction;
+  trace = NoOpLogFunction;
+  warn = NoOpLogFunction;
+};
+export {
+  ConsoleLogger,
+  IdLogger,
+  LevelLogger,
+  LogLevel,
+  NoOpLogFunction,
+  SilentLogger,
+  getFunctionName
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,8 @@
+import type { TypeCheck } from '../../object-model/neutral/index.ts';
+import type { TypedObject } from '../../typeof/neutral/index.ts';
+/** Factory for creating type-narrowing functions for TypedObject types. */
+export declare const AsObjectFactory: {
+    create: <T extends TypedObject>(typeCheck: TypeCheck<T>) => import("../../object-model/neutral/index.ts").AsTypeFunction<T>;
+    createOptional: <T extends TypedObject>(typeCheck: TypeCheck<T>) => (value: import("../../promise/neutral/index.ts").AnyNonPromise) => T | undefined;
+};
+//# sourceMappingURL=AsObjectFactory.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { AsTypeFunction, TypeCheck } from '../../object-model/neutral/index.ts';
+import type { AnyNonPromise } from '../../promise/neutral/index.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/neutral/EmptyObject.d.ts

@@ -0,0 +1,2 @@
+export type { EmptyObject } from '../../object-model/neutral/index.ts';
+//# sourceMappingURL=EmptyObject.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { TypeCheck, TypeCheckConfig } from '../../object-model/neutral/index.ts';
+import { type ObjectTypeShape, type TypedObject } from '../../typeof/neutral/index.ts';
+/** Configuration options for object type checking. */
+export interface ObjectTypeConfig extends TypeCheckConfig {
+}
+/** Factory class for creating type-guard functions that validate objects against a given shape and optional additional checks. */
+export declare class IsObjectFactory<T extends TypedObject> {
+    /**
+     * 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?: ObjectTypeShape, additionalChecks?: TypeCheck<TypedObject>[]): TypeCheck<T>;
+}
+//# sourceMappingURL=IsObjectFactory.d.ts.map