@xyo-network/sdk 7.0.3 → 7.0.4

package/dist/_pkg/node-memory/neutral/NodeHelper/attachToExistingNode.d.ts

@@ -1,3 +0,0 @@
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import type { NodeInstance } from '../../../node-model/neutral/index.ts';
-export declare const attachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/attachToNewNode.d.ts

@@ -1,4 +0,0 @@
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import type { NodeInstance } from '../../../node-model/neutral/index.ts';
-import type { MemoryNodeParams } from '../MemoryNode.ts';
-export declare const attachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams?: MemoryNodeParams) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/flatAttachToExistingNode.d.ts

@@ -1,5 +0,0 @@
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import type { NodeInstance } from '../../../node-model/neutral/index.ts';
-export declare const flatAttachAllToExistingNode: (source: NodeInstance, destination: NodeInstance) => Promise<NodeInstance>;
-export declare const flatAttachChildToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
-export declare const flatAttachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/flatAttachToNewNode.d.ts

@@ -1,4 +0,0 @@
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import type { NodeInstance } from '../../../node-model/neutral/index.ts';
-import type { MemoryNodeParams } from '../MemoryNode.ts';
-export declare const flatAttachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams: MemoryNodeParams) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/index.d.ts

@@ -1,13 +0,0 @@
-import type { ModuleIdentifier, ModuleInstance } from '../../../module-model/neutral/index.ts';
-import type { NodeInstance } from '../../../node-model/neutral/index.ts';
-import type { MemoryNodeParams } from '../MemoryNode.ts';
-export declare const MemoryNodeHelper: {
-    attachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
-    attachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams?: MemoryNodeParams) => Promise<NodeInstance>;
-    attachedPrivateModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;
-    attachedPublicModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;
-    flatAttachAllToExistingNode: (source: NodeInstance, destination: NodeInstance) => Promise<NodeInstance>;
-    flatAttachChildToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
-    flatAttachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
-    flatAttachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams: MemoryNodeParams) => Promise<NodeInstance>;
-};

package/dist/_pkg/node-memory/neutral/index.d.ts

@@ -1,2 +0,0 @@
-export * from './MemoryNode.ts';
-export * from './NodeHelper/index.ts';

package/dist/_pkg/node-memory/neutral/index.mjs

