@ariestools/sdk 7.0.6 → 7.0.8

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

@@ -1,380 +0,0 @@
-// 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
-};

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

@@ -1,2 +0,0 @@
-export type { EthAddress } from './ethAddress.ts';
-export type { BrandedHex, Hex, HexConfig, } from './hex/index.ts';

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

@@ -1,5 +0,0 @@
-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>>;

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

@@ -1,6 +0,0 @@
-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);
-}

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

@@ -1,18 +0,0 @@
-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;
-}

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

@@ -1,46 +0,0 @@
-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;
-}

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

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

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

@@ -1,16 +0,0 @@
-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;
-}

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

@@ -1,6 +0,0 @@
-/**
- * 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;

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

@@ -1,6 +0,0 @@
-export * from './ConsoleLogger.ts';
-export * from './getFunctionName.ts';
-export * from './IdLogger.ts';
-export * from './LevelLogger.ts';
-export * from './NoOpLogFunction.ts';
-export * from './SilentLogger.ts';

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

@@ -1,125 +0,0 @@
-// 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
-};

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

@@ -1,7 +0,0 @@
-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;
-};

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

@@ -1,10 +0,0 @@
-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;
-};

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

@@ -1 +0,0 @@
-export type { EmptyObject } from '../../object-model/neutral/index.ts';

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

@@ -1,15 +0,0 @@
-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>;
-}