@xyo-network/sdk-protocol 7.0.12 → 7.0.13

package/dist/_pkg/quant-wallet/neutral/index.mjs

@@ -1,229 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/bip85.ts
-import {
-  computeHmac,
-  getBytes,
-  toUtf8Bytes
-} from "ethers";
-var BIP85_PURPOSE = "83696968'";
-var BIP85_HEX_APP = "128169'";
-var BIP85_HMAC_KEY = "bip-entropy-from-k";
-var BIP85_SEED_LENGTH = 32;
-function bip85DefaultLeafTail(index = 0) {
-  return `${BIP85_PURPOSE}/${BIP85_HEX_APP}/32'/${index}'`;
-}
-function isBip85AbsolutePath(path) {
-  return path.startsWith(`m/${BIP85_PURPOSE}/`);
-}
-function isUnderBip85Purpose(node) {
-  const p = node.path;
-  if (p === null) return false;
-  return p === `m/${BIP85_PURPOSE}` || p.startsWith(`m/${BIP85_PURPOSE}/`);
-}
-function bip85EntropyFromNode(node) {
-  const key = toUtf8Bytes(BIP85_HMAC_KEY);
-  const msg = getBytes(node.privateKey);
-  const hmac = computeHmac("sha512", key, msg);
-  return getBytes(hmac).slice(0, BIP85_SEED_LENGTH);
-}
-
-// src/QuantHDWallet.ts
-import {
-  hexFromArrayBuffer,
-  staticImplements,
-  toUint8Array
-} from "@ariestools/sdk";
-import {
-  isMnemonicInitializationConfig,
-  isPhraseInitializationConfig,
-  isPrivateKeyInitializationConfig
-} from "../../account-model/neutral/index.mjs";
-import { QuantAccount } from "../../quant-account/neutral/index.mjs";
-import { generateMnemonic } from "@scure/bip39";
-import { wordlist as englishWordlist } from "@scure/bip39/wordlists/english.js";
-import {
-  defaultPath,
-  HDNodeWallet,
-  Mnemonic
-} from "ethers";
-var QuantHDWallet = class {
-  algorithm = "ml-dsa-65";
-  _account;
-  _master;
-  _seed;
-  node;
-  neuter = () => {
-    throw new Error("neuter() is not implemented for ml-dsa-65 HD wallets");
-  };
-  constructor(key, node, master, seed, account) {
-    if (key !== QuantHDWallet._protectedConstructorKey) {
-      throw new Error("Do not call this protected constructor");
-    }
-    this.node = node;
-    this._master = master;
-    this._seed = seed;
-    this._account = account;
-  }
-  static async create(opts) {
-    if (isPhraseInitializationConfig(opts)) {
-      return await this.fromPhrase(opts.phrase);
-    }
-    if (isMnemonicInitializationConfig(opts)) {
-      return await this.fromPhrase(opts.mnemonic, opts.path);
-    }
-    if (isPrivateKeyInitializationConfig(opts)) {
-      throw new Error("Invalid initialization config. from privateKey not supported. Use QuantAccount.fromPrivateKey instead.");
-    }
-    throw new Error("Invalid initialization config");
-  }
-  static async createFromNode(node, master, previousHash) {
-    const leafNode = isUnderBip85Purpose(node) ? node : node.derivePath(bip85DefaultLeafTail(0));
-    const seed = bip85EntropyFromNode(leafNode);
-    const account = await QuantAccount.create({
-      privateKey: seed.buffer,
-      previousHash: previousHash === void 0 ? void 0 : toUint8Array(previousHash, 32).buffer
-    });
-    const wallet = new QuantHDWallet(this._protectedConstructorKey, node, master, seed, account);
-    return wallet.verifyUniqueWallet();
-  }
-  static async fromExtendedKey(key) {
-    const node = HDNodeWallet.fromExtendedKey(key);
-    const master = node.depth === 0 ? node : void 0;
-    return await this.createFromNode(node, master);
-  }
-  static async fromMnemonic(mnemonic, path = defaultPath) {
-    const master = HDNodeWallet.fromMnemonic(mnemonic, "m");
-    const node = path === "m" || path === "m/" ? master : master.derivePath(path.startsWith("m/") ? path.slice(2) : path);
-    return await this.createFromNode(node, master);
-  }
-  static async fromPhrase(phrase, path = defaultPath) {
-    return await this.fromMnemonic(Mnemonic.fromPhrase(phrase), path);
-  }
-  static async fromPrivateKey(_key) {
-    return await Promise.reject(new Error("fromPrivateKey is not supported on QuantHDWallet \u2014 use fromSeed, fromPhrase, fromMnemonic, or fromExtendedKey"));
-  }
-  static async fromSeed(seed) {
-    const master = HDNodeWallet.fromSeed(toUint8Array(seed));
-    return await this.createFromNode(master, master);
-  }
-  static generateMnemonic(wordlist = englishWordlist, strength = 256) {
-    return generateMnemonic(wordlist, strength);
-  }
-  static async random() {
-    return await this.fromPhrase(this.generateMnemonic());
-  }
-  get address() {
-    return this._account.address;
-  }
-  get addressBytes() {
-    return this._account.addressBytes;
-  }
-  get chainCode() {
-    return this.node.chainCode;
-  }
-  get depth() {
-    return this.node.depth;
-  }
-  get extendedKey() {
-    return this.node.extendedKey;
-  }
-  get fingerprint() {
-    return this.node.fingerprint;
-  }
-  get index() {
-    return this.node.index;
-  }
-  get mnemonic() {
-    return this.node.mnemonic;
-  }
-  get parentFingerprint() {
-    return this.node.parentFingerprint;
-  }
-  get path() {
-    return this.node.path;
-  }
-  get previousHash() {
-    return this._account.previousHash;
-  }
-  set previousHash(_value) {
-  }
-  get previousHashBytes() {
-    return this._account.previousHashBytes;
-  }
-  set previousHashBytes(_value) {
-  }
-  get privateKey() {
-    return hexFromArrayBuffer(this._seed.buffer, { prefix: false }).toLowerCase();
-  }
-  get publicKey() {
-    const bytes = this._account.publicKey;
-    return hexFromArrayBuffer(bytes, { prefix: false }).toLowerCase();
-  }
-  async derivePath(path) {
-    if (path.startsWith("m/")) {
-      if (isBip85AbsolutePath(path)) {
-        if (this._master === void 0) {
-          throw new Error("Cannot derive BIP-85 absolute path: wallet has no master node (built from extended key)");
-        }
-        const childNode = this._master.derivePath(path.slice(2));
-        return await QuantHDWallet.createFromNode(childNode, this._master);
-      }
-      const parentPath = this.path;
-      if (parentPath !== null && path.startsWith(parentPath)) {
-        const childPath = path.slice(parentPath.length + 1);
-        return await QuantHDWallet.createFromNode(this.node.derivePath(childPath), this._master);
-      }
-      if (this._master !== void 0) {
-        return await QuantHDWallet.createFromNode(this._master.derivePath(path.slice(2)), this._master);
-      }
-      throw new Error(`Invalid absolute path ${path} for wallet with path ${parentPath}`);
-    }
-    return await QuantHDWallet.createFromNode(this.node.derivePath(path), this._master);
-  }
-  async sign(hash, previousHash) {
-    return await this._account.sign(hash, previousHash);
-  }
-  async signJwt(options) {
-    return await this._account.signJwt(options);
-  }
-  async verify(msg, signature) {
-    return await this._account.verify(msg, signature);
-  }
-  verifyUniqueWallet() {
-    const address = this.address;
-    const existing = QuantHDWallet._walletAddressMap[address]?.deref();
-    if (existing === void 0) {
-      QuantHDWallet._walletAddressMap[address] = new WeakRef(this);
-      return this;
-    }
-    return existing;
-  }
-};
-__publicField(QuantHDWallet, "_protectedConstructorKey", /* @__PURE__ */ Symbol());
-__publicField(QuantHDWallet, "_walletAddressMap", {});
-QuantHDWallet = __decorateClass([
-  staticImplements()
-], QuantHDWallet);
-export {
-  BIP85_HEX_APP,
-  BIP85_HMAC_KEY,
-  BIP85_PURPOSE,
-  BIP85_SEED_LENGTH,
-  QuantHDWallet,
-  bip85DefaultLeafTail,
-  bip85EntropyFromNode,
-  isBip85AbsolutePath,
-  isUnderBip85Purpose
-};