@@ -1,283 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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;
-};
-
-// src/MemoryNode.ts
-import {
-  assertEx,
-  exists,
-  isAddress,
-  isDefined
-} from "@xylabs/sdk";
-import {
-  creatableModule
-} from "../../module-model/neutral/index.mjs";
-import { AbstractNode } from "../../node-abstract/neutral/index.mjs";
-import { isNodeModule } from "../../node-model/neutral/index.mjs";
-import { Mutex } from "async-mutex";
-var MemoryNode = class extends AbstractNode {
-  registeredModuleMap = {};
-  _attachMutex = new Mutex();
-  _attachedPrivateModules = /* @__PURE__ */ new Set();
-  _attachedPublicModules = /* @__PURE__ */ new Set();
-  async attachHandler(id, external) {
-    await this.startedAsync("warn", true);
-    return assertEx(
-      isAddress(id) ? await this.attachUsingAddress(id, external) : await this.attachUsingName(id, external),
-      () => `Unable to locate module [${id}]`
-    );
-  }
-  async certifyHandler(id) {
-    const child = (await this.publicChildren()).find((child2) => child2.modName === id || child2.address === id);
-    if (child) {
-      return {
-        address: child.address,
-        expiration: Date.now() + 1e3 * 60 * 10
-        /* 10 minutes */
-      };
-    }
-    throw new Error(`Unable to certify child module [${id}]`);
-  }
-  async detachHandler(id) {
-    return isAddress(id) ? await this.detachUsingAddress(id) : await this.detachUsingName(id);
-  }
-  async privateChildren() {
-    return [...await this.attachedPrivateModules(), ...this.params.privateChildren ?? []];
-  }
-  async publicChildren() {
-    return [...await this.attachedPublicModules(), ...this.params.publicChildren ?? []];
-  }
-  async register(mod) {
-    this.started("warn");
-    if (this.registeredModuleMap[mod.address]) {
-      if (this.registeredModuleMap[mod.address] === mod) {
-        this.logger?.warn(`Module already registered at that address[${mod.address}]|${mod.id}|[${mod.config.schema}]`);
-      } else {
-        throw new Error(`Other module already registered at that address[${mod.address}]|${mod.id}|[${mod.config.schema}]`);
-      }
-    }
-    this.registeredModuleMap[mod.address] = mod;
-    const args = { mod, name: mod.modName };
-    await this.emit("moduleRegistered", args);
-  }
-  registeredHandler() {
-    return Promise.resolve(
-      Object.keys(this.registeredModuleMap).map((key) => {
-        return key;
-      })
-    );
-  }
-  registeredModules() {
-    return Object.values(this.registeredModuleMap).map((value) => {
-      return value;
-    }).filter(exists);
-  }
-  async unregister(mod) {
-    try {
-      await this.detach(mod.address);
-    } catch {
-    }
-    delete this.registeredModuleMap[mod.address];
-    const args = { mod, name: mod.modName };
-    await this.emit("moduleUnregistered", args);
-    return this;
-  }
-  async attachUsingAddress(address, external) {
-    return await this._attachMutex.runExclusive(async () => {
-      const existingModule = await this.resolve(address);
-      if (existingModule) {
-        this.logger?.warn(`MemoryNode: Module [${existingModule?.modName ?? existingModule?.address}] already attached at address [${address}]`);
-      }
-      const mod = assertEx(this.registeredModuleMap[address], () => `No Module Registered at address [${address}]`);
-      if (this._attachedPublicModules.has(mod.address)) {
-        this.logger?.warn(`Module [${mod.modName}] already attached at [${address}] (public)`);
-      }
-      if (this._attachedPrivateModules.has(mod.address)) {
-        this.logger?.warn(`Module [${mod.modName}] already attached at [${address}] (private)`);
-      }
-      const notificationList = await this.getModulesToNotifyAbout(mod);
-      mod.upResolver.addResolver?.(this.privateResolver);
-      mod.upResolver.addResolver?.(this.downResolver);
-      mod.upResolver.addResolver?.(this.upResolver);
-      if (external) {
-        this._attachedPublicModules.add(mod.address);
-        this.downResolver.addResolver(mod.downResolver);
-      } else {
-        this._attachedPrivateModules.add(mod.address);
-        this.privateResolver.addResolver(mod.downResolver);
-      }
-      mod.addParent(this);
-      const args = { mod, name: mod.modName };
-      await this.emit("moduleAttached", args);
-      if (isNodeModule(mod) && external) {
-        const attachedListener = async (args2) => await this.emit("moduleAttached", args2);
-        const detachedListener = async (args2) => await this.emit("moduleDetached", args2);
-        mod.on("moduleAttached", attachedListener);
-        mod.on("moduleDetached", detachedListener);
-      }
-      await this.notifyOfExistingModulesAttached(notificationList);
-      return address;
-    });
-  }
-  async detachUsingAddress(address) {
-    const mod = assertEx(this.registeredModuleMap[address], () => `No Module Registered at address [${address}]`);
-    const isAttachedPublic = this._attachedPublicModules.has(mod.address);
-    const isAttachedPrivate = this._attachedPrivateModules.has(mod.address);
-    assertEx(isAttachedPublic || isAttachedPrivate, () => `Module [${mod.modName}] not attached at [${address}]`);
-    mod.upResolver?.removeResolver?.(this.privateResolver);
-    mod.upResolver?.removeResolver?.(this.upResolver);
-    this.downResolver.removeResolver(mod.downResolver);
-    mod.removeParent(this.address);
-    if (isAttachedPublic) {
-      this._attachedPublicModules.delete(mod.address);
-    }
-    if (isAttachedPrivate) {
-      this._attachedPrivateModules.delete(mod.address);
-    }
-    const args = { mod, name: mod.modName };
-    await this.emit("moduleDetached", args);
-    if (isNodeModule(mod)) {
-      const notificationList = await this.getModulesToNotifyAbout(mod);
-      await this.notifyOfExistingModulesDetached(notificationList);
-    }
-    return address;
-  }
-  startHandler() {
-    return super.startHandler();
-  }
-  async attachUsingName(name, external) {
-    const address = this.registeredModuleAddressFromName(name);
-    if (isDefined(address)) {
-      return await this.attachUsingAddress(address, external);
-    }
-  }
-  async detachUsingName(name) {
-    const address = this.registeredModuleAddressFromName(name);
-    if (isDefined(address)) {
-      return await this.detachUsingAddress(address);
-    }
-  }
-  async getModulesToNotifyAbout(node) {
-    const notifiedAddresses = [];
-    const childModules = await node.resolve("*", { direction: "down" });
-    return childModules.map((child) => {
-      if (node.address === child.address) {
-        return;
-      }
-      if (notifiedAddresses.includes(child.address)) {
-        return;
-      }
-      notifiedAddresses.push(child.address);
-      return child;
-    }).filter(exists);
-  }
-  async notifyOfExistingModulesAttached(childModules) {
-    await Promise.all(
-      childModules.map(async (child) => {
-        const args = { mod: child, name: child.modName };
-        await this.emit("moduleAttached", args);
-      })
-    );
-  }
-  async notifyOfExistingModulesDetached(childModules) {
-    await Promise.all(
-      childModules.map(async (child) => {
-        const args = { mod: child, name: child.modName };
-        await this.emit("moduleDetached", args);
-      })
-    );
-  }
-  registeredModuleAddressFromName(name) {
-    return Object.values(this.registeredModuleMap).find((value) => {
-      return value?.modName === name;
-    })?.address;
-  }
-};
-MemoryNode = __decorateClass([
-  creatableModule()
-], MemoryNode);
-
-// src/NodeHelper/index.ts
-import { NodeHelper } from "../../node-abstract/neutral/index.mjs";
-
-// src/NodeHelper/attachToExistingNode.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk";
-import { asNodeInstance } from "../../node-model/neutral/index.mjs";
-
-// src/NodeHelper/flatAttachToExistingNode.ts
-import { assertEx as assertEx2, exists as exists2 } from "@xylabs/sdk";
-import { asAttachableModuleInstance } from "../../module-model/neutral/index.mjs";
-var flatAttachAllToExistingNode = async (source, destination) => {
-  const children = (await source.publicChildren()).map((child) => asAttachableModuleInstance(child)).filter(exists2);
-  await Promise.all(
-    children.map(async (child) => {
-      await destination.register?.(child);
-      await destination.attach(child.address, true);
-    })
-  );
-  return destination;
-};
-var flatAttachChildToExistingNode = async (source, id, destination) => {
-  assertEx2(id !== "*", () => "* is not a single child");
-  const child = assertEx2(await source.resolve(id), () => `Module ${id} not found`);
-  const attachableChild = asAttachableModuleInstance(child, () => `Module ${id} is not attachable`, { required: true });
-  await destination.register?.(attachableChild);
-  await destination.attach(child.address, true);
-  return destination;
-};
-var flatAttachToExistingNode = async (source, id, destination) => {
-  return id === "*" ? await flatAttachAllToExistingNode(source, destination) : flatAttachChildToExistingNode(source, id, destination);
-};
-
-// src/NodeHelper/attachToExistingNode.ts
-var attachToExistingNode = async (source, id, destination) => {
-  const parts = id.split(":");
-  const first = assertEx3(parts.shift(), () => "missing first part");
-  if (parts.length === 0) {
-    return await flatAttachToExistingNode(source, first, destination);
-  } else {
-    const firstModule = await source.resolve(first);
-    const firstNode = asNodeInstance(firstModule, () => "first part is not a node", { required: true });
-    const newNode = await MemoryNode.create({ config: firstNode.config });
-    await destination.register?.(newNode);
-    await destination.attach(newNode.address, true);
-    await attachToExistingNode(firstNode, parts.join(":"), newNode);
-    return destination;
-  }
-};
-
-// src/NodeHelper/attachToNewNode.ts
-import { NodeConfigSchema } from "../../node-model/neutral/index.mjs";
-var DEFAULT_NODE_PARAMS = { config: { schema: NodeConfigSchema }, name: "MemoryNode" };
-var attachToNewNode = async (source, id, destinationParams = DEFAULT_NODE_PARAMS) => {
-  const destination = await MemoryNode.create(destinationParams);
-  return await attachToExistingNode(source, id, destination);
-};
-
-// src/NodeHelper/flatAttachToNewNode.ts
-var flatAttachToNewNode = async (source, id, destinationParams) => {
-  const destination = await MemoryNode.create(destinationParams);
-  return await flatAttachToExistingNode(source, id, destination);
-};
-
-// src/NodeHelper/index.ts
-var MemoryNodeHelper = {
-  ...NodeHelper,
-  attachToExistingNode,
-  attachToNewNode,
-  flatAttachAllToExistingNode,
-  flatAttachChildToExistingNode,
-  flatAttachToExistingNode,
-  flatAttachToNewNode
-};
-export {
-  MemoryNode,
-  MemoryNodeHelper
-};

