pmcf 3.8.14 → 3.8.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "3.8.14",
+  "version": "3.8.15",
   "publishConfig": {
     "access": "public"
   },
@@ -51,7 +51,7 @@
     "lint:typescript": "tsc --allowJs --checkJs --noEmit --resolveJsonModule --target esnext -m esnext --module nodenext --moduleResolution nodenext ./src**/*.mjs"
   },
   "dependencies": {
-    "ip-utilties": "^1.4.8",
+    "ip-utilties": "^1.4.9",
     "npm-pkgbuild": "^18.2.29",
     "pacc": "^4.14.1",
     "package-directory": "^8.1.0"

package/src/base.mjs

@@ -72,10 +72,6 @@ export class Base {
       case "object":
         this.read(data, BaseTypeDefinition);
     }
-
-    if (this.name === undefined) {
-      this.error("Missing name", this.owner?.toString(), data);
-    }
   }
 
   ownerFor(property, data) {
@@ -94,7 +90,11 @@ export class Base {
     return this;
   }
 
-  read(data, type) {
+  read(data, type=this.constructor.typeDefinition) {
+    if(type.extends) {
+      this.read(data, type.extends);
+    }
+
     const assign = (name, property, value) => {
       if (value === undefined && property.default !== undefined) {
         value = property.default;
@@ -178,6 +178,7 @@ export class Base {
                   this.ownerFor(property, value),
                   value
                 );
+                object.read(value);
                 this.addObject(object);
               } else {
                 this.finalize(() => {

package/src/cluster.mjs

@@ -35,10 +35,6 @@ export class Cluster extends Host {
     return ClusterTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, ClusterTypeDefinition);
-  }
 
   set masters(value) {
     this._masters.push(value);

package/src/extra-source-service.mjs

@@ -22,11 +22,6 @@ export class ExtraSourceService extends Service {
     return ExtraSourceServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, ExtraSourceServiceTypeDefinition);
-  }
-
   get type() {
     return ExtraSourceServiceTypeDefinition.name;
   }

package/src/host.mjs

@@ -109,12 +109,13 @@ export class Host extends ServiceOwner {
 
   constructor(owner, data) {
     super(owner, data);
-
-    this.read(data, HostTypeDefinition);
-
     owner.addObject(this);
+  }
 
-    if (data.extends) {
+  read(data, type) {
+    super.read(data, type);
+
+    if (data?.extends) {
       this.finalize(() => {
         for (const host of this.extends) {
           host.execFinalize();
@@ -122,7 +123,6 @@ export class Host extends ServiceOwner {
         }
       });
     }
-
     this.extra = data.extra;
   }
 

package/src/location.mjs

@@ -23,11 +23,6 @@ export class Location extends Owner {
     return LocationTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, LocationTypeDefinition);
-  }
-
   get location() {
     return this;
   }

package/src/network-interfaces/ethernet.mjs

@@ -30,11 +30,6 @@ export class EthernetNetworkInterface extends NetworkInterface {
     return name.match(/eth\d+$/);
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, EthernetNetworkInterfaceTypeDefinition);
-  }
-
   get kind() {
     return EthernetNetworkInterfaceTypeDefinition.name;
   }

package/src/network-interfaces/loopback.mjs

@@ -33,11 +33,6 @@ export class LoopbackNetworkInterface extends SkeletonNetworkInterface {
     return name.match(/lo\d+$/);
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, NetworkInterfaceTypeDefinition);
-  }
-
   get kind() {
     return LoopbackNetworkInterfaceTypeDefinition.name;
   }

package/src/network-interfaces/network-interface.mjs

@@ -69,11 +69,6 @@ export class NetworkInterface extends SkeletonNetworkInterface {
   _hwaddr;
   _class;
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, NetworkInterfaceTypeDefinition);
-  }
-
   addSubnet(address) {
     if (!this.network) {
       if (!hasWellKnownSubnet(address)) {

package/src/network-interfaces/tun.mjs

@@ -1,8 +1,8 @@
-import { SkeletonNetworkInterface } from "./skeleton.mjs";
+import { NetworkInterface } from "./network-interface.mjs";
 import { NetworkInterfaceTypeDefinition } from "./network-interface.mjs";
 import { addType } from "../types.mjs";
 
-const WireguardNetworkInterfaceTypeDefinition = {
+const TUNdNetworkInterfaceTypeDefinition = {
   name: "tun",
   specializationOf: NetworkInterfaceTypeDefinition,
   owners: NetworkInterfaceTypeDefinition.owners,
@@ -11,20 +11,16 @@ const WireguardNetworkInterfaceTypeDefinition = {
   properties: {}
 };
 
-export class TUNNetworkInterface extends SkeletonNetworkInterface {
+export class TUNNetworkInterface extends NetworkInterface {
   static {
     addType(this);
   }
 
   static get typeDefinition() {
-    return WireguardNetworkInterfaceTypeDefinition;
+    return TUNdNetworkInterfaceTypeDefinition;
   }
 
   get kind() {
-    return WireguardNetworkInterfaceTypeDefinition.name;
-  }
-
-  get ipAddresses() {
-    return new Map();
+    return TUNdNetworkInterfaceTypeDefinition.name;
   }
 }

package/src/network.mjs

@@ -35,11 +35,6 @@ export class Network extends Owner {
     return NetworkTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, NetworkTypeDefinition);
-  }
-
   get network() {
     return this;
   }

package/src/owner.mjs

@@ -44,11 +44,6 @@ export class Owner extends Base {
     return OwnerTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, OwnerTypeDefinition);
-  }
-
   _traverse(...args) {
     if (super._traverse(...args)) {
       for (const typeSlot of this._membersByType.values()) {

package/src/service.mjs

@@ -86,11 +86,6 @@ export class Service extends Base {
     return ServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, ServiceTypeDefinition);
-  }
-
   toString() {
     return `${super.toString()}[${this.type}]`;
   }

package/src/services/bind.mjs

@@ -120,7 +120,6 @@ export class BindService extends ExtraSourceService {
   retry = 72000;
   expire = 600000;
   minimum = 60000;
-
   static {
     addType(this);
   }
@@ -133,7 +132,13 @@ export class BindService extends ExtraSourceService {
     super(owner, data);
 
     this._systemd = "bind.service";
-    this._extends.push(new Service(owner, { name: this.name, type: "dns" }));
+
+    // TODO
+    const dns = new Service(owner);
+    dns.name = "dns";
+    dns.type = "dns";
+
+    this._extends.push(dns);
     this.views = {};
 
     for (const name of ["internal", "protected"]) {
@@ -145,8 +150,6 @@ export class BindService extends ExtraSourceService {
 
     this.views.protected.inView = this.views.internal;
     this.views.protected.access = ["!internal"];
-
-    this.read(data, BindServiceTypeDefinition);
   }
 
   get type() {

package/src/services/chrony.mjs

@@ -58,11 +58,7 @@ export class ChronyService extends ExtraSourceService {
 
   constructor(owner, data) {
     super(owner, data);
-
     this._extends.push(new Service(owner, { name: this.name, type: "ntp" }));
-
-    this.read(data, ChronyServiceTypeDefinition);
-
     this._systemd = "chronyd.service";
   }
 

package/src/services/influxdb.mjs

@@ -44,11 +44,6 @@ export class InfluxdbService extends Service {
     return InfluxdbServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, InfluxdbServiceTypeDefinition);
-  }
-
   get type() {
     return InfluxdbServiceTypeDefinition.name;
   }

package/src/services/kea.mjs

@@ -136,11 +136,6 @@ export class KeaService extends Service {
     return KeaServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, KeaServiceTypeDefinition);
-  }
-
   get type() {
     return KeaServiceTypeDefinition.name;
   }

package/src/services/mosquitto.mjs

@@ -35,11 +35,6 @@ export class MosquittoService extends Service {
     return MosquittoServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, MosquittoServiceTypeDefinition);
-  }
-
   get type() {
     return MosquittoServiceTypeDefinition.name;
   }

package/src/services/openldap.mjs

@@ -55,8 +55,6 @@ export class OpenLDAPService extends Service {
 
   constructor(owner, data) {
     super(owner, data);
-    this.read(data, OpenLDAPServiceTypeDefinition);
-
     this._systemd = "slapd.service";
   }
 

package/src/services/systemd-journal-remote.mjs

@@ -35,11 +35,6 @@ export class SystemdJournalRemoteService extends Service {
     return SystemdJournalRemoteServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, SystemdJournalRemoteServiceTypeDefinition);
-  }
-
   get type() {
     return SystemdJournalRemoteServiceTypeDefinition.name;
   }

package/src/services/systemd-journal-upload.mjs

@@ -23,11 +23,6 @@ export class SystemdJournalUploadService extends Service {
     return SystemdJournalUploadServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, SystemdJournalUploadServiceTypeDefinition);
-  }
-
   get type() {
     return SystemdJournalUploadServiceTypeDefinition.name;
   }

package/src/services/systemd-journal.mjs

@@ -20,11 +20,6 @@ export class SystemdJournalService extends Service {
     return SystemdJournalServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, SystemdJournalServiceTypeDefinition);
-  }
-
   get type() {
     return SystemdJournalServiceTypeDefinition.name;
   }

package/src/services/systemd-resolved.mjs

@@ -1,5 +1,6 @@
 import {
   ExtraSourceService,
+  ExtraSourceServiceTypeDefinition,
   ServiceTypeDefinition,
   serviceEndpoints
 } from "pmcf";
@@ -9,7 +10,7 @@ const SystemdResolvedServiceTypeDefinition = {
   name: "systemd-resolved",
   specializationOf: ServiceTypeDefinition,
   owners: ServiceTypeDefinition.owners,
-  extends: ServiceTypeDefinition,
+  extends: ExtraSourceServiceTypeDefinition,
   priority: 0.1,
   properties: {},
   service: {}
@@ -24,11 +25,6 @@ export class SystemdResolvedService extends ExtraSourceService {
     return SystemdResolvedServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, SystemdResolvedServiceTypeDefinition);
-  }
-
   get type() {
     return SystemdResolvedServiceTypeDefinition.name;
   }

package/src/services/systemd-timesyncd.mjs

@@ -1,5 +1,6 @@
 import {
   ExtraSourceService,
+  ExtraSourceServiceTypeDefinition,
   ServiceTypeDefinition,
   serviceEndpoints
 } from "pmcf";
@@ -9,7 +10,7 @@ const SystemdTimesyncdServiceTypeDefinition = {
   name: "systemd-timesyncd",
   specializationOf: ServiceTypeDefinition,
   owners: ServiceTypeDefinition.owners,
-  extends: ServiceTypeDefinition,
+  extends: ExtraSourceServiceTypeDefinition,
   priority: 0.1,
   properties: {},
   service: {}
@@ -24,11 +25,6 @@ export class SystemdTimesyncdService extends ExtraSourceService {
     return SystemdTimesyncdServiceTypeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    this.read(data, SystemdTimesyncdServiceTypeDefinition);
-  }
-
   get type() {
     return SystemdTimesyncdServiceTypeDefinition.name;
   }

package/src/types.mjs

@@ -91,5 +91,7 @@ export function resolveTypeLinks() {
 
 export function typeFactory(type, owner, data) {
   const factory = type.factoryFor?.(owner, data) || type.clazz;
-  return new factory(owner, data);
+  const object = new factory(owner);
+  object.read(data);
+  return object;
 }

package/types/base.d.mts

@@ -61,7 +61,7 @@ export class Base {
     _finalize: any;
     _properties: any;
     ownerFor(property: any, data: any): any;
-    read(data: any, type: any): void;
+    read(data: any, type?: any): void;
     named(name: any): void;
     typeNamed(typeName: any, name: any): any;
     addObject(object: any): any;

package/types/network-interfaces/tun.d.mts

@@ -1,4 +1,4 @@
-export class TUNNetworkInterface extends SkeletonNetworkInterface {
+export class TUNNetworkInterface extends NetworkInterface {
     static get typeDefinition(): {
         name: string;
         specializationOf: {
@@ -573,4 +573,4 @@ export class TUNNetworkInterface extends SkeletonNetworkInterface {
     };
     get kind(): string;
 }
-import { SkeletonNetworkInterface } from "./skeleton.mjs";
+import { NetworkInterface } from "./network-interface.mjs";

package/types/services/systemd-resolved.d.mts

@@ -203,22 +203,106 @@ export class SystemdResolvedService extends ExtraSourceService {
         extends: {
             name: string;
             owners: string[];
-            priority: number;
             extends: {
                 name: string;
-                owners: any[];
+                owners: string[];
+                priority: number;
+                extends: {
+                    name: string;
+                    owners: any[];
+                    properties: {
+                        owner: {
+                            type: string;
+                            collection: boolean;
+                            writable: boolean;
+                        };
+                        type: import("pacc").AttributeDefinition;
+                        name: import("pacc").AttributeDefinition;
+                        description: {
+                            writable: boolean;
+                            type: string;
+                            isKey: boolean;
+                            mandatory: boolean;
+                            collection: boolean;
+                            private?: boolean;
+                            depends?: string;
+                            description?: string;
+                            default?: any;
+                            set?: Function;
+                            get?: Function;
+                            env?: string[] | string;
+                        };
+                        priority: import("pacc").AttributeDefinition;
+                        directory: {
+                            writable: boolean;
+                            type: string;
+                            isKey: boolean;
+                            mandatory: boolean;
+                            collection: boolean;
+                            private?: boolean;
+                            depends?: string;
+                            description?: string;
+                            default?: any;
+                            set?: Function;
+                            get?: Function;
+                            env?: string[] | string;
+                        };
+                        packaging: import("pacc").AttributeDefinition;
+                        disabled: import("pacc").AttributeDefinition;
+                        tags: import("pacc").AttributeDefinition;
+                    };
+                };
+                specializations: {};
+                factoryFor(owner: any, value: any): any;
                 properties: {
-                    owner: {
+                    alias: {
                         type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
                         collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    weight: {
+                        type: string;
+                        isKey: boolean;
                         writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
                     };
-                    type: import("pacc").AttributeDefinition;
-                    name: import("pacc").AttributeDefinition;
-                    description: {
+                    systemd: import("pacc").AttributeDefinition;
+                    port: {
+                        type: string;
+                        isKey: boolean;
                         writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    protocol: {
+                        values: string[];
                         type: string;
                         isKey: boolean;
+                        writable: boolean;
                         mandatory: boolean;
                         collection: boolean;
                         private?: boolean;
@@ -229,8 +313,23 @@ export class SystemdResolvedService extends ExtraSourceService {
                         get?: Function;
                         env?: string[] | string;
                     };
-                    priority: import("pacc").AttributeDefinition;
-                    directory: {
+                    type: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    types: typeof import("pacc").string_collection_attribute;
+                    tls: import("pacc").AttributeDefinition;
+                    hostName: {
                         writable: boolean;
                         type: string;
                         isKey: boolean;
@@ -244,157 +343,70 @@ export class SystemdResolvedService extends ExtraSourceService {
                         get?: Function;
                         env?: string[] | string;
                     };
-                    packaging: import("pacc").AttributeDefinition;
-                    disabled: import("pacc").AttributeDefinition;
-                    tags: import("pacc").AttributeDefinition;
+                    cidrAddresses: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    cidrAddress: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    addresses: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    address: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
                 };
             };
-            specializations: {};
-            factoryFor(owner: any, value: any): any;
+            priority: number;
             properties: {
-                alias: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                weight: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                systemd: import("pacc").AttributeDefinition;
-                port: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                protocol: {
-                    values: string[];
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                type: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                types: typeof import("pacc").string_collection_attribute;
-                tls: import("pacc").AttributeDefinition;
-                hostName: {
-                    writable: boolean;
+                source: {
                     type: string;
-                    isKey: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                cidrAddresses: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                cidrAddress: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                addresses: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
                     collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                address: {
-                    type: string;
-                    isKey: boolean;
                     writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
                 };
             };
         };

package/types/services/systemd-timesyncd.d.mts

@@ -203,22 +203,106 @@ export class SystemdTimesyncdService extends ExtraSourceService {
         extends: {
             name: string;
             owners: string[];
-            priority: number;
             extends: {
                 name: string;
-                owners: any[];
+                owners: string[];
+                priority: number;
+                extends: {
+                    name: string;
+                    owners: any[];
+                    properties: {
+                        owner: {
+                            type: string;
+                            collection: boolean;
+                            writable: boolean;
+                        };
+                        type: import("pacc").AttributeDefinition;
+                        name: import("pacc").AttributeDefinition;
+                        description: {
+                            writable: boolean;
+                            type: string;
+                            isKey: boolean;
+                            mandatory: boolean;
+                            collection: boolean;
+                            private?: boolean;
+                            depends?: string;
+                            description?: string;
+                            default?: any;
+                            set?: Function;
+                            get?: Function;
+                            env?: string[] | string;
+                        };
+                        priority: import("pacc").AttributeDefinition;
+                        directory: {
+                            writable: boolean;
+                            type: string;
+                            isKey: boolean;
+                            mandatory: boolean;
+                            collection: boolean;
+                            private?: boolean;
+                            depends?: string;
+                            description?: string;
+                            default?: any;
+                            set?: Function;
+                            get?: Function;
+                            env?: string[] | string;
+                        };
+                        packaging: import("pacc").AttributeDefinition;
+                        disabled: import("pacc").AttributeDefinition;
+                        tags: import("pacc").AttributeDefinition;
+                    };
+                };
+                specializations: {};
+                factoryFor(owner: any, value: any): any;
                 properties: {
-                    owner: {
+                    alias: {
                         type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
                         collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    weight: {
+                        type: string;
+                        isKey: boolean;
                         writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
                     };
-                    type: import("pacc").AttributeDefinition;
-                    name: import("pacc").AttributeDefinition;
-                    description: {
+                    systemd: import("pacc").AttributeDefinition;
+                    port: {
+                        type: string;
+                        isKey: boolean;
                         writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    protocol: {
+                        values: string[];
                         type: string;
                         isKey: boolean;
+                        writable: boolean;
                         mandatory: boolean;
                         collection: boolean;
                         private?: boolean;
@@ -229,8 +313,23 @@ export class SystemdTimesyncdService extends ExtraSourceService {
                         get?: Function;
                         env?: string[] | string;
                     };
-                    priority: import("pacc").AttributeDefinition;
-                    directory: {
+                    type: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    types: typeof import("pacc").string_collection_attribute;
+                    tls: import("pacc").AttributeDefinition;
+                    hostName: {
                         writable: boolean;
                         type: string;
                         isKey: boolean;
@@ -244,157 +343,70 @@ export class SystemdTimesyncdService extends ExtraSourceService {
                         get?: Function;
                         env?: string[] | string;
                     };
-                    packaging: import("pacc").AttributeDefinition;
-                    disabled: import("pacc").AttributeDefinition;
-                    tags: import("pacc").AttributeDefinition;
+                    cidrAddresses: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    cidrAddress: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    addresses: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
+                    address: {
+                        type: string;
+                        isKey: boolean;
+                        writable: boolean;
+                        mandatory: boolean;
+                        collection: boolean;
+                        private?: boolean;
+                        depends?: string;
+                        description?: string;
+                        default?: any;
+                        set?: Function;
+                        get?: Function;
+                        env?: string[] | string;
+                    };
                 };
             };
-            specializations: {};
-            factoryFor(owner: any, value: any): any;
+            priority: number;
             properties: {
-                alias: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                weight: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                systemd: import("pacc").AttributeDefinition;
-                port: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                protocol: {
-                    values: string[];
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                type: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                types: typeof import("pacc").string_collection_attribute;
-                tls: import("pacc").AttributeDefinition;
-                hostName: {
-                    writable: boolean;
+                source: {
                     type: string;
-                    isKey: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                cidrAddresses: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                cidrAddress: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                addresses: {
-                    type: string;
-                    isKey: boolean;
-                    writable: boolean;
-                    mandatory: boolean;
                     collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
-                };
-                address: {
-                    type: string;
-                    isKey: boolean;
                     writable: boolean;
-                    mandatory: boolean;
-                    collection: boolean;
-                    private?: boolean;
-                    depends?: string;
-                    description?: string;
-                    default?: any;
-                    set?: Function;
-                    get?: Function;
-                    env?: string[] | string;
                 };
             };
         };