package/dist/_pkg/query-payload-plugin/neutral/Payload.d.ts

@@ -1,42 +0,0 @@
-import * as z from 'zod/mini';
-export declare const QueryPayloadZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<"network.xyo.query" & {
-        readonly __schema: true;
-    }>;
-    query: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../payload-model/neutral/index.ts").BrandedSchema<string>, string>>;
-}, z.core.$strip>;
-export type QueryPayload = z.infer<typeof QueryPayloadZod>;
-export declare const isQueryPayload: <T>(value: T) => value is T & {
-    schema: "network.xyo.query" & {
-        readonly __schema: true;
-    };
-    query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
-};
-export declare const asQueryPayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.query" & {
-            readonly __schema: true;
-        };
-        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.query" & {
-            readonly __schema: true;
-        };
-        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
-    };
-};
-export declare const toQueryPayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.query" & {
-            readonly __schema: true;
-        };
-        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.query" & {
-            readonly __schema: true;
-        };
-        query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
-    };
-};

package/dist/_pkg/query-payload-plugin/neutral/Plugin.d.ts

@@ -1,6 +0,0 @@
-export declare const QueryPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
-    schema: "network.xyo.query" & {
-        readonly __schema: true;
-    };
-    query: import("../../payload-model/neutral/index.ts").BrandedSchema<string>;
-}>;

