pmcf 1.27.2 → 1.29.0

package/bin/pmcf-host-defs

@@ -4,18 +4,18 @@ import { writeFile, mkdir, copyFile, glob, chmod } from "node:fs/promises";
 import { join } from "node:path";
 import { Host } from "pmcf";
 import { writeLines, sectionLines } from "../src/utils.mjs";
-import { prepare, } from "../src/cmd.mjs";
+import { prepare } from "../src/cmd.mjs";
 
-const { world, args, options } = prepare();
+const { root, args, options } = prepare();
 
 const hostName = args[0];
 
-const host = await world.load(hostName,{ type: Host });
+const host = await root.load(hostName, { type: Host });
 
 await generateNetworkDefs(host, options.output);
 await generateMachineInfo(host, options.output);
 await copySshKeys(host, options.output);
-await generateKnownHosts(world.hosts(), join(options.output, "root", ".ssh"));
+await generateKnownHosts(root.hosts(), join(options.output, "root", ".ssh"));
 
 console.log("provides", "host", ...host.provides);
 console.log("depends", `location-${host.location.name}`, ...host.depends);
@@ -153,7 +153,10 @@ async function copySshKeys(host, dir) {
   for await (const file of glob("ssh_host_*", { cwd: host.directory })) {
     const destinationFileName = join(sshDir, file);
     await copyFile(join(host.directory, file), destinationFileName);
-    await chmod(destinationFileName, destinationFileName.endsWith('.pub') ? 0o0644 : 0o0600);
+    await chmod(
+      destinationFileName,
+      destinationFileName.endsWith(".pub") ? 0o0644 : 0o0600
+    );
   }
 }
 

