@xyo-network/sdk 7.0.3 → 7.0.4

package/dist/_pkg/sdk-protocol/_pkg/manifest-model/neutral/index.d.ts

@@ -1,2 +0,0 @@
-export * from './Manifest.ts';
-export * from './Payload.ts';

package/dist/_pkg/sdk-protocol/_pkg/manifest-model/neutral/index.mjs

@@ -1,192 +0,0 @@
-// src/Manifest.zod.ts
-import {
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
-} from "@xylabs/sdk";
-import * as z from "zod/mini";
-var isString = (value) => typeof value === "string";
-var stringZod = z.string();
-var optionalStringZod = z.optional(stringZod);
-var optionalStringArrayZod = z.optional(z.array(stringZod));
-var optionalStringRecordZod = z.optional(z.record(stringZod, optionalStringZod));
-var xyoAddressZod = z.custom(isString);
-var nullableStringZod = z.nullable(stringZod);
-var optionalAddressChildrenRecordZod = z.optional(z.record(xyoAddressZod, nullableStringZod));
-var schemaZod = z.custom(isString);
-var asBrandedZod = (schema) => {
-  return z.pipe(schema, z.transform((value) => value));
-};
-var ModuleAliasZod = asBrandedZod(z.string());
-var ManifestZod = z.object({
-  $schema: z.optional(z.string()),
-  description: z.optional(z.string())
-});
-var isManifest = zodIsFactory(ManifestZod);
-var asManifest = zodAsFactory(ManifestZod, "asManifest");
-var toManifest = zodToFactory(ManifestZod, "toManifest");
-var ConfigManifestZod = z.looseObject({
-  accountPath: optionalStringZod,
-  features: optionalStringArrayZod,
-  labels: optionalStringRecordZod,
-  language: optionalStringZod,
-  name: stringZod,
-  os: optionalStringZod,
-  schema: schemaZod
-});
-var isConfigManifest = zodIsFactory(ConfigManifestZod);
-var asConfigManifest = zodAsFactory(ConfigManifestZod, "asConfigManifest");
-var toConfigManifest = zodToFactory(ConfigManifestZod, "toConfigManifest");
-var ModuleManifestStatusZod = z.object({
-  address: xyoAddressZod,
-  children: optionalAddressChildrenRecordZod
-});
-var ModuleManifestZod = z.extend(ManifestZod, {
-  config: ConfigManifestZod,
-  lazyStart: z.optional(z.boolean()),
-  status: z.optional(ModuleManifestStatusZod)
-});
-var isModuleManifest = zodIsFactory(ModuleManifestZod);
-var asModuleManifest = zodAsFactory(ModuleManifestZod, "asModuleManifest");
-var toModuleManifest = zodToFactory(ModuleManifestZod, "toModuleManifest");
-var ModuleManifestReferenceZod = z.union([ModuleManifestZod, ModuleAliasZod]);
-var moduleManifestReferenceArrayZod = z.optional(z.array(ModuleManifestReferenceZod));
-var nodeModulesZod = z.optional(z.object({ private: moduleManifestReferenceArrayZod, public: moduleManifestReferenceArrayZod }));
-var NodeManifestZod = z.extend(ModuleManifestZod, { modules: nodeModulesZod });
-var isNodeManifest = zodIsFactory(NodeManifestZod);
-var asNodeManifest = zodAsFactory(NodeManifestZod, "asNodeManifest");
-var toNodeManifest = zodToFactory(NodeManifestZod, "toNodeManifest");
-var PackageManifestZod = z.extend(ManifestZod, {
-  modules: z.optional(z.record(ModuleAliasZod, ModuleManifestZod)),
-  nodes: z.array(NodeManifestZod)
-});
-var isPackageManifest = zodIsFactory(PackageManifestZod);
-var asPackageManifest = zodAsFactory(PackageManifestZod, "asPackageManifest");
-var toPackageManifest = zodToFactory(PackageManifestZod, "toPackageManifest");
-var AuthoredModuleManifestBaseZod = z.strictObject({
-  config: ConfigManifestZod,
-  description: z.optional(z.string())
-});
-var AuthoredModuleManifestZod = AuthoredModuleManifestBaseZod;
-var isAuthoredModuleManifest = zodIsFactory(AuthoredModuleManifestZod);
-var asAuthoredModuleManifest = zodAsFactory(AuthoredModuleManifestZod, "asAuthoredModuleManifest");
-var toAuthoredModuleManifest = zodToFactory(AuthoredModuleManifestZod, "toAuthoredModuleManifest");
-var authoredModuleManifestArrayZod = z.optional(z.array(AuthoredModuleManifestBaseZod));
-var authoredNodeModulesZod = z.optional(z.strictObject({
-  private: authoredModuleManifestArrayZod,
-  public: authoredModuleManifestArrayZod
-}));
-var AuthoredNodeManifestZod = z.extend(AuthoredModuleManifestBaseZod, {
-  modules: authoredNodeModulesZod,
-  name: optionalStringZod
-});
-var isAuthoredNodeManifest = zodIsFactory(AuthoredNodeManifestZod);
-var asAuthoredNodeManifest = zodAsFactory(AuthoredNodeManifestZod, "asAuthoredNodeManifest");
-var toAuthoredNodeManifest = zodToFactory(AuthoredNodeManifestZod, "toAuthoredNodeManifest");
-var AuthoredPackageManifestZod = z.strictObject({
-  $schema: z.optional(z.string()),
-  description: z.optional(z.string()),
-  nodes: z.array(AuthoredNodeManifestZod),
-  schema: z.literal("network.xyo.manifest")
-});
-var isAuthoredPackageManifest = zodIsFactory(AuthoredPackageManifestZod);
-var asAuthoredPackageManifest = zodAsFactory(AuthoredPackageManifestZod, "asAuthoredPackageManifest");
-var toAuthoredPackageManifest = zodToFactory(AuthoredPackageManifestZod, "toAuthoredPackageManifest");
-var ExternalModuleRequestZod = z.strictObject({ name: z.string() });
-var ExternalManifestZod = z.strictObject({ modules: z.array(ExternalModuleRequestZod) });
-var AuthoredDappPackageManifestZod = z.strictObject({
-  $schema: z.optional(z.string()),
-  description: z.optional(z.string()),
-  external: z.optional(ExternalManifestZod),
-  nodes: z.array(AuthoredNodeManifestZod),
-  schema: z.literal("network.xyo.manifest.package.dapp")
-});
-var isAuthoredDappPackageManifest = zodIsFactory(AuthoredDappPackageManifestZod);
-var asAuthoredDappPackageManifest = zodAsFactory(AuthoredDappPackageManifestZod, "asAuthoredDappPackageManifest");
-var toAuthoredDappPackageManifest = zodToFactory(AuthoredDappPackageManifestZod, "toAuthoredDappPackageManifest");
-
-// src/Payload.zod.ts
-import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory as zodToFactory2
-} from "@xylabs/sdk";
-import { asSchema } from "../../payload-model/neutral/index.mjs";
-import * as z2 from "zod/mini";
-var DappPackageManifestPayloadSchema = asSchema("network.xyo.manifest.package.dapp", true);
-var PackageManifestPayloadSchema = asSchema("network.xyo.manifest.package", true);
-var ModuleManifestPayloadSchema = asSchema("network.xyo.module.manifest", true);
-var NodeManifestPayloadSchema = asSchema("network.xyo.node.manifest", true);
-var NodeManifestPayloadZod = z2.extend(NodeManifestZod, { schema: z2.literal(NodeManifestPayloadSchema) });
-var isNodeManifestPayload = zodIsFactory2(NodeManifestPayloadZod);
-var asNodeManifestPayload = zodAsFactory2(NodeManifestPayloadZod, "asNodeManifestPayload");
-var toNodeManifestPayload = zodToFactory2(NodeManifestPayloadZod, "toNodeManifestPayload");
-var ModuleManifestPayloadZod = z2.extend(ModuleManifestZod, { schema: z2.union([z2.literal(ModuleManifestPayloadSchema), z2.literal(NodeManifestPayloadSchema)]) });
-var isModuleManifestPayload = zodIsFactory2(ModuleManifestPayloadZod);
-var asModuleManifestPayload = zodAsFactory2(ModuleManifestPayloadZod, "asModuleManifestPayload");
-var toModuleManifestPayload = zodToFactory2(ModuleManifestPayloadZod, "toModuleManifestPayload");
-var PackageManifestPayloadZod = z2.extend(PackageManifestZod, { schema: z2.literal(PackageManifestPayloadSchema) });
-var isPackageManifestPayload = zodIsFactory2(PackageManifestPayloadZod);
-var asPackageManifestPayload = zodAsFactory2(PackageManifestPayloadZod, "asPackageManifestPayload");
-var toPackageManifestPayload = zodToFactory2(PackageManifestPayloadZod, "toPackageManifestPayload");
-export {
-  AuthoredDappPackageManifestZod,
-  AuthoredModuleManifestZod,
-  AuthoredNodeManifestZod,
-  AuthoredPackageManifestZod,
-  ConfigManifestZod,
-  DappPackageManifestPayloadSchema,
-  ExternalManifestZod,
-  ExternalModuleRequestZod,
-  ManifestZod,
-  ModuleAliasZod,
-  ModuleAliasZod as ModuleAliasZodSchema,
-  ModuleManifestPayloadSchema,
-  ModuleManifestPayloadZod,
-  ModuleManifestReferenceZod,
-  ModuleManifestStatusZod,
-  ModuleManifestZod,
-  NodeManifestPayloadSchema,
-  NodeManifestPayloadZod,
-  NodeManifestZod,
-  PackageManifestPayloadSchema,
-  PackageManifestPayloadZod,
-  PackageManifestZod,
-  asAuthoredDappPackageManifest,
-  asAuthoredModuleManifest,
-  asAuthoredNodeManifest,
-  asAuthoredPackageManifest,
-  asBrandedZod,
-  asConfigManifest,
-  asManifest,
-  asModuleManifest,
-  asModuleManifestPayload,
-  asNodeManifest,
-  asNodeManifestPayload,
-  asPackageManifest,
-  asPackageManifestPayload,
-  isAuthoredDappPackageManifest,
-  isAuthoredModuleManifest,
-  isAuthoredNodeManifest,
-  isAuthoredPackageManifest,
-  isConfigManifest,
-  isManifest,
-  isModuleManifest,
-  isModuleManifestPayload,
-  isNodeManifest,
-  isNodeManifestPayload,
-  isPackageManifest,
-  isPackageManifestPayload,
-  toAuthoredDappPackageManifest,
-  toAuthoredModuleManifest,
-  toAuthoredNodeManifest,
-  toAuthoredPackageManifest,
-  toConfigManifest,
-  toManifest,
-  toModuleManifest,
-  toModuleManifestPayload,
-  toNodeManifest,
-  toNodeManifestPayload,
-  toPackageManifest,
-  toPackageManifestPayload
-};