package/dist/_pkg/node-model/neutral/ChildCertification.d.ts

@@ -1,18 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { type XyoAddress } from '../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const ChildCertificationSchema: 'network.xyo.child.certification' & {
-    readonly __schema: true;
-};
-export type ChildCertificationSchema = typeof ChildCertificationSchema;
-export interface ChildCertificationFields {
-    address: XyoAddress;
-    expiration: number;
-}
-export declare const ChildCertificationZod: z.ZodMiniIntersection<z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<ChildCertificationSchema>;
-}, z.core.$strip>, z.ZodMiniCustom<ChildCertificationFields, ChildCertificationFields>>;
-export type ChildCertification = z.infer<typeof ChildCertificationZod>;
-export declare const isChildCertification: ReturnType<typeof zodIsFactory<ChildCertification>>;
-export declare const asChildCertification: ReturnType<typeof zodAsFactory<ChildCertification>>;
-export declare const toChildCertification: ReturnType<typeof zodToFactory<ChildCertification>>;

package/dist/_pkg/node-model/neutral/Config.d.ts

@@ -1,20 +0,0 @@
-import type { EmptyObject, WithAdditional } from '@xylabs/sdk';
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import type { ModuleConfig } from '../../module-model/neutral/index.ts';
-import { ModuleConfigZod } from '../../module-model/neutral/index.ts';
-import type { Payload, Schema } from '../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const NodeConfigSchema: 'network.xyo.node.config' & {
-    readonly __schema: true;
-};
-export type NodeConfigSchema = typeof NodeConfigSchema;
-export declare const NodeConfigZod: z.ZodMiniObject<Omit<(typeof ModuleConfigZod)['shape'], 'schema'> & {
-    schema: z.ZodMiniLiteral<NodeConfigSchema>;
-}, z.core.$strip>;
-export type NodeConfigBase = z.infer<typeof NodeConfigZod>;
-export declare const isNodeConfig: ReturnType<typeof zodIsFactory<NodeConfigBase>>;
-export declare const asNodeConfig: ReturnType<typeof zodAsFactory<NodeConfigBase>>;
-export declare const toNodeConfig: ReturnType<typeof zodToFactory<NodeConfigBase>>;
-export type NodeConfig<TConfig extends EmptyObject | Payload | void = void, TSchema extends Schema | void = void> = ModuleConfig<WithAdditional<{
-    archivist?: string;
-}, TConfig>, TSchema extends void ? TConfig extends Payload ? TConfig['schema'] : NodeConfigSchema : TSchema>;