package/dist/_pkg/query-payload-plugin/neutral/Schema.d.ts

@@ -1,4 +0,0 @@
-export declare const QuerySchema: "network.xyo.query" & {
-    readonly __schema: true;
-};
-export type QuerySchema = typeof QuerySchema;

package/dist/_pkg/query-payload-plugin/neutral/Template.d.ts

@@ -1,2 +0,0 @@
-import type { QueryPayload } from './Payload.ts';
-export declare const queryPayloadTemplate: () => QueryPayload;

package/dist/_pkg/query-payload-plugin/neutral/index.d.ts

@@ -1,4 +0,0 @@
-export * from './Payload.ts';
-export { QueryPayloadPlugin as default, QueryPayloadPlugin } from './Plugin.ts';
-export * from './Schema.ts';
-export * from './Template.ts';

package/dist/_pkg/query-payload-plugin/neutral/index.mjs

@@ -1,43 +0,0 @@
-// src/Payload.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@ariestools/sdk";
-import { PayloadZodOfSchema, SchemaZod } from "../../payload-model/neutral/index.mjs";
-import * as z from "zod/mini";
-
-// src/Schema.ts
-import { asSchema } from "../../payload-model/neutral/index.mjs";
-var QuerySchema = asSchema("network.xyo.query", true);
-
-// src/Payload.ts
-var QueryPayloadZod = z.extend(PayloadZodOfSchema(QuerySchema), { query: SchemaZod });
-var isQueryPayload = zodIsFactory(QueryPayloadZod);
-var asQueryPayload = zodAsFactory(QueryPayloadZod, "asQueryPayload");
-var toQueryPayload = zodToFactory(QueryPayloadZod, "toQueryPayload");
-
-// src/Plugin.ts
-import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
-
-// src/Template.ts
-var queryPayloadTemplate = () => ({
-  query: "",
-  schema: QuerySchema
-});
-
-// src/Plugin.ts
-var QueryPayloadPlugin = () => createPayloadPlugin({
-  schema: QuerySchema,
-  template: queryPayloadTemplate
-});
-export {
-  QueryPayloadPlugin,
-  QueryPayloadZod,
-  QuerySchema,
-  asQueryPayload,
-  QueryPayloadPlugin as default,
-  isQueryPayload,
-  queryPayloadTemplate,
-  toQueryPayload
-};