package/dist/_pkg/sdk-protocol/_pkg/metamask-connector/browser/MetaMaskConnector.d.ts

@@ -1,37 +0,0 @@
-import type { MetaMaskInpageProvider } from '@metamask/providers';
-import type { Listener } from 'ethers';
-import { BrowserProvider } from 'ethers';
-declare global {
-    var ethereum: MetaMaskInpageProvider | undefined;
-}
-export declare class MetaMaskConnector {
-    private account;
-    private ethereum;
-    private listeners;
-    private provider;
-    private providerListeners;
-    constructor(provider?: BrowserProvider);
-    get chainId(): string | null | undefined;
-    get currentAccount(): string | null | undefined;
-    connectWallet(): Promise<void>;
-    isMetaMaskInstalled(): true | undefined;
-    isWalletIsConnected(): boolean;
-    /**
-     * EIP-1193 Event Listeners
-     *
-     * .on in Web3Provider does not understand EIP-1193 events
-     * see - https://github.com/ethers-io/ethers.js/discussions/1560#discussioncomment-730893
-     */
-    providerOnAccountsChanged(listener: Listener): void;
-    providerOnChainChanged(listener: Listener): void;
-    providerOnConnect(listener: Listener): void;
-    providerOnDisconnect(listener: Listener): void;
-    providerRemoveListener(event: string, listener: Listener): void;
-    providerRemoveListeners(): void;
-    requestAccounts(): Promise<string[] | null>;
-    signMessage(message: string): Promise<string | undefined>;
-    /** Web3Provider Listeners - https://docs.ethers.org/v5/api/providers/provider/#Provider--events */
-    web3ProviderOn(event: string, listener: Listener): void;
-    web3ProviderRemoveListener(event: string, listener: Listener): void;
-    web3ProviderRemoveListeners(): void;
-}