package/dist/_pkg/node-model/neutral/EventsModels/ModuleAttached.d.ts

@@ -1,6 +0,0 @@
-import type { EventData } from '@xylabs/sdk';
-import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
-export type ModuleAttachedEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
-export interface ModuleAttachedEventData extends EventData {
-    moduleAttached: ModuleAttachedEventArgs;
-}

package/dist/_pkg/node-model/neutral/EventsModels/ModuleDetached.d.ts

@@ -1,6 +0,0 @@
-import type { EventData } from '@xylabs/sdk';
-import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
-export type ModuleDetachedEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
-export interface ModuleDetachedEventData extends EventData {
-    moduleDetached: ModuleDetachedEventArgs;
-}

package/dist/_pkg/node-model/neutral/EventsModels/ModuleRegistered.d.ts

@@ -1,6 +0,0 @@
-import type { EventData } from '@xylabs/sdk';
-import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
-export type ModuleRegisteredEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
-export interface ModuleRegisteredEventData extends EventData {
-    moduleRegistered: ModuleRegisteredEventArgs;
-}

package/dist/_pkg/node-model/neutral/EventsModels/ModuleUnregistered.d.ts

@@ -1,6 +0,0 @@
-import type { EventData } from '@xylabs/sdk';
-import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
-export type ModuleUnregisteredEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
-export interface ModuleUnregisteredEventData extends EventData {
-    moduleUnregistered: ModuleUnregisteredEventArgs;
-}

package/dist/_pkg/node-model/neutral/EventsModels/index.d.ts

@@ -1,4 +0,0 @@
-export * from './ModuleAttached.ts';
-export * from './ModuleDetached.ts';
-export * from './ModuleRegistered.ts';
-export * from './ModuleUnregistered.ts';

package/dist/_pkg/node-model/neutral/Node.d.ts