package/dist/_pkg/schema-cache/neutral/Debounce.d.ts

@@ -1,4 +0,0 @@
-export declare class Debounce<TKey = string> {
-    private map;
-    one<T>(key: TKey, closure: () => Promise<T>, timeout?: number): Promise<T>;
-}

package/dist/_pkg/schema-cache/neutral/SchemaCache.d.ts

@@ -1,42 +0,0 @@
-import type { SchemaResolution, SchemaResolutionSource } from '../../domain-payload-plugin/neutral/index.ts';
-import type { FetchedPayload } from '../../huri/neutral/index.ts';
-import type { SchemaPayload } from '../../schema-payload-plugin/neutral/index.ts';
-import type { SchemaNameToValidatorMap } from './SchemaNameToValidatorMap.ts';
-export interface SchemaCacheEntry extends FetchedPayload<SchemaPayload> {
-    /** Provenance of the schema definition when resolved via the domain schema authority */
-    source?: SchemaResolutionSource;
-}
-export declare class SchemaCache<T extends SchemaNameToValidatorMap = SchemaNameToValidatorMap> {
-    /**
-     * Object representing `null` since LRU Cache types
-     * only allow for types that derive from object
-     */
-    protected static readonly NULL: SchemaCacheEntry;
-    private static _instance?;
-    private _cache;
-    private _resolutions;
-    private _validators;
-    private getDebounce;
-    onSchemaCached?: (name: string, entry: SchemaCacheEntry) => void;
-    proxy?: string;
-    private constructor();
-    static get instance(): SchemaCache<SchemaNameToValidatorMap>;
-    private cacheSchemaIfValid;
-    private cacheSchemas;
-    private fetchSchema;
-    /**
-     * A map of cached schema (by name) to payload validators for the schema. A schema
-     * must be cached via `get('schema.name')` before it's validator can be used as
-     * they are compiled dynamically at runtime upon retrieval.
-     */
-    get validators(): T;
-    get(schema?: string): Promise<SchemaCacheEntry | undefined | null>;
-    /**
-     * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
-     * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
-     * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
-     * their validators compiled, exactly as with get(). 'unreachable' results are
-     * retryable: they are not cached as permanent negatives.
-     */
-    resolve(schema?: string): Promise<SchemaResolution | undefined>;
-}

package/dist/_pkg/schema-cache/neutral/SchemaNameToValidatorMap.d.ts

@@ -1,11 +0,0 @@
-import type { Payload } from '../../payload-model/neutral/index.ts';
-/**
- * Used in conjunction with schema validation to support compile time type assertion
- * for known schema types.
- */
-export type NarrowPayload<T extends Payload = Payload> = ((x: Payload) => x is T) | undefined;
-/**
- * Used to map known schemas (byt their string name) to the validators which assert their types
- */
-export interface SchemaNameToValidatorMap {
-}

package/dist/_pkg/schema-cache/neutral/TtlLruCache.d.ts

@@ -1,12 +0,0 @@
-export interface TtlLruCacheOpts {
-    max: number;
-    ttl: number;
-}
-export declare class TtlLruCache<K, V> {
-    private readonly map;
-    private readonly max;
-    private readonly ttl;
-    constructor(opts: TtlLruCacheOpts);
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-}

package/dist/_pkg/schema-cache/neutral/index.d.ts