package/dist/_pkg/sdk-protocol/_pkg/metamask-connector/browser/index.d.ts

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

package/dist/_pkg/sdk-protocol/_pkg/metamask-connector/browser/index.mjs

@@ -1,113 +0,0 @@
-// src/MetaMaskConnector.ts
-import { forget, isString } from "@xylabs/sdk";
-import { BrowserProvider } from "ethers";
-var MetaMaskConnector = class {
-  account = "";
-  ethereum = globalThis.ethereum;
-  listeners = [];
-  provider;
-  providerListeners = [];
-  constructor(provider) {
-    if (provider) {
-      this.provider = provider;
-    } else if (this.ethereum) {
-      this.provider = new BrowserProvider(this.ethereum);
-    }
-  }
-  get chainId() {
-    return this.ethereum?.networkVersion;
-  }
-  get currentAccount() {
-    return this.ethereum?.selectedAddress;
-  }
-  async connectWallet() {
-    if (!this.provider) {
-      logProviderMissing();
-      return;
-    }
-    const accounts = await this.provider.send("eth_requestAccounts", []);
-    if (accounts.length > 0) {
-      this.account = accounts[0];
-      console.log("Connected:", this.account);
-    } else {
-      console.log("No authorized account found.");
-    }
-  }
-  isMetaMaskInstalled() {
-    return this.ethereum?.isMetaMask;
-  }
-  isWalletIsConnected() {
-    if (isString(this.currentAccount)) {
-      console.log("Found an authorized account:", this.ethereum?.selectedAddress);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * EIP-1193 Event Listeners
-   *
-   * .on in Web3Provider does not understand EIP-1193 events
-   * see - https://github.com/ethers-io/ethers.js/discussions/1560#discussioncomment-730893
-   */
-  providerOnAccountsChanged(listener) {
-    this.ethereum?.on("accountsChanged", listener);
-    this.providerListeners.push(["accountsChanged", listener]);
-  }
-  providerOnChainChanged(listener) {
-    this.ethereum?.on("chainChanged", listener);
-    this.providerListeners.push(["chainChanged", listener]);
-  }
-  providerOnConnect(listener) {
-    this.ethereum?.on("connect", listener);
-    this.providerListeners.push(["connect", listener]);
-  }
-  providerOnDisconnect(listener) {
-    this.ethereum?.on("disconnect", listener);
-    this.providerListeners.push(["disconnect", listener]);
-  }
-  providerRemoveListener(event, listener) {
-    this.providerListeners = this.providerListeners.filter(([, savedListener]) => listener !== savedListener);
-  }
-  providerRemoveListeners() {
-  }
-  async requestAccounts() {
-    if (!this.provider) {
-      logProviderMissing();
-      return null;
-    }
-    return await this.provider.send("eth_requestAccounts", []);
-  }
-  async signMessage(message) {
-    if (!this.provider) {
-      logProviderMissing();
-      return;
-    }
-    const signer = await this.provider.getSigner();
-    await signer.getAddress();
-    return await signer.signMessage(message);
-  }
-  /** Web3Provider Listeners - https://docs.ethers.org/v5/api/providers/provider/#Provider--events */
-  web3ProviderOn(event, listener) {
-    if (this.provider) {
-      forget(this.provider.on(event, listener));
-    }
-    this.listeners.push(listener);
-  }
-  web3ProviderRemoveListener(event, listener) {
-    if (this.provider) {
-      forget(this.provider.removeListener(event, listener));
-    }
-    this.listeners = this.listeners.filter((savedListener) => listener !== savedListener);
-  }
-  web3ProviderRemoveListeners() {
-    if (this.provider) {
-      forget(this.provider.removeAllListeners());
-    }
-  }
-};
-function logProviderMissing() {
-  console.warn("Cannot call this method because there is no web3 provider connected.  Please confirm that metamask is installed");
-}
-export {
-  MetaMaskConnector
-};

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkNodePayload.d.ts

@@ -1,78 +0,0 @@
-import * as z from 'zod/mini';
-export declare const NetworkNodeTypeZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
-export type NetworkNodeType = z.infer<typeof NetworkNodeTypeZod>;
-export declare const NetworkNodeSchema: "network.xyo.network.node" & {
-    readonly __schema: true;
-};
-export type NetworkNodeSchema = typeof NetworkNodeSchema;
-export declare const NetworkNodePayloadZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<"network.xyo.network.node" & {
-        readonly __schema: true;
-    }>;
-    docs: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    slug: z.ZodMiniString<string>;
-    type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
-    uri: z.ZodMiniString<string>;
-    web: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strip>;
-export type NetworkNodePayload = z.infer<typeof NetworkNodePayloadZod>;
-export declare const isNetworkNodePayload: <T>(value: T) => value is T & {
-    schema: "network.xyo.network.node" & {
-        readonly __schema: true;
-    };
-    slug: string;
-    type: "archivist" | "diviner" | "bridge" | "sentinel";
-    uri: string;
-    docs?: string | undefined;
-    name?: string | undefined;
-    web?: string | undefined;
-};
-export declare const asNetworkNodePayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    };
-};
-export declare const toNetworkNodePayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    };
-};

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkNodePayloadWrapper.d.ts