@@ -1,7 +0,0 @@
-import type { ModuleEventData, QueryableModule } from '../../module-model/neutral/index.ts';
-import type { ModuleAttachedEventData, ModuleDetachedEventData, ModuleRegisteredEventData, ModuleUnregisteredEventData } from './EventsModels/index.ts';
-import type { NodeParams } from './Params.ts';
-export interface NodeModuleEventData extends ModuleAttachedEventData, ModuleDetachedEventData, ModuleRegisteredEventData, ModuleUnregisteredEventData, ModuleEventData {
-}
-export interface NodeModule<TParams extends NodeParams = NodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends QueryableModule<TParams, TEventData> {
-}

package/dist/_pkg/node-model/neutral/Params.d.ts

@@ -1,6 +0,0 @@
-import type { AnyConfigSchema, ModuleInstanceParams, QueryableModuleParams } from '../../module-model/neutral/index.ts';
-import type { NodeConfig } from './Config.ts';
-export interface NodeParams<TConfig extends AnyConfigSchema<NodeConfig> = AnyConfigSchema<NodeConfig>> extends QueryableModuleParams<TConfig> {
-}
-export interface NodeInstanceParams<TConfig extends AnyConfigSchema<NodeConfig> = AnyConfigSchema<NodeConfig>> extends ModuleInstanceParams<TConfig> {
-}

package/dist/_pkg/node-model/neutral/Queries/Attach.d.ts

@@ -1,18 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const NodeAttachQuerySchema: 'network.xyo.query.node.attach' & {
-    readonly __schema: true;
-};
-export type NodeAttachQuerySchema = typeof NodeAttachQuerySchema;
-export declare const NodeAttachQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<NodeAttachQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'] & {
-    external: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
-}, z.core.$strip>;
-export type NodeAttachQuery = z.infer<typeof NodeAttachQueryZod>;
-export declare const isNodeAttachQuery: ReturnType<typeof zodIsFactory<NodeAttachQuery>>;
-export declare const asNodeAttachQuery: ReturnType<typeof zodAsFactory<NodeAttachQuery>>;
-export declare const toNodeAttachQuery: ReturnType<typeof zodToFactory<NodeAttachQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Attached.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const NodeAttachedQuerySchema: 'network.xyo.query.node.attached' & {
-    readonly __schema: true;
-};
-export type NodeAttachedQuerySchema = typeof NodeAttachedQuerySchema;
-export declare const NodeAttachedQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<NodeAttachedQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type NodeAttachedQuery = z.infer<typeof NodeAttachedQueryZod>;
-export declare const isNodeAttachedQuery: ReturnType<typeof zodIsFactory<NodeAttachedQuery>>;
-export declare const asNodeAttachedQuery: ReturnType<typeof zodAsFactory<NodeAttachedQuery>>;
-export declare const toNodeAttachedQuery: ReturnType<typeof zodToFactory<NodeAttachedQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Certify.d.ts

@@ -1,17 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const NodeCertifyQuerySchema: 'network.xyo.query.node.certify' & {
-    readonly __schema: true;
-};
-export type NodeCertifyQuerySchema = typeof NodeCertifyQuerySchema;
-export declare const NodeCertifyQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<NodeCertifyQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'] & {
-    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
-}, z.core.$strip>;
-export type NodeCertifyQuery = z.infer<typeof NodeCertifyQueryZod>;
-export declare const isNodeCertifyQuery: ReturnType<typeof zodIsFactory<NodeCertifyQuery>>;
-export declare const asNodeCertifyQuery: ReturnType<typeof zodAsFactory<NodeCertifyQuery>>;
-export declare const toNodeCertifyQuery: ReturnType<typeof zodToFactory<NodeCertifyQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Detach.d.ts

@@ -1,17 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const NodeDetachQuerySchema: 'network.xyo.query.node.detach' & {
-    readonly __schema: true;
-};
-export type NodeDetachQuerySchema = typeof NodeDetachQuerySchema;
-export declare const NodeDetachQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<NodeDetachQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'] & {
-    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
-}, z.core.$strip>;
-export type NodeDetachQuery = z.infer<typeof NodeDetachQueryZod>;
-export declare const isNodeDetachQuery: ReturnType<typeof zodIsFactory<NodeDetachQuery>>;
-export declare const asNodeDetachQuery: ReturnType<typeof zodAsFactory<NodeDetachQuery>>;
-export declare const toNodeDetachQuery: ReturnType<typeof zodToFactory<NodeDetachQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Registered.d.ts