@@ -1,4 +0,0 @@
-export * from './Debounce.ts';
-export * from './SchemaCache.ts';
-export * from './SchemaNameToValidatorMap.ts';
-export * from './TtlLruCache.ts';

package/dist/_pkg/schema-cache/neutral/index.mjs

@@ -1,177 +0,0 @@
-// src/Debounce.ts
-import { delay, isDefined } from "@ariestools/sdk";
-var Debounce = class {
-  map = /* @__PURE__ */ new Map();
-  async one(key, closure, timeout = 1e4) {
-    const startTime = Date.now();
-    while (isDefined(this.map.get(key))) {
-      await delay(100);
-      if (Date.now() - startTime > timeout) {
-        throw new Error(`Debounce timed out [${String(key)}]`);
-      }
-    }
-    try {
-      this.map.set(key, 1);
-      return await closure();
-    } finally {
-      this.map.delete(key);
-    }
-  }
-};
-
-// src/SchemaCache.ts
-import {
-  FetchClientError,
-  handleError,
-  isDefined as isDefined2,
-  isString
-} from "@ariestools/sdk";
-import { DomainPayloadWrapper, DomainSchemaResolver } from "../../domain-payload-plugin/neutral/index.mjs";
-import { SchemaSchema } from "../../schema-payload-plugin/neutral/index.mjs";
-import { Ajv } from "ajv";
-
-// src/TtlLruCache.ts
-var TtlLruCache = class {
-  map = /* @__PURE__ */ new Map();
-  max;
-  ttl;
-  constructor(opts) {
-    this.max = opts.max;
-    this.ttl = opts.ttl;
-  }
-  get(key) {
-    const entry = this.map.get(key);
-    if (entry === void 0) return void 0;
-    if (entry.expires <= Date.now()) {
-      this.map.delete(key);
-      return void 0;
-    }
-    this.map.delete(key);
-    this.map.set(key, entry);
-    return entry.value;
-  }
-  set(key, value) {
-    if (this.map.has(key)) this.map.delete(key);
-    this.map.set(key, { value, expires: Date.now() + this.ttl });
-    if (this.map.size > this.max) {
-      const oldest = this.map.keys().next().value;
-      if (oldest !== void 0) this.map.delete(oldest);
-    }
-  }
-};
-
-// src/SchemaCache.ts
-var getSchemaNameFromSchema = (schema) => {
-  if (isString(schema.$id)) {
-    return schema.$id;
-  }
-};
-var SchemaCache = class _SchemaCache {
-  /**
-   * Object representing `null` since LRU Cache types
-   * only allow for types that derive from object
-   */
-  static NULL = { payload: { definition: {}, schema: SchemaSchema } };
-  static _instance;
-  _cache = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
-  _resolutions = new TtlLruCache({ max: 500, ttl: 1e3 * 60 * 5 });
-  _validators = {};
-  // prevents double discovery
-  getDebounce = new Debounce();
-  onSchemaCached;
-  proxy;
-  constructor(proxy) {
-    this.proxy = proxy;
-  }
-  static get instance() {
-    this._instance ??= new _SchemaCache();
-    return this._instance;
-  }
-  cacheSchemaIfValid(entry) {
-    if (!isDefined2(entry?.payload?.definition)) {
-      return;
-    }
-    const ajv = new Ajv({ strict: false });
-    const validator = ajv.compile(entry.payload.definition);
-    const schemaName = getSchemaNameFromSchema(entry.payload.definition);
-    if (isString(schemaName)) {
-      this._cache.set(schemaName, entry);
-      const key = schemaName;
-      this._validators[key] = validator;
-      this.onSchemaCached?.(schemaName, entry);
-    }
-  }
-  cacheSchemas(aliasEntries) {
-    for (const entry of aliasEntries?.filter((entry2) => entry2.payload.schema === SchemaSchema) ?? []) {
-      this.cacheSchemaIfValid(entry);
-    }
-  }
-  async fetchSchema(schema) {
-    try {
-      const resolution = await this.resolve(schema);
-      if (resolution?.status === "resolved") {
-        return;
-      }
-      const domain = await DomainPayloadWrapper.discover(schema, this.proxy);
-      await domain?.fetch();
-      this.cacheSchemas(domain?.aliases);
-      if (this._cache.get(schema) === void 0 && resolution?.status !== "unreachable") {
-        this._cache.set(schema, _SchemaCache.NULL);
-      }
-    } catch (error) {
-      if (error instanceof FetchClientError) {
-        console.log(`Fetch Url: ${error.config.url}`);
-      }
-      handleError(error, (error2) => {
-        console.error(`fetchSchema threw: ${error2.message}`);
-      });
-    }
-  }
-  /**
-   * A map of cached schema (by name) to payload validators for the schema. A schema
-   * must be cached via `get('schema.name')` before it's validator can be used as
-   * they are compiled dynamically at runtime upon retrieval.
-   */
-  get validators() {
-    return this._validators;
-  }
-  async get(schema) {
-    if (isString(schema)) {
-      await this.getDebounce.one(schema, async () => {
-        if (this._cache.get(schema) === void 0) {
-          await this.fetchSchema(schema);
-        }
-      });
-      const value = this._cache.get(schema);
-      return value === _SchemaCache.NULL ? null : value;
-    }
-    return void 0;
-  }
-  /**
-   * Resolve a schema name to its domain-published authoritative definition (SPEC.md in
-   * @xyo-network/domain-payload-plugin), with provenance and a richer status than get():
-   * 'resolved' | 'not-published' | 'unreachable'. Resolved definitions are cached and
-   * their validators compiled, exactly as with get(). 'unreachable' results are
-   * retryable: they are not cached as permanent negatives.
-   */
-  async resolve(schema) {
-    if (!isString(schema)) return void 0;
-    await this.getDebounce.one(`resolve:${schema}`, async () => {
-      const existing = this._resolutions.get(schema);
-      if (existing === void 0 || existing.status === "unreachable") {
-        const resolver = new DomainSchemaResolver();
-        const resolution = await resolver.resolve(schema, { proxy: this.proxy });
-        this._resolutions.set(schema, resolution);
-        if (resolution.status === "resolved" && isDefined2(resolution.payload)) {
-          this.cacheSchemaIfValid({ payload: resolution.payload, source: resolution.source });
-        }
-      }
-    });
-    return this._resolutions.get(schema);
-  }
-};
-export {
-  Debounce,
-  SchemaCache,
-  TtlLruCache
-};