@@ -1,16 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
-import type { NetworkNodePayload } from './NetworkNodePayload.ts';
-export declare class NetworkNodePayloadWrapper<T extends NetworkNodePayload = NetworkNodePayload> extends PayloadWrapper<T> {
-    static known(hash: Hash): Promise<NetworkNodePayloadWrapper<{
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }>>;
-}

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkPayload.d.ts

@@ -1,118 +0,0 @@
-import * as z from 'zod/mini';
-export declare const NetworkSchema: "network.xyo.network" & {
-    readonly __schema: true;
-};
-export type NetworkSchema = typeof NetworkSchema;
-export declare const NetworkPayloadZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<"network.xyo.network" & {
-        readonly __schema: true;
-    }>;
-    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    nodes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-        schema: z.ZodMiniLiteral<"network.xyo.network.node" & {
-            readonly __schema: true;
-        }>;
-        docs: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        slug: z.ZodMiniString<string>;
-        type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
-        uri: z.ZodMiniString<string>;
-        web: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    }, z.core.$strip>>>;
-    slug: z.ZodMiniString<string>;
-}, z.core.$strip>;
-export type NetworkPayload = z.infer<typeof NetworkPayloadZod>;
-export declare const isNetworkPayload: <T>(value: T) => value is T & {
-    schema: "network.xyo.network" & {
-        readonly __schema: true;
-    };
-    slug: string;
-    name?: string | undefined;
-    nodes?: {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }[] | undefined;
-};
-export declare const asNetworkPayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.network" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        name?: string | undefined;
-        nodes?: {
-            schema: "network.xyo.network.node" & {
-                readonly __schema: true;
-            };
-            slug: string;
-            type: "archivist" | "diviner" | "bridge" | "sentinel";
-            uri: string;
-            docs?: string | undefined;
-            name?: string | undefined;
-            web?: string | undefined;
-        }[] | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.network" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        name?: string | undefined;
-        nodes?: {
-            schema: "network.xyo.network.node" & {
-                readonly __schema: true;
-            };
-            slug: string;
-            type: "archivist" | "diviner" | "bridge" | "sentinel";
-            uri: string;
-            docs?: string | undefined;
-            name?: string | undefined;
-            web?: string | undefined;
-        }[] | undefined;
-    };
-};
-export declare const toNetworkPayload: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.network" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        name?: string | undefined;
-        nodes?: {
-            schema: "network.xyo.network.node" & {
-                readonly __schema: true;
-            };
-            slug: string;
-            type: "archivist" | "diviner" | "bridge" | "sentinel";
-            uri: string;
-            docs?: string | undefined;
-            name?: string | undefined;
-            web?: string | undefined;
-        }[] | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.network" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        name?: string | undefined;
-        nodes?: {
-            schema: "network.xyo.network.node" & {
-                readonly __schema: true;
-            };
-            slug: string;
-            type: "archivist" | "diviner" | "bridge" | "sentinel";
-            uri: string;
-            docs?: string | undefined;
-            name?: string | undefined;
-            web?: string | undefined;
-        }[] | undefined;
-    };
-};

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkPayloadWrapper.d.ts