package/bin/pmcf-info

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import { prepare } from "../src/cmd.mjs";
-const { world, args } = prepare();
+const { root, args } = prepare();
+
+await root.loadAll();
 
 const objectName = args[0];
 
 if (objectName) {
-  const object = await world.named(objectName);
+  const object = await root.named(objectName);
   console.log(object.toJSON());
 } else {
-  for await (const location of world.locations()) {
+  for await (const location of root.locations()) {
     console.log(location.name);
-    console.log("  ", (await location.service({ type: "dns"}))?.toString());
+    console.log("  ", (await location.service({ type: "dns" }))?.toString());
   }
 }

package/bin/pmcf-location-defs

@@ -6,9 +6,11 @@ import { Location } from "pmcf";
 import { writeLines, sectionLines } from "../src/utils.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args, options } = prepare();
+const { root, args, options } = prepare();
 
-const location = await world.load(args[0], { type: Location });
+await root.loadAll();
+
+const location = await root.load(args[0], { type: Location });
 
 await generateLocationDefs(location, options.output);
 

package/bin/pmcf-named-defs

@@ -9,9 +9,11 @@ import {
 } from "../src/utils.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args, options } = prepare();
+const { root, args, options } = prepare();
 
-const owner = await world.load(args[0]);
+await root.loadAll();
+
+const owner = await root.load(args[0]);
 const updates = [
   Math.ceil(Date.now() / 1000),
   36000,
@@ -42,7 +44,7 @@ async function generateNamedDefs(owner, targetDir) {
     const createRecord = (key, type, value) => {
       return {
         key,
-       /*type,
+        /*type,
         value,*/
         toString: () =>
           `${key.padEnd(maxKeyLength, " ")} ${ttl} IN ${type.padEnd(

package/bin/pmcf-network

@@ -2,9 +2,9 @@
 
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args } = prepare();
+const { root, args } = prepare();
 
-const location = await world.load(args[0]);
+const location = await root.load(args[0]);
 
 function q(str) {
   return str.match(/^\w+$/) ? str : `"${str}"`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "1.27.2",
+  "version": "1.29.0",
   "publishConfig": {
     "access": "public"
   },
@@ -43,7 +43,7 @@
     "pacc": "^3.1.9"
   },
   "devDependencies": {
-    "@types/node": "^22.10.10",
+    "@types/node": "^22.12.0",
     "ava": "^6.2.0",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",

package/src/base.mjs

@@ -9,6 +9,14 @@ export class Base {
   static get typeName() {
     return "base";
   }
+  
+  static get pluralTypeName() {
+    return this.typeName + "s";
+  }
+
+  static get nameLookupName() {
+    return this.typeName + "Named";
+  }
 
   static get typeFileName() {
     return this.typeName + ".json";
@@ -18,16 +26,14 @@ export class Base {
     return "**/" + this.typeFileName;
   }
 
-  static async prepareData(world, data) {
+  static async prepareData(root, data) {
     return this;
   }
 
-  static baseName(name) {
-    if (!name) {
-      return undefined;
+  static normalizeName(name) {
+    if (name !== undefined) {
+      return name.replace(/\/\w+\.json$/, "");
     }
-
-    return name.replace(/\/\w+\.json$/, "");
   }
 
   constructor(owner, data) {
@@ -43,6 +49,7 @@ export class Base {
 
   withOwner(owner) {
     if (this.owner !== owner) {
+      // @ts-ignore
       return new this.constructor(owner, this);
     }
 
@@ -50,11 +57,12 @@ export class Base {
   }
 
   get typeName() {
+    // @ts-ignore
     return this.constructor.typeName;
   }
 
-  get world() {
-    return this.owner.world;
+  get root() {
+    return this.owner.root;
   }
 
   get location() {
@@ -83,7 +91,7 @@ export class Base {
   }
 
   get fullName() {
-    return this.owner?.fullName
+    return this.owner && this.name
       ? join(this.owner.fullName, this.name)
       : this.name;
   }

package/src/cluster.mjs

@@ -4,4 +4,9 @@ export class Cluster extends Owner {
   static get typeName() {
     return "cluster";
   }
+
+  constructor(owner, data) {
+    super(owner, data);
+    owner.addObject(this);
+  }
 }

package/src/cmd.mjs

@@ -1,12 +1,12 @@
 import { parseArgs } from "node:util";
 import { argv, cwd, env } from "node:process";
-import { World } from "./model.mjs";
+import { Root } from "./model.mjs";
 
 export function prepare() {
   const { values, positionals } = parseArgs({
     args: argv.slice(2),
     options: {
-      world: {
+      root: {
         type: "string",
         short: "w",
         default: env.PMCF_WORLD || cwd()
@@ -20,7 +20,7 @@ export function prepare() {
     allowPositionals: true
   });
 
-  const world = new World(values.world);
+  const root = new Root(values.root);
 
-  return { world, options: values, args: positionals };
+  return { root, options: values, args: positionals };
 }

package/src/dns.mjs

@@ -13,6 +13,7 @@ export class DNSService extends Base {
   constructor(owner, data) {
     super(owner, data);
     Object.assign(this, data);
+    owner.addObject(this);
   }
 
   async *services() {
@@ -21,7 +22,7 @@ export class DNSService extends Base {
     yield* this.owner.services(filter);
 
     for (const s of asArray(this.forwardsTo)) {
-      const owner = await this.owner.world.load(s);
+      const owner = await this.owner.root.load(s);
       yield* owner.services(filter);
     }
   }

package/src/model.mjs

@@ -7,104 +7,92 @@ import {
   normalizeIPAddress
 } from "./utils.mjs";
 import { Base } from "./base.mjs";
-import { Owner } from "./owner.mjs";
+import { Owner, Network, Subnet } from "./owner.mjs";
 import { Service } from "./service.mjs";
 import { Cluster } from "./cluster.mjs";
 import { DNSService } from "./dns.mjs";
 
-export class World extends Owner {
+export class Root extends Owner {
   static get types() {
     return _typesByName;
   }
 
   static get typeName() {
-    return "world";
+    return "root";
   }
 
-  #byName = new Map();
-
   constructor(directory) {
     super(undefined, { name: "" });
     this.directory = directory;
     this.addObject(this);
   }
 
-  _traverse(...args) {
-    if (super._traverse(...args)) {
-      for (const object of this.#byName.values()) {
-        object._traverse(...args);
-      }
-
-      return true;
-    }
-
-    return false;
-  }
-
   get fullName() {
     return "";
   }
 
-  get world() {
+  get root() {
     return this;
   }
 
   async load(name, options) {
-    if (name === "") {
-      return this;
-    }
-    const baseName = Base.baseName(name);
-
-    let object = this.#byName.get(baseName);
-
-    if (!object) {
-      let path = baseName.split("/");
-      path.pop();
-
-      let data;
-      let type = options?.type;
-      if (type) {
-        data = JSON.parse(
-          await readFile(
-            join(this.directory, baseName, type.typeFileName),
-            "utf8"
-          )
-        );
-      } else {
-        for (type of _types) {
-          try {
-            data = JSON.parse(
-              await readFile(
-                join(this.directory, baseName, type.typeFileName),
-                "utf8"
-              )
-            );
-            break;
-          } catch {}
-        }
-
-        if (!data) {
-          return this.load(path.join("/"), options);
-        }
-      }
+    const fullName = Base.normalizeName(name);
+    let object = this.named(fullName);
+    if (object) {
+      return object;
+    }
 
-      const owner = await this.load(path.join("/"));
+    //console.log("LOAD", fullName);
 
-      const length = owner.fullName.length;
-      const n = baseName[length] === "/" ? length + 1 : length;
-      data.name = baseName.substring(n);
+    let path = fullName.split("/");
+    path.pop();
 
-      type = await type.prepareData(this, data);
+    let data;
+    let type = options?.type;
+    if (type) {
+      data = JSON.parse(
+        await readFile(
+          join(this.directory, fullName, type.typeFileName),
+          "utf8"
+        )
+      );
+    } else {
+      for (type of _types) {
+        try {
+          data = JSON.parse(
+            await readFile(
+              join(this.directory, fullName, type.typeFileName),
+              "utf8"
+            )
+          );
+          break;
+        } catch {}
+      }
 
-      object = new type(owner, data);
-      this.addObject(object);
+      if (!data) {
+        return this.load(path.join("/"), options);
+      }
     }
 
+    const owner = await this.load(path.join("/"));
+
+    const length = owner.fullName.length;
+    const n = fullName[length] === "/" ? length + 1 : length;
+    data.name = fullName.substring(n);
+
+    type = await type.prepareData(this, data);
+
+    object = new type(owner, data);
+
+    this._addObject(type.typeName, fullName, object);
+
+    //console.log("FINISH LOAD", object.fullName);
+
     return object;
   }
 
   async loadAll() {
-    for (let type of Object.values(World.types)) {
+    for (let type of Object.values(Root.types)) {
       for await (const name of glob(type.fileNameGlob, {
         cwd: this.directory
       })) {
@@ -114,41 +102,6 @@ export class World extends Owner {
 
     this.execFinalize();
   }
-
-  addObject(object) {
-    this.#byName.set(object.fullName, object);
-  }
-
-  async named(name) {
-    await this.loadAll();
-    return this.#byName.get(name);
-  }
-
-  async *locations() {
-    await this.loadAll();
-
-    for (const object of this.#byName.values()) {
-      if (object instanceof Location) {
-        yield object;
-      }
-    }
-  }
-
-  async *hosts() {
-    await this.loadAll();
-
-    for (const object of this.#byName.values()) {
-      if (object instanceof Host) {
-        yield object;
-      }
-    }
-  }
-
-  async *domains() {
-    for await (const location of this.locations()) {
-      yield location.domain;
-    }
-  }
 }
 
 export class Location extends Owner {
@@ -159,82 +112,6 @@ export class Location extends Owner {
   get location() {
     return this;
   }
-
-  async *hosts() {
-    for await (const host of this.owner.hosts()) {
-      if (host.location === this) {
-        yield host;
-      }
-    }
-  }
-}
-
-export class Network extends Owner {
-  kind;
-  scope;
-  metric;
-  ipv4;
-  subnet;
-  bridge;
-
-  static get typeName() {
-    return "network";
-  }
-
-  constructor(owner, data) {
-    super(owner, data);
-
-    let bridge;
-    if (data.bridge) {
-      bridge = data.bridge;
-      delete data.bridge;
-    }
-
-    Object.assign(this, data);
-
-    const subnetAddress = this.subnetAddress;
-
-    if (subnetAddress) {
-      let subnet = owner.subnet(subnetAddress);
-      if (!subnet) {
-        subnet = new Subnet(owner, { name: subnetAddress });
-      }
-
-      this.subnet = subnet;
-      subnet.networks.add(this);
-    }
-
-    owner.addNetwork(this);
-
-    this.bridge = owner.addBridge(this, bridge);
-  }
-
-  get netmask() {
-    const m = this.ipv4?.match(/\/(\d+)$/);
-    if (m) {
-      return parseInt(m[1]);
-    }
-  }
-
-  get subnetAddress() {
-    if (this.ipv4) {
-      const [addr, bits] = this.ipv4.split(/\//);
-      const parts = addr.split(/\./);
-      return parts.slice(0, bits / 8).join(".");
-    }
-  }
-
-  get propertyNames() {
-    return [
-      ...super.propertyNames,
-      "kind",
-      "ipv4",
-      "netmask",
-      "scope",
-      "metric",
-      "bridge"
-    ];
-  }
 }
 
 export class Host extends Base {
@@ -256,14 +133,14 @@ export class Host extends Base {
     return "host";
   }
 
-  static async prepareData(world, data) {
+  static async prepareData(root, data) {
     if (data.location) {
-      data.location = await world.load(data.location, { type: Location });
+      data.location = await root.load(data.location, { type: Location });
     }
 
     if (data.extends) {
       data.extends = await Promise.all(
-        asArray(data.extends).map(e => world.load(e, { type: Host }))
+        asArray(data.extends).map(e => root.load(e, { type: Host }))
       );
     }
 
@@ -335,7 +212,7 @@ export class Host extends Base {
       new NetworkInterface(this, iface);
     }
 
-    owner.addHost(this);
+    owner.addObject(this);
   }
 
   _traverse(...args) {
@@ -452,7 +329,7 @@ export class Host extends Base {
     this.networkInterfaces[networkInterface.name] = networkInterface;
 
     if (networkInterface.network) {
-      networkInterface.network.addHost(this);
+      networkInterface.network.addObject(this);
     }
   }
 
@@ -465,7 +342,9 @@ export class Host extends Base {
   }
 
   get ipAddresses() {
-    return [...this.networkAddresses()].map(na => normalizeIPAddress(na.address));
+    return [...this.networkAddresses()].map(na =>
+      normalizeIPAddress(na.address)
+    );
   }
 
   get ipAddress() {
@@ -655,25 +534,5 @@ export class NetworkInterface extends Base {
   }
 }
 
-export class Subnet extends Base {
-  networks = new Set();
-
-  static get typeName() {
-    return "subnet";
-  }
-
-  constructor(owner, data) {
-    super(owner, data);
-
-    Object.assign(this, data);
-
-    owner.addSubnet(this);
-  }
-
-  get address() {
-    return this.name;
-  }
-}
-
 const _types = [Location, Network, Subnet, Host, Cluster, Service, DNSService];
 const _typesByName = Object.fromEntries(_types.map(t => [t.typeName, t]));

package/src/owner.mjs

@@ -1,12 +1,9 @@
 import { asArray, bridgeToJSON } from "./utils.mjs";
-
 import { Base } from "./base.mjs";
 import { DNSService } from "./dns.mjs";
 
 export class Owner extends Base {
-  #hosts = new Map();
-  #networks = new Map();
-  #subnets = new Map();
+  #membersByType = new Map();
   #bridges = new Set();
   #dns;
   #administratorEmail;
@@ -34,16 +31,16 @@ export class Owner extends Base {
       }
     }
     Object.assign(this, data);
+
+    owner?.addObject(this);
   }
 
   _traverse(...args) {
     if (super._traverse(...args)) {
-      for (const network of this.#networks.values()) {
-        network._traverse(...args);
-      }
-
-      for (const host of this.#hosts.values()) {
-        host._traverse(...args);
+      for (const typeSlot of this.#membersByType.values()) {
+        for (const object of typeSlot.values()) {
+          object._traverse(...args);
+        }
       }
 
       return true;
@@ -56,19 +53,44 @@ export class Owner extends Base {
     return this.#dns;
   }
 
-  async *hosts() {
-    for (const host of this.#hosts.values()) {
-      yield host;
+  named(name) {
+    //console.log("NAMED", this.#membersByType.keys());
+    for (const slot of this.#membersByType.values()) {
+      const object = slot.get(name);
+      if (object) {
+        return object;
+      }
     }
   }
 
-  addObject(object) {
-    this.world.addObject(object);
+  typeNamed(typeName, name) {
+    const typeSlot = this.#membersByType.get(typeName);
+    return typeSlot?.get(name);
   }
 
-  addHost(host) {
-    this.#hosts.set(host.name, host);
-    this.addObject(host);
+  *typeList(typeName) {
+    const typeSlot = this.#membersByType.get(typeName);
+    if (typeSlot) {
+      for (const object of typeSlot.values()) {
+        yield object;
+      }
+    }
+  }
+
+  _addObject(typeName, fullName, object) {
+    let typeSlot = this.#membersByType.get(typeName);
+    if (!typeSlot) {
+      typeSlot = new Map();
+      this.#membersByType.set(typeName, typeSlot);
+    }
+    typeSlot.set(fullName, object);
+
+    //console.log(this.toString(),"ADD", typeName, fullName, object.name, this.named(fullName)?.toString());
+  }
+
+  addObject(object) {
+    this.owner?.addObject(object);
+    this._addObject(object.typeName, object.fullName, object);
   }
 
   async service(filter) {
@@ -90,18 +112,44 @@ export class Owner extends Base {
     }
   }
 
+  locationNamed(name) {
+    return this.typeNamed("location", name);
+  }
+
+  locations() {
+    return this.typeList("location");
+  }
+
+  hostNamed(name) {
+    return this.typeNamed("host", name);
+  }
+
+  hosts() {
+    return this.typeList("host");
+  }
+
   networkNamed(name) {
-    return this.#networks.get(name);
+    return this.typeNamed("network", name);
   }
 
-  async *networks() {
-    for (const network of this.#networks.values()) {
-      yield network;
-    }
+  networks() {
+    return this.typeList("network");
+  }
+
+  subnetNamed(name) {
+    return this.typeNamed("subnet", name);
+  }
+
+  subnets() {
+    return this.typeList("subnet");
+  }
+
+  clusterNamed(name) {
+    return this.typeNamed("cluster", name);
   }
 
-  addNetwork(network) {
-    this.#networks.set(network.fullName, network);
+  clusters() {
+    return this.typeList("cluster");
   }
 
   addBridge(network, destinationNetworks) {
@@ -167,33 +215,115 @@ export class Owner extends Base {
     }
   }
 
-  addSubnet(subnet) {
-    this.#subnets.set(subnet.name, subnet);
+  get administratorEmail() {
+    return this.#administratorEmail || "admin@" + this.domain;
   }
 
-  subnet(name) {
-    return this.#subnets.get(name);
+  *domains() {
+    for (const location of this.locations()) {
+      yield location.domain;
+    }
   }
 
-  subnets() {
-    return this.#subnets.values();
+  get propertyNames() {
+    return [...super.propertyNames, "domain", "administratorEmail", "dns"];
   }
 
-  get administratorEmail() {
-    return this.#administratorEmail || "admin@" + this.domain;
+  toJSON() {
+    const json = super.toJSON();
+
+    for (const [typeName, slot] of this.#membersByType) {
+      json[typeName] = [...slot.keys()].sort();
+    }
+
+    return json;
+  }
+}
+
+export class Network extends Owner {
+  kind;
+  scope;
+  metric;
+  ipv4;
+  subnet;
+  bridge;
+
+  static get typeName() {
+    return "network";
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+
+    let bridge;
+    if (data.bridge) {
+      bridge = data.bridge;
+      delete data.bridge;
+    }
+
+    Object.assign(this, data);
+
+    const subnetAddress = this.subnetAddress;
+
+    if (subnetAddress) {
+      let subnet = owner.subnetNamed(subnetAddress);
+      if (!subnet) {
+        subnet = new Subnet(owner, { name: subnetAddress });
+      }
+
+      this.subnet = subnet;
+      subnet.networks.add(this);
+    }
+
+    owner.addObject(this);
+
+    this.bridge = owner.addBridge(this, bridge);
+  }
+
+  get netmask() {
+    const m = this.ipv4?.match(/\/(\d+)$/);
+    if (m) {
+      return parseInt(m[1]);
+    }
+  }
+
+  get subnetAddress() {
+    if (this.ipv4) {
+      const [addr, bits] = this.ipv4.split(/\//);
+      const parts = addr.split(/\./);
+      return parts.slice(0, bits / 8).join(".");
+    }
   }
 
   get propertyNames() {
-    return [...super.propertyNames, "domain", "administratorEmail", "dns"];
+    return [
+      ...super.propertyNames,
+      "kind",
+      "ipv4",
+      "netmask",
+      "scope",
+      "metric",
+      "bridge"
+    ];
   }
+}
 
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      networks: [...this.#networks.keys()].sort(),
-      subnets: [...this.#subnets.keys()].sort(),
-      bridges: [...this.#bridges].map(b => bridgeToJSON(b)),
-      hosts: [...this.#hosts.keys()].sort()
-    };
+export class Subnet extends Base {
+  networks = new Set();
+
+  static get typeName() {
+    return "subnet";
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+
+    Object.assign(this, data);
+
+    owner.addObject(this);
+  }
+
+  get address() {
+    return this.name;
   }
 }

package/src/service.mjs

@@ -71,6 +71,7 @@ export class Service extends Base {
       if (this.#ipAddresses) {
         data.ipAddresses = this.#ipAddresses;
       }
+      // @ts-ignore
       return new this.constructor(owner, data);
     }
 

package/types/base.d.mts

@@ -1,17 +1,19 @@
 export function extractFrom(object: any, propertyNames: any): {};
 export class Base {
     static get typeName(): string;
+    static get pluralTypeName(): string;
+    static get nameLookupName(): string;
     static get typeFileName(): string;
     static get fileNameGlob(): string;
-    static prepareData(world: any, data: any): Promise<typeof Base>;
-    static baseName(name: any): any;
+    static prepareData(root: any, data: any): Promise<typeof Base>;
+    static normalizeName(name: any): any;
     constructor(owner: any, data: any);
     owner: any;
     name: any;
     description: any;
     withOwner(owner: any): any;
     get typeName(): any;
-    get world(): any;
+    get root(): any;
     get location(): any;
     get host(): any;
     get network(): any;

package/types/cmd.d.mts

@@ -1,9 +1,9 @@
 export function prepare(): {
-    world: World;
+    root: Root;
     options: {
-        world: string;
+        root: string;
         output: string;
     };
     args: string[];
 };
-import { World } from "./model.mjs";
+import { Root } from "./model.mjs";

package/types/model.d.mts

@@ -1,33 +1,18 @@
-export class World extends Owner {
+export class Root extends Owner {
     static get types(): {
-        [k: string]: typeof DNSService | typeof Cluster | typeof Service | typeof Host | typeof Network | typeof Subnet;
+        [k: string]: typeof DNSService | typeof Subnet | typeof Cluster | typeof Service | typeof Host;
     };
     constructor(directory: any);
     get fullName(): string;
-    get world(): this;
+    get root(): this;
     load(name: any, options: any): any;
     loadAll(): Promise<void>;
-    named(name: any): Promise<any>;
-    locations(): AsyncGenerator<Location, void, unknown>;
-    hosts(): AsyncGenerator<Host, void, unknown>;
-    domains(): AsyncGenerator<any, void, unknown>;
-    #private;
 }
 export class Location extends Owner {
     get location(): this;
 }
-export class Network extends Owner {
-    kind: any;
-    scope: any;
-    metric: any;
-    ipv4: any;
-    subnet: any;
-    bridge: any;
-    get netmask(): number;
-    get subnetAddress(): any;
-}
 export class Host extends Base {
-    static prepareData(world: any, data: any): Promise<typeof Host>;
+    static prepareData(root: any, data: any): Promise<typeof Host>;
     networkInterfaces: {};
     postinstall: any[];
     _traverse(...args: any[]): boolean;
@@ -81,12 +66,9 @@ export class NetworkInterface extends Base {
     get kind(): any;
     #private;
 }
-export class Subnet extends Base {
-    networks: Set<any>;
-    get address(): any;
-}
 import { Owner } from "./owner.mjs";
 import { DNSService } from "./dns.mjs";
+import { Subnet } from "./owner.mjs";
 import { Cluster } from "./cluster.mjs";
 import { Service } from "./service.mjs";
 import { Base } from "./base.mjs";

package/types/owner.d.mts

@@ -5,27 +5,42 @@ export class Owner extends Base {
     };
     _traverse(...args: any[]): boolean;
     get dns(): DNSService;
-    hosts(): AsyncGenerator<any, void, unknown>;
+    named(name: any): any;
+    typeNamed(typeName: any, name: any): any;
+    typeList(typeName: any): Generator<any, void, unknown>;
+    _addObject(typeName: any, fullName: any, object: any): void;
     addObject(object: any): void;
-    addHost(host: any): void;
     service(filter: any): Promise<any>;
     services(filter: any): AsyncGenerator<any, void, unknown>;
+    locationNamed(name: any): any;
+    locations(): Generator<any, void, unknown>;
+    hostNamed(name: any): any;
+    hosts(): Generator<any, void, unknown>;
     networkNamed(name: any): any;
-    networks(): AsyncGenerator<any, void, unknown>;
-    addNetwork(network: any): void;
+    networks(): Generator<any, void, unknown>;
+    subnetNamed(name: any): any;
+    subnets(): Generator<any, void, unknown>;
+    clusterNamed(name: any): any;
+    clusters(): Generator<any, void, unknown>;
     addBridge(network: any, destinationNetworks: any): any;
     _resolveBridges(): void;
     networkAddresses(): AsyncGenerator<any, void, unknown>;
-    addSubnet(subnet: any): void;
-    subnet(name: any): any;
-    subnets(): MapIterator<any>;
-    toJSON(): {
-        networks: any[];
-        subnets: any[];
-        bridges: any[][];
-        hosts: any[];
-    };
+    domains(): Generator<any, void, unknown>;
     #private;
 }
+export class Network extends Owner {
+    kind: any;
+    scope: any;
+    metric: any;
+    ipv4: any;
+    subnet: any;
+    bridge: any;
+    get netmask(): number;
+    get subnetAddress(): any;
+}
+export class Subnet extends Base {
+    networks: Set<any>;
+    get address(): any;
+}
 import { Base } from "./base.mjs";
 import { DNSService } from "./dns.mjs";