package/dist/_pkg/schema-name-validator/neutral/SchemaNameValidator.d.ts

@@ -1,42 +0,0 @@
-/**
- * Validates a XYO schema name's structure
- */
-export declare class SchemaNameValidator {
-    private _parts?;
-    private _rootDomain?;
-    private _schema?;
-    constructor(schema?: string);
-    /**
-     * Checks whether the schema is all lowercase
-     *
-     * @returns boolean
-     */
-    get isLowercase(): boolean;
-    /**
-     * Levels in the schema
-     *
-     * @returns number
-     */
-    get levels(): number | undefined;
-    /**
-     * The schema converted into a string array split on '.'
-     *
-     * @returns string[]
-     */
-    get parts(): string[] | undefined;
-    /**
-     * The rootDomain is the first two levels of the schema, in reverse order
-     * This can be used to determine who 'owns' that schema, based on domain
-     * registration
-     *
-     * @returns string
-     */
-    get rootDomain(): string | undefined;
-    get schema(): string | undefined;
-    set schema(schema: string | undefined);
-    /**
-     * Run all static validations
-     * @returns Error[]
-     */
-    all(): Error[];
-}

package/dist/_pkg/schema-name-validator/neutral/index.d.ts

@@ -1 +0,0 @@
-export * from './SchemaNameValidator.ts';