@@ -1,14 +0,0 @@
-import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
-import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
-import * as z from 'zod/mini';
-export declare const NodeRegisteredQuerySchema: 'network.xyo.query.node.registered' & {
-    readonly __schema: true;
-};
-export type NodeRegisteredQuerySchema = typeof NodeRegisteredQuerySchema;
-export declare const NodeRegisteredQueryZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<NodeRegisteredQuerySchema>;
-} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
-export type NodeRegisteredQuery = z.infer<typeof NodeRegisteredQueryZod>;
-export declare const isNodeRegisteredQuery: ReturnType<typeof zodIsFactory<NodeRegisteredQuery>>;
-export declare const asNodeRegisteredQuery: ReturnType<typeof zodAsFactory<NodeRegisteredQuery>>;
-export declare const toNodeRegisteredQuery: ReturnType<typeof zodToFactory<NodeRegisteredQuery>>;

package/dist/_pkg/node-model/neutral/Queries/index.d.ts

@@ -1,13 +0,0 @@
-import type { ModuleQueries } from '../../../module-model/neutral/index.ts';
-import type { NodeAttachQuery } from './Attach.ts';
-import type { NodeAttachedQuery } from './Attached.ts';
-import type { NodeCertifyQuery } from './Certify.ts';
-import type { NodeDetachQuery } from './Detach.ts';
-import type { NodeRegisteredQuery } from './Registered.ts';
-export * from './Attach.ts';
-export * from './Attached.ts';
-export * from './Certify.ts';
-export * from './Detach.ts';
-export * from './Registered.ts';
-export type NodeQueries = NodeAttachQuery | NodeCertifyQuery | NodeDetachQuery | NodeAttachedQuery | NodeRegisteredQuery;
-export type NodeModuleQueries = ModuleQueries | NodeQueries;

package/dist/_pkg/node-model/neutral/attachable/AttachableInstance.d.ts

@@ -1,11 +0,0 @@
-import type { TypeCheck } from '@xylabs/sdk';
-import { IsObjectFactory } from '@xylabs/sdk';
-import type { AttachableModuleInstance } from '../../../module-model/neutral/index.ts';
-import type { NodeInstance } from '../instance.ts';
-import type { NodeModule, NodeModuleEventData } from '../Node.ts';
-import type { NodeParams } from '../Params.ts';
-export interface AttachableNodeInstance<TParams extends NodeParams = NodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends NodeModule<TParams, TEventData>, AttachableModuleInstance<TParams, TEventData>, NodeInstance<TParams, TEventData> {
-}
-export type AttachableNodeInstanceTypeCheck<T extends AttachableNodeInstance = AttachableNodeInstance> = TypeCheck<T>;
-export declare class IsAttachableNodeInstanceFactory<T extends AttachableNodeInstance = AttachableNodeInstance> extends IsObjectFactory<T> {
-}

package/dist/_pkg/node-model/neutral/attachable/asAttachableInstance.d.ts

@@ -1 +0,0 @@
-export declare const asAttachableNodeInstance: import("@xylabs/sdk").AsTypeFunction<import("./AttachableInstance.ts").AttachableNodeInstance<import("../Params.ts").NodeParams<import("../../../module-model/neutral/index.ts").AnyConfigSchema<import("../Config.ts").NodeConfig>>, import("../Node.ts").NodeModuleEventData>>;

package/dist/_pkg/node-model/neutral/attachable/index.d.ts

@@ -1,3 +0,0 @@
-export * from './asAttachableInstance.ts';
-export * from './AttachableInstance.ts';
-export * from './isAttachableInstance.ts';

package/dist/_pkg/node-model/neutral/attachable/isAttachableInstance.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk';
-import type { AttachableNodeInstance } from './AttachableInstance.ts';
-export declare const requiredAttachableNodeInstanceFunctions: ObjectTypeShape;
-export declare const isAttachableNodeInstance: TypeCheck<AttachableNodeInstance>;

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

@@ -1,9 +0,0 @@
-export * from './attachable/index.ts';
-export * from './ChildCertification.ts';
-export * from './Config.ts';
-export * from './EventsModels/index.ts';
-export * from './instance.ts';
-export * from './Node.ts';
-export * from './Params.ts';
-export * from './Queries/index.ts';
-export * from './typeChecks.ts';