@@ -1,62 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
-import type { NetworkNodeType } from './NetworkNodePayload.ts';
-import type { NetworkPayload } from './NetworkPayload.ts';
-export declare class NetworkPayloadWrapper extends PayloadWrapper<NetworkPayload> {
-    static known(hash: Hash): Promise<NetworkPayload | undefined>;
-    get archivists(): {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }[] | undefined;
-    get bridges(): {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }[] | undefined;
-    get diviners(): {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }[] | undefined;
-    get sentinels(): {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }[] | undefined;
-    filterNodesByType(type: NetworkNodeType): {
-        schema: "network.xyo.network.node" & {
-            readonly __schema: true;
-        };
-        slug: string;
-        type: "archivist" | "diviner" | "bridge" | "sentinel";
-        uri: string;
-        docs?: string | undefined;
-        name?: string | undefined;
-        web?: string | undefined;
-    }[] | undefined;
-}

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/index.d.ts

@@ -1,7 +0,0 @@
-export * from './knownArchivists.ts';
-export * from './knownDiviners.ts';
-export * from './knownNetworks.ts';
-export * from './NetworkNodePayload.ts';
-export * from './NetworkNodePayloadWrapper.ts';
-export * from './NetworkPayload.ts';
-export * from './NetworkPayloadWrapper.ts';