@gdacm/grafana-items 0.1.18 → 0.1.20

package/dist/index.js

@@ -20,7 +20,7 @@ var asJson = (obj) => {
 	return sortKeys(obj);
 };
 //#endregion
-//#region src/utils/typesDefinition.js
+//#region src/utils/MetaClassRegistry.js
 /**
 * @typedef {import("@gdacm/base-types").GenericMetaOptions} GenericMetaOptions
 */
@@ -29,72 +29,115 @@ var asJson = (obj) => {
 * @typedef {import("@gdacm/base-types").MetaConstructor<T>} MetaConstructor
 */
 /**
-* @typedef {Object} MetaClassInfo
-* @property {string[]} methods - The methods defined for the class
-* @property {((instance: GrafanaItem)=>void)[]} onInits - The onInit functions defined for the class
-* @property {string|undefined} parentName - The name of the parent class
-* @property {Function|undefined} parent - The parent class constructor
-* @property {String[]} typeNamesToInclude - The type names to include in the generated type definition
+* @template {Object} T
+* @template {T} C
+* @typedef {{
+*   methods: string[],
+*   onInits: ((instance: C)=>void)[],
+*   parentName: string|undefined,
+*   parent: MetaConstructor<T>|undefined,
+*   typeNamesToInclude: string[]
+* }} MetaClassInfo
 */
 /**
-* @type {Map<typeof GrafanaItem, MetaClassInfo>}
+* @template {Object} T
 */
-var types = /* @__PURE__ */ new Map();
+var MetaClassRegistry = class {
+	constructor() {
+		/**
+		* @type {Map<MetaConstructor<T>, unknown>}
+		*/
+		this.types = /* @__PURE__ */ new Map();
+	}
+	/**
+	* @template {T} C
+	* @param {MetaConstructor<C>} cls
+	* @param {MetaClassInfo<T,C>} info
+	*/
+	set(cls, info) {
+		this.types.set(cls, info);
+	}
+	/**
+	* @template {T} C
+	* @param {MetaConstructor<C>} cls
+	* @returns {MetaClassInfo<T,C>}
+	*/
+	get(cls) {
+		const info = this.types.get(cls);
+		if (info === void 0) throw new Error(`MetaClassInfo not found for class ${cls.name}`);
+		return info;
+	}
+	/**
+	* @template {T} C
+	* @param {MetaConstructor<C>} cls
+	* @returns {boolean}
+	*/
+	has(cls) {
+		return this.types.has(cls);
+	}
+	/**
+	* @returns {MetaConstructor<T>[]} The keys of the types map
+	*/
+	keys() {
+		return [...this.types.keys()];
+	}
+};
+//#endregion
+//#region src/utils/typesReference.js
 /**
-* @param {typeof GrafanaItem} cls 
+* @typedef {import("@gdacm/base-types").GenericMetaOptions} GenericMetaOptions
 */
-function defineClass(cls) {
-	if (!types.has(cls)) {
-		/** @type {Function|undefined} */
-		let parent = Object.getPrototypeOf(cls);
-		if (parent && !parent.name) parent = void 0;
-		/** @type {((instance: GrafanaItem)=>void)[]} */
-		let onInitsParent = [];
-		if (parent && parent.name) onInitsParent = getMetaClassInfo(parent).onInits;
-		/** @type {MetaClassInfo} */
-		const metaClassInfo = {
-			methods: [],
-			onInits: [...onInitsParent],
-			parentName: parent?.name,
-			parent,
-			typeNamesToInclude: []
-		};
-		cls.prototype._onInit = function() {
-			for (const onInit of metaClassInfo.onInits) onInit(this);
-		};
-		types.set(cls, metaClassInfo);
-	}
-	return new GrafanaItemClassBuilder(cls);
-}
 /**
-* 
-* @param {typeof GrafanaItem} cls
-* @returns {MetaClassInfo}
+* @template T
+* @typedef {import("@gdacm/base-types").MetaConstructor<T>} MetaConstructor
 */
-function getMetaClassInfo(cls) {
-	const metaClassInfo = types.get(cls);
-	if (metaClassInfo === void 0) throw new Error(`MetaClassInfo not found for class ${cls.name}`);
-	return metaClassInfo;
-}
 /**
-* @param {typeof GrafanaItem} cls
-* @param {string} name 
+* @template {Object} T
+* @template {T} C
+* @typedef {import("./MetaClassRegistry.js").MetaClassInfo<T,C>} MetaClassInfo
 */
-function hasPrototype(cls, name) {
-	return cls.prototype[name] !== void 0;
-}
 /**
-* @param {typeof GrafanaItem} cls
+* @type {MetaClassRegistry<GrafanaItem>}
+*/
+var types = new MetaClassRegistry();
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
+* @returns {boolean} Whether the type exists in the map
+*/
+var hasType = (cls) => types.has(cls);
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
+* @returns {MetaClassInfo<GrafanaItem,C>}
+*/
+var getMetaClassInfo = (cls) => types.get(cls);
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
+* @param {MetaClassInfo<GrafanaItem,C>} metaClassInfo
+*/
+var setTypeMetaClassInfo = (cls, metaClassInfo) => types.set(cls, metaClassInfo);
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
+* @returns {Record<string, unknown>}
+*/
+var getPrototype = (cls) => cls.prototype;
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
 * @param {string} name 
 * @param {Function} value 
 */
 function setPrototype(cls, name, value) {
-	cls.prototype[name] = value;
+	getPrototype(cls)[name] = value;
 }
 /**
-* @param {typeof GrafanaItem} cls 
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
 * @param {string} name 
-* @param {(self: GrafanaItem) => any} getter 
+* @param {(self: C) => any} getter 
 */
 function setGetter(cls, name, getter) {
 	Object.defineProperty(cls.prototype, name, {
@@ -106,9 +149,10 @@ function setGetter(cls, name, getter) {
 	});
 }
 /**
-* @param {typeof GrafanaItem} cls 
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
 * @param {string} name 
-* @param {(instance: GrafanaItem, value: any) => void} setter 
+* @param {(instance: C, value: any) => void} setter 
 */
 function setSetter(cls, name, setter) {
 	Object.defineProperty(cls.prototype, name, {
@@ -120,10 +164,11 @@ function setSetter(cls, name, setter) {
 	});
 }
 /**
-* @param {typeof GrafanaItem} cls 
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
 * @param {string} name 
-* @param {(self: GrafanaItem) => any} getter 
-* @param {(instance: GrafanaItem, value: any) => void} setter 
+* @param {(self: C) => any} getter 
+* @param {(instance: C, value: any) => void} setter 
 */
 function setGetterAndSetter(cls, name, getter, setter) {
 	Object.defineProperty(cls.prototype, name, {
@@ -138,100 +183,182 @@ function setGetterAndSetter(cls, name, getter, setter) {
 	});
 }
 /**
-* @param {typeof GrafanaItem} cls 
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} typeName
+*/
+var addTypeNameToInclude = (cls, typeName) => {
+	const metaClassInfo = getMetaClassInfo(cls);
+	if (metaClassInfo.typeNamesToInclude.includes(typeName) === false) {
+		if ([
+			"String",
+			"Number",
+			"Boolean",
+			"Array",
+			"Object"
+		].indexOf(typeName) === -1) metaClassInfo.typeNamesToInclude.push(typeName);
+	}
+};
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {(typeof GrafanaItem)[]} [typesToInclude]
+*/
+var addTypesToInclude = (cls, typesToInclude) => {
+	if (typesToInclude !== void 0) for (const type of typesToInclude) addTypeNameToInclude(cls, type.name);
+};
+/**
+* @template {GrafanaItem} C
+* @param {MetaClassInfo<GrafanaItem,C>} metaClassInfo
+* @param {string} signature 
+*/
+var addSignatureOnMetaClassInfo = (metaClassInfo, signature) => {
+	if (metaClassInfo.methods.includes(signature) === false) metaClassInfo.methods.push(signature);
+};
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
+* @param {string} signature 
+*/
+var addSignature = (cls, signature) => {
+	addSignatureOnMetaClassInfo(getMetaClassInfo(cls), signature);
+};
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls
+* @param {string} name 
+* @param {string} postSignature
+* @param {Function} value 
+*/
+var setPrototypeWithSignature = (cls, name, postSignature, value) => {
+	setPrototype(cls, name, value);
+	addSignature(cls, `${name}${postSignature}`);
+};
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} name 
+* @param {(self: C) => any} getter 
+* @param {(instance: C, value: any) => void} setter 
+* @param {string} typeName
+*/
+function setGetterAndSetterWithSignature(cls, name, getter, setter, typeName) {
+	setGetterAndSetter(cls, name, getter, setter);
+	addSignature(cls, `get ${name}(): ${typeName};`);
+	addSignature(cls, `set ${name}(value: ${typeName});`);
+}
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} name 
+* @param {(self: C) => any} getter 
+* @param {string} typeName
+*/
+function setGetterWithSignature(cls, name, getter, typeName) {
+	setGetter(cls, name, getter);
+	addSignature(cls, `get ${name}(): ${typeName};`);
+}
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} name 
+* @param {(instance: C, value: any) => void} setter 
+* @param {string} typeName
+*/
+function setSetterWithSignature(cls, name, setter, typeName) {
+	setSetter(cls, name, setter);
+	addSignature(cls, `set ${name}(value: ${typeName});`);
+}
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {((instance: C) => void)|undefined} onInit
+*/
+function addOnInit(cls, onInit) {
+	const metaClassInfo = getMetaClassInfo(cls);
+	if (onInit) metaClassInfo.onInits.push(onInit);
+}
+//#endregion
+//#region src/utils/typesDefinition.js
+/**
+* @typedef {import("@gdacm/base-types").GenericMetaOptions} GenericMetaOptions
+*/
+/**
+* @template T
+* @typedef {import("@gdacm/base-types").MetaConstructor<T>} MetaConstructor
+*/
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
 * @param {string} key 
 * @param {Function} type
 * @param {Object} [option]
 * @param {string} [option.name]
-* @param {(instance: GrafanaItem) => void} [option.onInit]
-* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+* @param {(instance: C) => void} [option.onInit]
+* @param {(metaOptions: GenericMetaOptions) => unknown} [option.onDefault]
 * @param {String} [option.typeName]
 */
 function defineValue(cls, key, type, option) {
-	const metaClassInfo = getMetaClassInfo(cls);
 	const name = option?.name ? option.name : key;
 	const caseName = name.charAt(0).toUpperCase() + name.slice(1);
 	const typeName = option?.typeName ? option.typeName : type.name;
-	if (metaClassInfo.typeNamesToInclude.includes(type.name) === false) {
-		if ([
-			"String",
-			"Number",
-			"Boolean",
-			"Array",
-			"Object"
-		].indexOf(type.name) === -1) metaClassInfo.typeNamesToInclude.push(type.name);
-	}
-	const setName = `set${caseName}`;
-	if (!hasPrototype(cls, setName)) {
-		setPrototype(
-			cls,
-			setName,
-			/**
-			* @this GrafanaItem
-			* @template T
-			* @param {T} value
-			* @returns {GrafanaItem}
-			*/
-			function(value) {
-				return this._setValue(key, value);
-			}
-		);
-		metaClassInfo.methods.push(`${setName}(${name}: ${typeName}): this;`);
-	}
-	if (option?.onInit) metaClassInfo.onInits.push(option.onInit);
-	if (option?.onDefault) metaClassInfo.onInits.push(function(instance) {
-		instance._setValue(key, option?.onDefault?.(instance.metaOptions));
-	});
+	addTypeNameToInclude(cls, type.name);
+	setPrototypeWithSignature(
+		cls,
+		`set${caseName}`,
+		`(${name}: ${typeName}): this;`,
+		/**
+		* @this C
+		* @template T
+		* @param {T} value
+		* @returns {C}
+		*/
+		function(value) {
+			return this._setValue(key, value);
+		}
+	);
+	addOnInit(cls, option?.onInit);
+	if (option?.onDefault) addOnInit(cls, (instance) => instance._setValue(key, option?.onDefault?.(instance.metaOptions)));
 }
 /**
-* @param {typeof GrafanaItem} cls 
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
 * @param {string} key 
 * @param {Function} type 
 * @param {Object} [option]
 * @param {string} [option.name]
-* @param {(instance: GrafanaItem) => void} [option.onInit]
-* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+* @param {(instance: C) => void} [option.onInit]
+* @param {(metaOptions: GenericMetaOptions) => unknown} [option.onDefault]
 * @param {String} [option.typeName]
 */
-function defineObject(cls, key, type, option) {
-	const metaClassInfo = getMetaClassInfo(cls);
+function defineBasicObject(cls, key, type, option) {
 	const name = option?.name ? option.name : key;
 	const caseName = name.charAt(0).toUpperCase() + name.slice(1);
 	const typeName = option?.typeName ? option.typeName : type.name;
-	if (metaClassInfo.typeNamesToInclude.includes(type.name) === false) {
-		if ([
-			"String",
-			"Number",
-			"Boolean",
-			"Array",
-			"Object"
-		].indexOf(type.name) === -1) metaClassInfo.typeNamesToInclude.push(type.name);
-	}
-	const setName = `set${caseName}`;
-	if (hasPrototype(cls, setName) === false) {
-		setPrototype(
-			cls,
-			setName,
-			/**
-			* @this GrafanaItem
-			* @template T
-			* @param {T} value
-			* @returns {GrafanaItem}
-			*/
-			function(value) {
-				return this._setObject(key, value);
-			}
-		);
-		metaClassInfo.methods.push(`${setName}(${name}: ${typeName}): this;`);
-	}
-	setPrototype(
+	addTypeNameToInclude(cls, type.name);
+	setPrototypeWithSignature(
+		cls,
+		`set${caseName}`,
+		`(${name}: ${typeName}): this;`,
+		/**
+		* @this C
+		* @template T
+		* @param {T} value
+		* @returns {C}
+		*/
+		function(value) {
+			return this._setObject(key, value);
+		}
+	);
+	setPrototypeWithSignature(
 		cls,
 		`with${caseName}`,
+		`(onWith: (item: ${typeName}) => void): this;`,
 		/**
-		* @this GrafanaItem
+		* @this C
 		* @template {GrafanaItem} T
 		* @param {(item: T) => void} onWith
-		* @returns {GrafanaItem}
+		* @returns {C}
 		*/
 		function(onWith) {
 			const item = this._getObject(key);
@@ -239,85 +366,62 @@ function defineObject(cls, key, type, option) {
 			return this;
 		}
 	);
-	metaClassInfo.methods.push(`with${caseName}(onWith: (item: ${typeName}) => void): this;`);
-	setGetter(cls, name, (self) => self._getObject(key));
-	metaClassInfo.methods.push(`get ${name}(): ${typeName};`);
-	if (option?.onInit) metaClassInfo.onInits.push(option?.onInit);
-	if (option?.onDefault) {
-		/**
-		* @param {GrafanaItem} instance
-		*/
-		const onInit = (instance) => {
-			instance._setObject(key, option?.onDefault?.(instance.metaOptions));
-		};
-		metaClassInfo.onInits.push(onInit);
-	}
+	setGetterWithSignature(cls, name, (self) => self._getObject(key), typeName);
+	addOnInit(cls, option?.onInit);
+	if (option?.onDefault) addOnInit(cls, (instance) => instance._setObject(key, option?.onDefault?.(instance.metaOptions)));
 }
 /**
+* @template {GrafanaItem} C
 * @template {GrafanaItem} T
-* @param {typeof GrafanaItem} cls 
+* @param {MetaConstructor<C>} cls 
 * @param {string} key 
 * @param {MetaConstructor<T>} type
 * @param {Object} [option]
 * @param {string} [option.name]
-* @param {(instance: T) => void} [option.onInit]
+* @param {(instance: C) => void} [option.onInit]
 * @param {(metaOptions: GenericMetaOptions) => T} [option.onDefault]
 * @param {String} [option.typeName]
 */
-function defineGrafanaObject(cls, key, type, option) {
-	const metaClassInfo = getMetaClassInfo(cls);
+function defineObject(cls, key, type, option) {
 	const name = option?.name ? option.name : key;
 	const caseName = name.charAt(0).toUpperCase() + name.slice(1);
 	const typeName = option?.typeName ? option.typeName : type.name;
-	if (metaClassInfo.typeNamesToInclude.includes(type.name) === false) {
-		if ([
-			"String",
-			"Number",
-			"Boolean",
-			"Array",
-			"Object"
-		].indexOf(type.name) === -1) metaClassInfo.typeNamesToInclude.push(type.name);
-	}
-	const setName = `set${caseName}`;
-	if (hasPrototype(cls, setName) === false) {
-		setPrototype(
-			cls,
-			setName,
-			/**
-			* @this GrafanaItem
-			* @param {T} value
-			* @returns {GrafanaItem}
-			*/
-			function(value) {
-				return this._setGrafanaObject(key, type, value);
-			}
-		);
-		metaClassInfo.methods.push(`${setName}(${name}: ${typeName}): this;`);
-	}
-	const setNewName = `setNew${caseName}`;
-	if (hasPrototype(cls, setNewName) === false) {
-		setPrototype(
-			cls,
-			setNewName,
-			/**
-			* @this GrafanaItem
-			* @param {(item: T) => T} [onNewCreated]
-			* @returns {GrafanaItem}
-			*/
-			function(onNewCreated) {
-				if (!onNewCreated) onNewCreated = (item) => item;
-				return this._setGrafanaObject(key, type, onNewCreated(new type(this.metaOptions)));
-			}
-		);
-		metaClassInfo.methods.push(`${setNewName}(onNewCreated: ((item: ${typeName}) => ${typeName}) | undefined): this;`);
-	}
-	setPrototype(
+	addTypeNameToInclude(cls, type.name);
+	setPrototypeWithSignature(
+		cls,
+		`set${caseName}`,
+		`(${name}: ${typeName}): this;`,
+		/**
+		* @this C
+		* @param {T} value
+		* @returns {C}
+		*/
+		function(value) {
+			return this._setGrafanaObject(key, type, value);
+		}
+	);
+	setPrototypeWithSignature(
+		cls,
+		`setNew${caseName}`,
+		`(onNewCreated: ((item: ${typeName}) => ${typeName}) | undefined): this;`,
+		/**
+		* @this C
+		* @param {(item: T) => T} [onNewCreated]
+		* @returns {C}
+		*/
+		function(onNewCreated) {
+			if (!onNewCreated) onNewCreated = (item) => item;
+			return this._setGrafanaObject(key, type, onNewCreated(new type(this.metaOptions)));
+		}
+	);
+	setPrototypeWithSignature(
 		cls,
 		`with${caseName}`,
+		`(onWith: (item: ${typeName}) => void): this;`,
 		/**
-		* @this GrafanaItem
+		* @this C
 		* @param {(item: T) => void} onWith
-		* @returns {GrafanaItem}
+		* @returns {C}
 		*/
 		function(onWith) {
 			const item = this._getGrafanaObject(key, type);
@@ -325,101 +429,79 @@ function defineGrafanaObject(cls, key, type, option) {
 			return this;
 		}
 	);
-	metaClassInfo.methods.push(`with${caseName}(onWith: (item: ${typeName}) => void): this;`);
-	setGetter(cls, name, (self) => self._getGrafanaObject(key, type));
-	metaClassInfo.methods.push(`get ${name}(): ${typeName};`);
-	if (option?.onInit) metaClassInfo.onInits.push(option?.onInit);
-	if (option?.onDefault) {
-		/**
-		* @param {GrafanaItem} instance
-		*/
-		const onInit = (instance) => {
-			const x = option?.onDefault?.(instance.metaOptions);
-			instance._setGrafanaObject(key, type, x);
-		};
-		metaClassInfo.onInits.push(onInit);
-	}
+	setGetterWithSignature(cls, name, (self) => self._getGrafanaObject(key, type), typeName);
+	addOnInit(cls, option?.onInit);
+	if (option?.onDefault) addOnInit(cls, (instance) => {
+		const x = option?.onDefault?.(instance.metaOptions);
+		instance._setGrafanaObject(key, type, x);
+	});
 }
 /**
-* @param {typeof GrafanaItem} cls 
-* @param {string} key 
-* @param {Function} type 
+* @template {GrafanaItem} C
+* @template {GrafanaItem} T
+* @param {MetaConstructor<C>} cls
+* @param {string} key
+* @param {MetaConstructor<T>} type
 * @param {Object} [option]
 * @param {string} [option.name]
 * @param {string} [option.itemName]
 * @param {boolean} [option.setEmpty]
-* @param {(instance: GrafanaItem) => void} [option.onInit]
-* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+* @param {(instance: C) => void} [option.onInit]
+* @param {(metaOptions: GenericMetaOptions) => T[]} [option.onDefault]
 */
 function defineArray(cls, key, type, option) {
-	const metaClassInfo = getMetaClassInfo(cls);
 	const name = option?.name ? option.name : key;
 	const caseName = name.charAt(0).toUpperCase() + name.slice(1);
 	const itemName = option?.itemName ? option.itemName : name.endsWith("s") ? name.slice(0, -1) : `${name}Item`;
-	if (metaClassInfo.typeNamesToInclude.includes(type.name) === false) {
-		if (type.name !== "String" && type.name !== "Number" && type.name !== "Boolean") metaClassInfo.typeNamesToInclude.push(type.name);
-	}
 	const caseItemName = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-	const initName = `init${caseName}`;
-	if (hasPrototype(cls, initName) === false) {
-		setPrototype(
-			cls,
-			initName,
-			/**
-			* @this GrafanaItem
-			* @returns {GrafanaItem}
-			*/
-			function() {
-				return this._initArray(key);
-			}
-		);
-		metaClassInfo.methods.push(`init${caseName}(): this;`);
-	}
-	setGetter(cls, name, (self) => self._getArray(key));
-	metaClassInfo.methods.push(`get ${name}(): ${type.name}[];`);
-	const addName = `add${caseItemName}`;
-	if (hasPrototype(cls, addName) === false) {
-		setPrototype(
-			cls,
-			addName,
-			/**
-			* @this GrafanaItem
-			* @template T
-			* @param {T} item
-			* @returns {GrafanaItem}
-			*/
-			function(item) {
-				return this._addArrayItem(key, item);
-			}
-		);
-		metaClassInfo.methods.push(`${addName}(${itemName}: ${type.name}): this;`);
-	}
-	const addNewName = `addNew${caseItemName}`;
-	if (hasPrototype(cls, addNewName) === false) {
-		setPrototype(
-			cls,
-			addNewName,
-			/**
-			* @this GrafanaItem
-			* @template T
-			* @param {(item: T) => T} onNewCreated
-			* @returns {GrafanaItem}
-			*/
-			function(onNewCreated) {
-				return this._addArrayItem(key, onNewCreated(new type(this.metaOptions)));
-			}
-		);
-		metaClassInfo.methods.push(`${addNewName}(onNewCreated: (item: ${type.name}) => ${type.name}): this;`);
-	}
-	const withName = `with${caseName}`;
-	setPrototype(
+	addTypeNameToInclude(cls, type.name);
+	setPrototypeWithSignature(
 		cls,
-		withName,
+		`init${caseName}`,
+		`(): this;`,
 		/**
-		* @this GrafanaItem
-		* @template T
+		* @this C
+		* @returns {C}
+		*/
+		function() {
+			return this._initArray(key);
+		}
+	);
+	setGetterWithSignature(cls, name, (self) => self._getArray(key), `${type.name}[]`);
+	setPrototypeWithSignature(
+		cls,
+		`add${caseItemName}`,
+		`(${itemName}: ${type.name}): this;`,
+		/**
+		* @this C
+		* @param {T} item
+		* @returns {C}
+		*/
+		function(item) {
+			return this._addArrayItem(key, item);
+		}
+	);
+	setPrototypeWithSignature(
+		cls,
+		`addNew${caseItemName}`,
+		`(onNewCreated: (item: ${type.name}) => ${type.name}): this;`,
+		/**
+		* @this C
+		* @param {(item: T) => T} onNewCreated
+		* @returns {C}
+		*/
+		function(onNewCreated) {
+			return this._addArrayItem(key, onNewCreated(new type(this.metaOptions)));
+		}
+	);
+	setPrototypeWithSignature(
+		cls,
+		`with${caseName}`,
+		`(onWith: (${name}: ${type.name}[]) => void): this;`,
+		/**
+		* @this C
 		* @param {(array: T[]) => void} onWith
-		* @returns {GrafanaItem}
+		* @returns {C}
 		*/
 		function(onWith) {
 			const array = this._getArray(key);
@@ -427,97 +509,174 @@ function defineArray(cls, key, type, option) {
 			return this;
 		}
 	);
-	metaClassInfo.methods.push(`${withName}(onWith: (${name}: ${type.name}[]) => void): this;`);
-	if (option?.onInit) metaClassInfo.onInits.push(option.onInit);
-	if (option?.setEmpty) {
-		/**
-		* @param {GrafanaItem} instance
-		*/
-		const onInitArray = (instance) => {
-			instance._initArray(key);
-		};
-		metaClassInfo.onInits.push(onInitArray);
-	}
+	addOnInit(cls, option?.onInit);
+	if (option?.onDefault) addOnInit(cls, (instance) => option.onDefault?.(instance.metaOptions)?.forEach((item) => instance._addArrayItem(key, item)));
+	if (option?.setEmpty) addOnInit(cls, (instance) => instance._initArray(key));
 }
 /**
-* @template {typeof GrafanaItem} T
-* @param {typeof GrafanaItem} cls 
-* @param {string|undefined} method
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} key 
+* @param {Function} type 
 * @param {Object} [option]
-* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
 * @param {string} [option.name]
-* @param {Function} [option.code]
-* @param {(instance: GrafanaItem) => void} [option.constr]
-* @param {string} [option.getterSetterType]
-* @param {(self: GrafanaItem) => any} [option.getter]
-* @param {(self: GrafanaItem, value: any) => void} [option.setter]
-*/
-function defineMemberInternal(cls, method, option) {
-	const { typesToInclude, name, code, constr, getterSetterType, getter, setter } = option || {};
-	const metaClassInfo = getMetaClassInfo(cls);
-	if (method !== void 0) metaClassInfo.methods.push(method);
-	if (typesToInclude !== void 0) {
-		for (const type of typesToInclude) if (metaClassInfo.typeNamesToInclude.includes(type.name) === false) metaClassInfo.typeNamesToInclude.push(type.name);
-	}
-	let codeCount = 0;
-	if (code !== void 0) codeCount++;
-	if (constr !== void 0) codeCount++;
-	if (getter !== void 0 || setter !== void 0) codeCount++;
-	if (codeCount > 1) throw new Error(`You can only provide either code or constructor or getter/setter, not all. (codeCount:${codeCount})`);
-	if (code !== void 0 && name === void 0) throw new Error("You must provide a name when providing code.");
-	if (constr !== void 0 && name !== void 0) throw new Error("You cannot provide a name when providing constructor.");
-	if ((getter !== void 0 || setter !== void 0) && name === void 0) throw new Error("You must provide a name when providing getter or setter.");
-	if (codeCount == 1) {
-		if (code !== void 0) {
-			if (!name) throw new Error("You must provide a name when providing code.");
-			setPrototype(
-				cls,
-				name,
-				/**
-				* @this {GrafanaItem}
-				* @param  {...any} args
-				* @returns {any}
-				*/
-				function(...args) {
-					return code(this, ...args);
-				}
-			);
-		}
-		if (constr !== void 0) metaClassInfo.onInits.push((instance) => constr(instance));
-		if (getter !== void 0 && setter === void 0) {
-			if (!name) throw new Error("You must provide a name when providing getter or setter.");
-			setGetter(cls, name, getter);
-			metaClassInfo.methods.push(`get ${name}(): ${getterSetterType};`);
+* @param {string} [option.itemName]
+* @param {boolean} [option.setEmpty]
+* @param {(instance: C) => void} [option.onInit]
+* @param {(metaOptions: GenericMetaOptions) => Object[]} [option.onDefault]
+*/
+function defineBasicArray(cls, key, type, option) {
+	const name = option?.name ? option.name : key;
+	const caseName = name.charAt(0).toUpperCase() + name.slice(1);
+	const itemName = option?.itemName ? option.itemName : name.endsWith("s") ? name.slice(0, -1) : `${name}Item`;
+	const caseItemName = itemName.charAt(0).toUpperCase() + itemName.slice(1);
+	addTypeNameToInclude(cls, type.name);
+	setPrototypeWithSignature(
+		cls,
+		`init${caseName}`,
+		`(): this;`,
+		/**
+		* @this C
+		* @returns {C}
+		*/
+		function() {
+			return this._initArray(key);
 		}
-		if (getter === void 0 && setter !== void 0) {
-			if (!name) throw new Error("You must provide a name when providing getter or setter.");
-			setSetter(cls, name, setter);
-			metaClassInfo.methods.push(`set ${name}(value: ${getterSetterType});`);
+	);
+	setGetterWithSignature(cls, name, (self) => self._getArray(key), `${type.name}[]`);
+	setPrototypeWithSignature(
+		cls,
+		`add${caseItemName}`,
+		`(${itemName}: ${type.name}): this;`,
+		/**
+		* @this C
+		* @template T
+		* @param {T} item
+		* @returns {C}
+		*/
+		function(item) {
+			return this._addArrayItem(key, item);
 		}
-		if (getter !== void 0 && setter !== void 0) {
-			if (!name) throw new Error("You must provide a name when providing getter or setter.");
-			setGetterAndSetter(cls, name, getter, setter);
-			metaClassInfo.methods.push(`get ${name}(): ${getterSetterType};`);
-			metaClassInfo.methods.push(`set ${name}(value: ${getterSetterType});`);
+	);
+	setPrototypeWithSignature(
+		cls,
+		`with${caseName}`,
+		`(onWith: (${name}: ${type.name}[]) => void): this;`,
+		/**
+		* @this C
+		* @template T
+		* @param {(array: T[]) => void} onWith
+		* @returns {C}
+		*/
+		function(onWith) {
+			const array = this._getArray(key);
+			if (array) onWith(array);
+			return this;
 		}
-	}
+	);
+	addOnInit(cls, option?.onInit);
+	if (option?.onDefault) addOnInit(cls, (instance) => option.onDefault?.(instance.metaOptions)?.forEach((item) => instance._addArrayItem(key, item)));
+	if (option?.setEmpty) addOnInit(cls, (instance) => instance._initArray(key));
 }
 /**
-* @param {typeof GrafanaItem} cls 
-* @param {(instance: GrafanaItem) => void} code
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {(instance: C) => void} code
 */
 function defineConstructor(cls, code) {
-	defineMemberInternal(cls, "constructor(metaOptions: GenericMetaOptions)", { constr: code });
+	addSignature(cls, "constructor(metaOptions: GenericMetaOptions)");
+	addOnInit(cls, (instance) => code(instance));
+}
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} method
+* @param {Object} [option]
+* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
+*/
+function defineMember(cls, method, option) {
+	const { typesToInclude } = option || {};
+	addSignature(cls, method);
+	addTypesToInclude(cls, typesToInclude);
 }
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} name
+* @param {string} args
+* @param {Object} option
+* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
+* @param {(instance: C, ...args: any[]) => any} option.code
+*/
+var defineMethod = (cls, name, args, option) => {
+	const { typesToInclude, code } = option || {};
+	addTypesToInclude(cls, typesToInclude);
+	setPrototypeWithSignature(
+		cls,
+		name,
+		args,
+		/**
+		* @this {C}
+		* @param  {...any} args
+		* @returns {any}
+		*/
+		function(...args) {
+			return code(this, ...args);
+		}
+	);
+};
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+* @param {string} name
+* @param {string} typeName
+* @param {Object} option
+* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
+* @param {(self: C) => any} [option.getter]
+* @param {(self: C, value: any) => void} [option.setter]
+*/
+function defineGetterSetter(cls, name, typeName, option) {
+	const { typesToInclude, getter, setter } = option || {};
+	addTypesToInclude(cls, typesToInclude);
+	if (getter !== void 0) {
+		if (setter !== void 0) setGetterAndSetterWithSignature(cls, name, getter, setter, typeName);
+		else setGetterWithSignature(cls, name, getter, typeName);
+	} else if (setter !== void 0) setSetterWithSignature(cls, name, setter, typeName);
+	else throw new Error("You must provide either a getter or a setter.");
+}
+//#endregion
+//#region src/utils/GrafanaItemClassBuilder.js
+/**
+* @typedef {import("@gdacm/base-types").GenericMetaOptions} GenericMetaOptions
+*/
+/**
+* @template {Object} T
+* @template {T} C
+* @typedef {import("./MetaClassRegistry.js").MetaClassInfo<T,C>} MetaClassInfo
+*/
+/**
+* @template T
+* @typedef {import("@gdacm/base-types").MetaConstructor<T>} MetaConstructor
+*/
+/**
+* @template {GrafanaItem} C
+*/
 var GrafanaItemClassBuilder = class {
 	/**
-	* @param {typeof GrafanaItem} cls
+	* @param {MetaConstructor<C>} cls
 	*/
 	constructor(cls) {
-		this.cls = cls;
+		/** @type {MetaConstructor<C>} */
+		this._cls = cls;
+	}
+	/**
+	* @return {MetaConstructor<C>}
+	*/
+	get cls() {
+		return this._cls;
 	}
 	/**
-	* @param {typeof GrafanaItem} parent
+	* @param {MetaConstructor<GrafanaItem>} parent
 	* @returns 
 	*/
 	setParent(parent) {
@@ -529,8 +688,8 @@ var GrafanaItemClassBuilder = class {
 	* @param {Function} type
 	* @param {Object} [option]
 	* @param {string} [option.name]
-	* @param {(instance: InstanceType<typeof GrafanaItem>) => void} [option.onInit]
-	* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+	* @param {(instance: C) => void} [option.onInit]
+	* @param {(metaOptions: GenericMetaOptions) => C} [option.onDefault]
 	* @param {String} [option.typeName]
 	* @return {this}
 	*/
@@ -539,13 +698,15 @@ var GrafanaItemClassBuilder = class {
 		return this;
 	}
 	/**
+	* @template {GrafanaItem} T
 	* @param {string} key 
-	* @param {Function} type 
+	* @param {MetaConstructor<T>} type 
 	* @param {Object} [option]
 	* @param {string} [option.name]
-	* @param {(instance: GrafanaItem) => void} [option.onInit]
-	* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+	* @param {(instance: C) => void} [option.onInit]
+	* @param {(metaOptions: GenericMetaOptions) => T} [option.onDefault]
 	* @param {String} [option.typeName]
+	* @param {String} [option.setNew]
 	* @return {this}
 	*/
 	defineObject(key, type, option) {
@@ -553,30 +714,29 @@ var GrafanaItemClassBuilder = class {
 		return this;
 	}
 	/**
-	* @template {GrafanaItem} T
 	* @param {string} key 
-	* @param {MetaConstructor<T>} type 
+	* @param {Function} type 
 	* @param {Object} [option]
 	* @param {string} [option.name]
-	* @param {(instance: T) => void} [option.onInit]
-	* @param {(metaOptions: GenericMetaOptions) => T} [option.onDefault]
+	* @param {(instance: C) => void} [option.onInit]
+	* @param {(metaOptions: GenericMetaOptions) => Object} [option.onDefault]
 	* @param {String} [option.typeName]
-	* @param {String} [option.setNew]
 	* @return {this}
 	*/
-	defineGrafanaObject(key, type, option) {
-		defineGrafanaObject(this.cls, key, type, option);
+	defineBasicObject(key, type, option) {
+		defineBasicObject(this.cls, key, type, option);
 		return this;
 	}
 	/**
+	* @template {GrafanaItem} T
 	* @param {string} key 
-	* @param {Function} type 
+	* @param {MetaConstructor<T>} type 
 	* @param {Object} [option]
 	* @param {string} [option.name]
 	* @param {string} [option.itemName]
 	* @param {boolean} [option.setEmpty]
-	* @param {(instance: GrafanaItem) => void} [option.onInit]
-	* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+	* @param {(instance: C) => void} [option.onInit]
+	* @param {(metaOptions: GenericMetaOptions) => T[]} [option.onDefault]
 	* @return {this}
 	*/
 	defineArray(key, type, option) {
@@ -584,18 +744,32 @@ var GrafanaItemClassBuilder = class {
 		return this;
 	}
 	/**
+	* @param {string} key 
+	* @param {Function} type 
+	* @param {Object} [option]
+	* @param {string} [option.name]
+	* @param {string} [option.itemName]
+	* @param {boolean} [option.setEmpty]
+	* @param {(instance: C) => void} [option.onInit]
+	* @param {(metaOptions: GenericMetaOptions) => Object[]} [option.onDefault]
+	* @return {this}
+	*/
+	defineBasicArray(key, type, option) {
+		defineBasicArray(this.cls, key, type, option);
+		return this;
+	}
+	/**
 	* @param {string} method
 	* @param {Object} [option]
 	* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
 	* @return {this}
 	*/
 	defineMember(method, option) {
-		defineMemberInternal(this.cls, method, option);
+		defineMember(this.cls, method, option);
 		return this;
 	}
 	/**
-	* @template {typeof GrafanaItem} T
-	* @param {(instance: InstanceType<T>) => void} code
+	* @param {(instance: C) => void} code
 	* @return {this}
 	*/
 	defineConstructor(code) {
@@ -607,36 +781,24 @@ var GrafanaItemClassBuilder = class {
 	* @param {string} args
 	* @param {Object} option
 	* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
-	* @param {Function} option.code
+	* @param {(instance: C, ...args: any[]) => any} option.code
 	* @return {this}
 	*/
 	defineMethod(name, args, option) {
-		defineMemberInternal(this.cls, `${name}${args}`, {
-			...option,
-			name
-		});
+		defineMethod(this.cls, name, args, option);
 		return this;
 	}
 	/**
-	* @template {typeof GrafanaItem} T
 	* @param {string} name
-	* @param {string} type
+	* @param {string} typeName
 	* @param {Object} option
 	* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
-	* @param {(instance: InstanceType<T>) => any} [option.getter]
-	* @param {(instance: InstanceType<T>, value: any) => void} [option.setter]
+	* @param {(instance: C) => any} [option.getter]
+	* @param {(instance: C, value: any) => void} [option.setter]
 	* @return {this}
 	*/
-	defineGetterSetter(name, type, option) {
-		const getter = option.getter;
-		const setter = option.setter;
-		defineMemberInternal(this.cls, void 0, {
-			...option,
-			getter,
-			setter,
-			name,
-			getterSetterType: type
-		});
+	defineGetterSetter(name, typeName, option) {
+		defineGetterSetter(this.cls, name, typeName, option);
 		return this;
 	}
 	/**
@@ -654,15 +816,43 @@ var GrafanaItemClassBuilder = class {
 	}
 };
 /**
+* @template {GrafanaItem} C
 * @param {string} name
 * @param {typeof GrafanaItem} parent
-* @returns {GrafanaItemClassBuilder}
+* @returns {GrafanaItemClassBuilder<C>}
 */
 var defineGrafanaItemClass = (name, parent) => {
 	const cls = class extends parent {};
 	Object.defineProperty(cls, "name", { value: name });
 	return defineClass(cls).setParent(parent);
 };
+/**
+* @template {GrafanaItem} C
+* @param {MetaConstructor<C>} cls 
+*/
+function defineClass(cls) {
+	if (!hasType(cls)) {
+		/** @type {Function|undefined} */
+		let parent = Object.getPrototypeOf(cls);
+		if (parent && !parent.name) parent = void 0;
+		/** @type {((instance: C)=>void)[]} */
+		let onInitsParent = [];
+		if (parent && parent.name) onInitsParent = getMetaClassInfo(parent).onInits;
+		/** @type {MetaClassInfo<GrafanaItem,C>} */
+		const metaClassInfo = {
+			methods: [],
+			onInits: [...onInitsParent],
+			parentName: parent?.name,
+			parent,
+			typeNamesToInclude: []
+		};
+		cls.prototype._onInit = function() {
+			for (const onInit of metaClassInfo.onInits) onInit(this);
+		};
+		setTypeMetaClassInfo(cls, metaClassInfo);
+	}
+	return new GrafanaItemClassBuilder(cls);
+}
 //#endregion
 //#region src/items/GrafanaItem.js
 var GrafanaItem = class {
@@ -823,10 +1013,10 @@ var GrafanaItem = class {
 defineClass(GrafanaItem).defineMember("constructor(metaOptions: GenericMetaOptions)").defineMember("get metaOptions(): GenericMetaOptions").defineMember("withMetaOptions(code: (metaOptions: GenericMetaOptions) => void): this").defineMember("with(code: (item: this) => void): this").defineMember("asJson(): Object;").defineMember("_onInit(): void;").defineMember("_setValue<T>(key: string, value: T): this;").defineMember("_getValue<T>(key: string): T;").defineMember("_initArray(key: string): this;").defineMember("_getArray<T>(key: string): T[];").defineMember("_addArrayItem<T>(key: string, item: T): this;").defineMember("_setObject<T>(key: string, value: T): this;").defineMember("_getObject<T>(key: string): T;").defineMember("_withObject<T>(key: string, code: (item: T) => void): this;").defineMember("_setGrafanaObject<T extends GrafanaItem>(key: string, type: new (metaOptions: GenericMetaOptions) => T, value: T | undefined): this;").defineMember("_getGrafanaObject<T extends GrafanaItem>(key: string, type: new (metaOptions: GenericMetaOptions) => T): T;").defineMember("_withGrafanaObject<T extends GrafanaItem>(key: string, type: new (metaOptions: GenericMetaOptions) => T, code: (item: T) => void): this;");
 //#endregion
 //#region src/items/OverrideMatcher.js
-var OverrideMatcher = defineGrafanaItemClass("OverrideMatcher", GrafanaItem).defineValue("id", String).defineObject("options", Object).asClass;
+var OverrideMatcher = defineGrafanaItemClass("OverrideMatcher", GrafanaItem).defineValue("id", String).defineBasicObject("options", Object).asClass;
 //#endregion
 //#region src/items/OverrideMatcherOptionsByNames.js
-var OverrideMatcherOptionsByNames = defineGrafanaItemClass("OverrideMatcherOptionsByNames", GrafanaItem).defineValue("mode", String).defineArray("names", String).defineValue("prefix", String).defineValue("readOnly", Boolean).asClass;
+var OverrideMatcherOptionsByNames = defineGrafanaItemClass("OverrideMatcherOptionsByNames", GrafanaItem).defineValue("mode", String).defineBasicArray("names", String).defineValue("prefix", String).defineValue("readOnly", Boolean).asClass;
 //#endregion
 //#region src/items/OverrideProperty.js
 var OverrideProperty = defineGrafanaItemClass("OverrideProperty", GrafanaItem).defineValue("id", String).defineValue("value", Object).asClass;
@@ -835,7 +1025,7 @@ var OverrideProperty = defineGrafanaItemClass("OverrideProperty", GrafanaItem).d
 var Datasource = defineGrafanaItemClass("Datasource", GrafanaItem).defineValue("type", String).defineValue("uid", String).asClass;
 //#endregion
 //#region src/items/Annotation.js
-var Annotation = defineGrafanaItemClass("Annotation", GrafanaItem).defineValue("builtIn", Number).defineGrafanaObject("datasource", Datasource).defineValue("enable", Boolean).defineValue("hide", Boolean).defineValue("iconColor", String).defineValue("name", String).defineValue("type", String).asClass;
+var Annotation = defineGrafanaItemClass("Annotation", GrafanaItem).defineValue("builtIn", Number).defineObject("datasource", Datasource).defineValue("enable", Boolean).defineValue("hide", Boolean).defineValue("iconColor", String).defineValue("name", String).defineValue("type", String).asClass;
 //#endregion
 //#region src/items/Annotations.js
 var Annotations = defineGrafanaItemClass("Annotations", GrafanaItem).defineArray("list", Annotation, { itemName: "annotation" }).asClass;
@@ -898,7 +1088,7 @@ code: (thresholds, value, color) => {
 } }).asClass;
 //#endregion
 //#region src/items/FieldConfigDefault.js
-var FieldConfigDefault = defineGrafanaItemClass("FieldConfigDefault", GrafanaItem).defineGrafanaObject("color", Color).defineGrafanaObject("custom", FieldConfigCustom).defineValue("decimals", Number).defineValue("fieldMinMax", Boolean).defineArray("mappings", Mapping).defineValue("max", Number).defineValue("min", Number).defineGrafanaObject("thresholds", Thresholds).defineValue("unit", String).defineMethod("setColorMode", "(mode: string): this;", { 
+var FieldConfigDefault = defineGrafanaItemClass("FieldConfigDefault", GrafanaItem).defineObject("color", Color).defineObject("custom", FieldConfigCustom).defineValue("decimals", Number).defineValue("fieldMinMax", Boolean).defineArray("mappings", Mapping).defineValue("max", Number).defineValue("min", Number).defineObject("thresholds", Thresholds).defineValue("unit", String).defineMethod("setColorMode", "(mode: string): this;", { 
 /**
 * @param {FieldConfigDefault} fieldConfigDefault
 * @param {String} mode
@@ -911,13 +1101,13 @@ code: (fieldConfigDefault, mode) => {
 } }).asClass;
 //#endregion
 //#region src/items/FieldConfigOverride.js
-var FieldConfigOverride = defineGrafanaItemClass("FieldConfigOverride", GrafanaItem).defineValue("__systemRef", String, { name: "systemRef" }).defineGrafanaObject("matcher", OverrideMatcher).defineArray("properties", OverrideProperty, { itemName: "property" }).asClass;
+var FieldConfigOverride = defineGrafanaItemClass("FieldConfigOverride", GrafanaItem).defineValue("__systemRef", String, { name: "systemRef" }).defineObject("matcher", OverrideMatcher).defineArray("properties", OverrideProperty, { itemName: "property" }).asClass;
 //#endregion
 //#region src/items/HideFrom.js
 var HideFrom = defineGrafanaItemClass("HideFrom", GrafanaItem).defineValue("graph", Boolean).defineValue("legend", Boolean).defineValue("tooltip", Boolean).defineValue("viz", Boolean).asClass;
 //#endregion
 //#region src/items/FieldConfig.js
-var FieldConfig = defineGrafanaItemClass("FieldConfig", GrafanaItem).defineGrafanaObject("defaults", FieldConfigDefault).defineArray("overrides", FieldConfigOverride).defineMethod("addNewOverrideHideSeriesFrom", "(names: string[]): this", { 
+var FieldConfig = defineGrafanaItemClass("FieldConfig", GrafanaItem).defineObject("defaults", FieldConfigDefault).defineArray("overrides", FieldConfigOverride).defineMethod("addNewOverrideHideSeriesFrom", "(names: string[]): this", { 
 /**
 * @param {FieldConfig} fieldConfig
 * @param {String[]} names
@@ -933,16 +1123,16 @@ code: (fieldConfig, names) => {
 } }).asClass;
 //#endregion
 //#region src/items/Target.js
-var Target = defineGrafanaItemClass("Target", GrafanaItem).defineValue("alias", String).defineValue("refId", String).defineValue("query", String).defineGrafanaObject("datasource", Datasource).defineValue("seriesCount", Number).defineValue("scenarioId", String).defineValue("stringInput", String).asClass;
+var Target = defineGrafanaItemClass("Target", GrafanaItem).defineValue("alias", String).defineValue("refId", String).defineValue("query", String).defineObject("datasource", Datasource).defineValue("seriesCount", Number).defineValue("scenarioId", String).defineValue("stringInput", String).asClass;
 //#endregion
 //#region src/items/Link.js
-var Link = defineGrafanaItemClass("Link", GrafanaItem).defineConstructor((instance) => instance.setType("link")).defineValue("asDropdown", Boolean).defineValue("icon", String).defineValue("includeVars", Boolean).defineValue("keepTime", Boolean).defineArray("tags", String, { setEmpty: true }).defineValue("targetBlank", Boolean).defineValue("title", String).defineValue("tooltip", String).defineValue("type", String).defineValue("url", String).asClass;
+var Link = defineGrafanaItemClass("Link", GrafanaItem).defineConstructor((instance) => instance.setType("link")).defineValue("asDropdown", Boolean).defineValue("icon", String).defineValue("includeVars", Boolean).defineValue("keepTime", Boolean).defineBasicArray("tags", String, { setEmpty: true }).defineValue("targetBlank", Boolean).defineValue("title", String).defineValue("tooltip", String).defineValue("type", String).defineValue("url", String).asClass;
 //#endregion
 //#region src/items/DataTransformation.js
 var DataTransformation = defineGrafanaItemClass("DataTransformation", GrafanaItem).asClass;
 //#endregion
 //#region src/items/Panel.js
-var Panel = defineGrafanaItemClass("Panel", GrafanaItem).defineValue("cacheTimeout", String).defineGrafanaObject("datasource", Datasource, { onDefault: (options) => void 0 }).defineValue("description", String).defineGrafanaObject("fieldConfig", FieldConfig, { onDefault: (options) => new FieldConfig(options) }).defineGrafanaObject("gridPos", GridPos).defineMethod("setPos", "(x: number, y: number, w: number, h: number): this;", { 
+var Panel = defineGrafanaItemClass("Panel", GrafanaItem).defineValue("cacheTimeout", String).defineObject("datasource", Datasource, { onDefault: (options) => void 0 }).defineValue("description", String).defineObject("fieldConfig", FieldConfig, { onDefault: (options) => new FieldConfig(options) }).defineObject("gridPos", GridPos).defineMethod("setPos", "(x: number, y: number, w: number, h: number): this;", { 
 /**
 * @param {Panel} panel
 * @param {number} x
@@ -952,7 +1142,7 @@ var Panel = defineGrafanaItemClass("Panel", GrafanaItem).defineValue("cacheTimeo
 */
 code: (panel, x, y, w, h) => {
 	return panel.setNewGridPos((gridPos) => gridPos.setPos(x, y, w, h));
-} }).defineValue("hideTimeOverride", Boolean).defineValue("id", Number).defineValue("interval", String).defineArray("links", Link).defineValue("maxDataPoints", Number).defineValue("maxPerRow", Number).defineGrafanaObject("options", Object).defineValue("pluginVersion", String).defineValue("queryCachingTTL", Number).defineValue("repeat", String).defineValue("repeatDirection", String).defineArray("targets", Target).defineMethod("addTargetWithParams", "(refId: string, query: string, datasource: Datasource): this;", { 
+} }).defineValue("hideTimeOverride", Boolean).defineValue("id", Number).defineValue("interval", String).defineArray("links", Link).defineValue("maxDataPoints", Number).defineValue("maxPerRow", Number).defineObject("options", Object).defineValue("pluginVersion", String).defineValue("queryCachingTTL", Number).defineValue("repeat", String).defineValue("repeatDirection", String).defineArray("targets", Target).defineMethod("addTargetWithParams", "(refId: string, query: string, datasource: Datasource): this;", { 
 /**
 * @param {Panel} panel
 * @param {string} refId
@@ -970,13 +1160,13 @@ var TemplateCurrent = defineGrafanaItemClass("TemplateCurrent", GrafanaItem).def
 var TemplateOption = defineGrafanaItemClass("TemplateOption", GrafanaItem).defineValue("selected", Boolean).defineValue("text", String).defineValue("value", String).asClass;
 //#endregion
 //#region src/items/Template.js
-var Template = defineGrafanaItemClass("Template", GrafanaItem).defineGrafanaObject("current", TemplateCurrent).defineValue("definition", String).defineValue("description", String).defineValue("hide", Number).defineValue("label", String).defineValue("multi", Boolean).defineValue("name", String).defineArray("options", TemplateOption).defineValue("query", Object).defineValue("refresh", Number).defineValue("regex", String).defineValue("sort", Number).defineValue("type", String).defineValue("useTags", Boolean).asClass;
+var Template = defineGrafanaItemClass("Template", GrafanaItem).defineObject("current", TemplateCurrent).defineValue("definition", String).defineValue("description", String).defineValue("hide", Number).defineValue("label", String).defineValue("multi", Boolean).defineValue("name", String).defineArray("options", TemplateOption).defineValue("query", Object).defineValue("refresh", Number).defineValue("regex", String).defineValue("sort", Number).defineValue("type", String).defineValue("useTags", Boolean).asClass;
 //#endregion
 //#region src/items/Templating.js
 var Templating = defineGrafanaItemClass("Templating", GrafanaItem).defineArray("list", Template, { itemName: "template" }).asClass;
 //#endregion
 //#region src/items/TimePicker.js
-var TimePicker = defineGrafanaItemClass("TimePicker", GrafanaItem).defineArray("refresh_intervals", String, { itemName: "refreshInterval" }).asClass;
+var TimePicker = defineGrafanaItemClass("TimePicker", GrafanaItem).defineBasicArray("refresh_intervals", String, { itemName: "refreshInterval" }).asClass;
 //#endregion
 //#region src/torefactor/index.js
 /**
@@ -989,7 +1179,7 @@ var TimePicker = defineGrafanaItemClass("TimePicker", GrafanaItem).defineArray("
 var getAnnotations = (options) => new Annotations(options).addNewAnnotation((annotation) => annotation.setBuiltIn(1).setNewDatasource((datasource) => datasource.setType("grafana").setUid("-- Grafana --")).setEnable(true).setHide(true).setIconColor("rgba(0, 211, 255, 1)").setName("Annotations & Alerts").setType("dashboard"));
 //#endregion
 //#region src/items/Dashboard.js
-var Dashboard = defineGrafanaItemClass("Dashboard", GrafanaItem).setParent(GrafanaItem).defineGrafanaObject("annotations", Annotations, { onDefault: (options) => getAnnotations(options) }).defineValue("editable", Boolean).defineValue("fiscalYearStartMonth", Number).defineValue("graphTooltip", Number).defineArray("links", Link, { itemName: "link" }).defineValue("liveNow", Boolean).defineMethod("addPanel", "(panel: Panel): this;", { 
+var Dashboard = defineGrafanaItemClass("Dashboard", GrafanaItem).setParent(GrafanaItem).defineObject("annotations", Annotations, { onDefault: (options) => getAnnotations(options) }).defineValue("editable", Boolean).defineValue("fiscalYearStartMonth", Number).defineValue("graphTooltip", Number).defineArray("links", Link, { itemName: "link" }).defineValue("liveNow", Boolean).defineArray("panels", Panel, { itemName: "panel" }).defineMethod("addPanel", "(panel: Panel): this;", { 
 /**
 * @param {Dashboard} dashboard
 * @param {Panel} panel
@@ -1003,10 +1193,10 @@ code: (dashboard, panel) => {
 	}, 0);
 	panel._setValue("id", max + 1);
 	return dashboard._addArrayItem("panels", panel);
-} }).defineArray("panels", Panel, { itemName: "panel" }).defineValue("preload", Boolean).defineValue("schemaVersion", Number).defineValue("refresh", String).defineValue("tags", Array, {
+} }).defineValue("preload", Boolean).defineValue("schemaVersion", Number).defineValue("refresh", String).defineValue("tags", Array, {
 	onDefault: (options) => [],
 	typeName: "Array<String>"
-}).defineGrafanaObject("templating", Templating, { onDefault: (options) => new Templating(options) }).defineGrafanaObject("time", TimeRange, { onDefault: (options) => new TimeRange(options).setRange("now-6h", "now") }).defineMethod("setTimeRange", "(from: string, to: string): this;", { 
+}).defineObject("templating", Templating, { onDefault: (options) => new Templating(options) }).defineObject("time", TimeRange, { onDefault: (options) => new TimeRange(options).setRange("now-6h", "now") }).defineMethod("setTimeRange", "(from: string, to: string): this;", { 
 /**
 * @param {Dashboard} dashboard
 * @param {string} from
@@ -1016,21 +1206,21 @@ code: (dashboard, panel) => {
 code: (dashboard, from, to) => {
 	dashboard.time.setRange(from, to);
 	return dashboard;
-} }).defineGrafanaObject("timepicker", TimePicker, { onDefault: (options) => new TimePicker(options) }).defineValue("timezone", String, { onDefault: (options) => "browser" }).defineValue("title", String, { onDefault: (options) => "" }).defineValue("uid", String).asClass;
+} }).defineObject("timepicker", TimePicker, { onDefault: (options) => new TimePicker(options) }).defineValue("timezone", String, { onDefault: (options) => "browser" }).defineValue("title", String, { onDefault: (options) => "" }).defineValue("uid", String).asClass;
 //#endregion
 //#region src/items/properties/datasource.js
 /**
-* @param {GrafanaItemClassBuilder} builder
+* @template {Datasource} T
+* @param {GrafanaItemClassBuilder<T>} builder
 * @param {string} typeName
 * @param {Object} [options]
-* @param {(instance: Datasource) => void} [options.onInit]
+* @param {(instance: T) => void} [options.onInit]
 */
 var defineDatasource = (builder, typeName, options) => {
 	const { onInit } = options ?? {};
 	builder.defineConstructor((instance) => {
-		const self = instance;
-		self.setType(typeName);
-		if (onInit) onInit(self);
+		instance.setType(typeName);
+		if (onInit) onInit(instance);
 	});
 };
 //#endregion
@@ -1042,7 +1232,8 @@ var ScaleDistribution = defineGrafanaItemClass("ScaleDistribution", GrafanaItem)
 //#endregion
 //#region src/items/properties/axisConfig.js
 /**
-* @param {GrafanaItemClassBuilder} builder
+* @template {FieldConfigCustom} T
+* @param {GrafanaItemClassBuilder<T>} builder
 */
 var defineAxisConfig = (builder) => {
 	builder.defineValue("axisBorderShow", Boolean).defineValue("axisCenteredZero", Boolean).defineValue("axisColorMode", String).defineValue("axisGridShow", Boolean).defineValue("axisLabel", String).defineValue("axisPlacement", String).defineValue("axisSoftMax", Number).defineValue("axisSoftMin", Number).defineValue("axisWidth", Number).defineObject("scaleDistribution", ScaleDistribution, { onDefault: (options) => new ScaleDistribution(options).setType("linear") });
@@ -1050,17 +1241,18 @@ var defineAxisConfig = (builder) => {
 //#endregion
 //#region src/items/properties/hideableFieldConfig.js
 /**
-* @param {GrafanaItemClassBuilder} builder
+* @template {FieldConfigCustom} T
+* @param {GrafanaItemClassBuilder<T>} builder
 */
 var defineHideableFieldConfig = (builder) => {
-	builder.defineGrafanaObject("hideFrom", HideFrom, { onDefault: (options) => new HideFrom(options).setLegend(false).setTooltip(false).setViz(false) });
+	builder.defineObject("hideFrom", HideFrom, { onDefault: (options) => new HideFrom(options).setLegend(false).setTooltip(false).setViz(false) });
 };
 //#endregion
 //#region src/items/ThresholdStyle.js
 var ThresholdStyle = defineGrafanaItemClass("ThresholdStyle", GrafanaItem).defineValue("mode", String).asClass;
 //#endregion
 //#region src/items/FieldConfigCustomBarChart.js
-var FieldConfigCustomBarChart = defineGrafanaItemClass("FieldConfigCustomBarChart", FieldConfigCustom).with((builder) => defineAxisConfig(builder)).defineValue("fillOpacity", Number).defineValue("gradientMode", String).with((builder) => defineHideableFieldConfig(builder)).defineValue("lineWidth", Number).defineGrafanaObject("thresholdsStyle", ThresholdStyle, { onDefault: (options) => new ThresholdStyle(options).setMode("off") }).defineMethod("setThresholdsStyleMode", "(mode: string): this;", { 
+var FieldConfigCustomBarChart = defineGrafanaItemClass("FieldConfigCustomBarChart", FieldConfigCustom).with((builder) => defineAxisConfig(builder)).defineValue("fillOpacity", Number).defineValue("gradientMode", String).with((builder) => defineHideableFieldConfig(builder)).defineValue("lineWidth", Number).defineObject("thresholdsStyle", ThresholdStyle, { onDefault: (options) => new ThresholdStyle(options).setMode("off") }).defineMethod("setThresholdsStyleMode", "(mode: string): this;", { 
 /**
 * @param {FieldConfigCustomBarChart} fieldConfigCustomBarChart
 * @param {String} mode
@@ -1075,7 +1267,7 @@ code: (fieldConfigCustomBarChart, mode) => {
 var FieldConfigCustomGauge = defineGrafanaItemClass("FieldConfigCustomGauge", FieldConfigCustom).asClass;
 //#endregion
 //#region src/items/FieldConfigCustomGeomap.js
-var FieldConfigCustomGeomap = defineGrafanaItemClass("FieldConfigCustomGeomap", FieldConfigCustom).defineGrafanaObject("hideFrom", HideFrom, { onDefault: (options) => new HideFrom(options).setLegend(false).setTooltip(false).setViz(false) }).asClass;
+var FieldConfigCustomGeomap = defineGrafanaItemClass("FieldConfigCustomGeomap", FieldConfigCustom).defineObject("hideFrom", HideFrom, { onDefault: (options) => new HideFrom(options).setLegend(false).setTooltip(false).setViz(false) }).asClass;
 //#endregion
 //#region src/items/FieldConfigCustomPieChart.js
 var FieldConfigCustomPieChart = defineGrafanaItemClass("FieldConfigCustomPieChart", FieldConfigCustom).with((builder) => defineHideableFieldConfig(builder)).asClass;
@@ -1087,7 +1279,7 @@ var LineStyle = defineGrafanaItemClass("LineStyle", GrafanaItem).defineValue("fi
 var Stacking = defineGrafanaItemClass("Stacking", GrafanaItem).defineValue("group", String).defineValue("mode", String).asClass;
 //#endregion
 //#region src/items/FieldConfigCustomTimeSerie.js
-var FieldConfigCustomTimeSerie = defineGrafanaItemClass("FieldConfigCustomTimeSerie", FieldConfigCustom).with((builder) => defineAxisConfig(builder)).defineValue("barAlignment", Number).defineValue("barMaxWidth", Number).defineValue("barWidthFactor", Number).defineValue("drawStyle", String).defineValue("fillBelowTo", String).defineValue("fillColor", String).defineValue("fillOpacity", Number).defineValue("gradientMode", String).with((builder) => defineHideableFieldConfig(builder)).defineValue("insertNulls", Boolean).defineValue("lineInterpolation", String).defineGrafanaObject("lineStyle", LineStyle, { onDefault: (options) => new LineStyle(options).setFill("solid") }).defineMethod("setLineStyleFill", "(fill: string): this;", { 
+var FieldConfigCustomTimeSerie = defineGrafanaItemClass("FieldConfigCustomTimeSerie", FieldConfigCustom).with((builder) => defineAxisConfig(builder)).defineValue("barAlignment", Number).defineValue("barMaxWidth", Number).defineValue("barWidthFactor", Number).defineValue("drawStyle", String).defineValue("fillBelowTo", String).defineValue("fillColor", String).defineValue("fillOpacity", Number).defineValue("gradientMode", String).with((builder) => defineHideableFieldConfig(builder)).defineValue("insertNulls", Boolean).defineValue("lineInterpolation", String).defineObject("lineStyle", LineStyle, { onDefault: (options) => new LineStyle(options).setFill("solid") }).defineMethod("setLineStyleFill", "(fill: string): this;", { 
 /**
 * @param {FieldConfigCustomTimeSerie} fieldConfigCustomTimeSerie
 * @param {String} fill
@@ -1096,7 +1288,7 @@ var FieldConfigCustomTimeSerie = defineGrafanaItemClass("FieldConfigCustomTimeSe
 code: (fieldConfigCustomTimeSerie, fill) => {
 	fieldConfigCustomTimeSerie.lineStyle.setFill(fill);
 	return fieldConfigCustomTimeSerie;
-} }).defineValue("lineWidth", Number).defineValue("pointColor", String).defineValue("pointSize", Number).defineValue("pointSymbol", String).defineValue("showPoints", String).defineValue("showValues", Boolean).defineValue("spanNulls", Boolean).defineGrafanaObject("stacking", Stacking, { onDefault: (options) => new Stacking(options).setGroup("A").setMode("none") }).defineGrafanaObject("thresholdsStyle", ThresholdStyle, { onDefault: (options) => new ThresholdStyle(options).setMode("off") }).defineMethod("setThresholdsStyleMode", "(mode: string): this;", { 
+} }).defineValue("lineWidth", Number).defineValue("pointColor", String).defineValue("pointSize", Number).defineValue("pointSymbol", String).defineValue("showPoints", String).defineValue("showValues", Boolean).defineValue("spanNulls", Boolean).defineObject("stacking", Stacking, { onDefault: (options) => new Stacking(options).setGroup("A").setMode("none") }).defineObject("thresholdsStyle", ThresholdStyle, { onDefault: (options) => new ThresholdStyle(options).setMode("off") }).defineMethod("setThresholdsStyleMode", "(mode: string): this;", { 
 /**
 * @param {FieldConfigCustomTimeSerie} fieldConfigCustomTimeSerie
 * @param {String} mode
@@ -1111,10 +1303,10 @@ code: (fieldConfigCustomTimeSerie, mode) => {
 var FieldConfigCustomTableCellOptions = defineGrafanaItemClass("FieldConfigCustomTableCellOptions", GrafanaItem).defineValue("type", String).asClass;
 //#endregion
 //#region src/items/FieldConfigCustomTableFooter.js
-var FieldConfigCustomTableFooter = defineGrafanaItemClass("FieldConfigCustomTableFooter", GrafanaItem).defineArray("reducers", String).asClass;
+var FieldConfigCustomTableFooter = defineGrafanaItemClass("FieldConfigCustomTableFooter", GrafanaItem).defineBasicArray("reducers", String).asClass;
 //#endregion
 //#region src/items/FieldConfigCustomTable.js
-var FieldConfigCustomTable = defineGrafanaItemClass("FieldConfigCustomTable", FieldConfigCustom).defineValue("align", String).defineGrafanaObject("cellOptions", FieldConfigCustomTableCellOptions, { onDefault: (options) => new FieldConfigCustomTableCellOptions(options) }).defineGrafanaObject("footer", FieldConfigCustomTableFooter, { onDefault: (options) => new FieldConfigCustomTableFooter(options) }).defineValue("inspect", Boolean).asClass;
+var FieldConfigCustomTable = defineGrafanaItemClass("FieldConfigCustomTable", FieldConfigCustom).defineValue("align", String).defineObject("cellOptions", FieldConfigCustomTableCellOptions, { onDefault: (options) => new FieldConfigCustomTableCellOptions(options) }).defineObject("footer", FieldConfigCustomTableFooter, { onDefault: (options) => new FieldConfigCustomTableFooter(options) }).defineValue("inspect", Boolean).asClass;
 //#endregion
 //#region src/items/Influxdb.js
 var Influxdb = defineGrafanaItemClass("Influxdb", Datasource).with((builder) => defineDatasource(builder, "influxdb")).asClass;
@@ -1123,7 +1315,7 @@ var Influxdb = defineGrafanaItemClass("Influxdb", Datasource).with((builder) =>
 var PanelOptions = defineGrafanaItemClass("PanelOptions", GrafanaItem).asClass;
 //#endregion
 //#region src/items/VizLegendOptions.js
-var VizLegendOptions = defineGrafanaItemClass("VizLegendOptions", GrafanaItem).defineValue("asTable", Boolean).defineArray("calcs", String).defineValue("displayMode", String).defineValue("isVisible", Boolean).defineValue("limit", Number).defineValue("overflow", String).defineValue("placement", String).defineValue("showLegend", Boolean).defineValue("sortBy", String).defineValue("sortDesc", Boolean).defineValue("width", Number).asClass;
+var VizLegendOptions = defineGrafanaItemClass("VizLegendOptions", GrafanaItem).defineValue("asTable", Boolean).defineBasicArray("calcs", String).defineValue("displayMode", String).defineValue("isVisible", Boolean).defineValue("limit", Number).defineValue("overflow", String).defineValue("placement", String).defineValue("showLegend", Boolean).defineValue("sortBy", String).defineValue("sortDesc", Boolean).defineValue("width", Number).asClass;
 //#endregion
 //#region src/items/VizTooltipOptions.js
 var VizTooltipOptions = defineGrafanaItemClass("VizTooltipOptions", GrafanaItem).defineValue("hideZeros", Boolean).defineValue("maxHeight", Number).defineValue("maxWidth", Number).defineValue("mode", String).defineValue("sort", String).asClass;
@@ -1132,19 +1324,19 @@ var VizTooltipOptions = defineGrafanaItemClass("VizTooltipOptions", GrafanaItem)
 var VizTextDisplayOptions = defineGrafanaItemClass("VizTextDisplayOptions", GrafanaItem).defineValue("percentSize", Number).defineValue("titleSize", Number).defineValue("valueSize", Number).asClass;
 //#endregion
 //#region src/items/PanelOptionsBarChart.js
-var PanelOptionsBarChart = defineGrafanaItemClass("PanelOptionsBarChart", PanelOptions).defineValue("barRadius", Number).defineValue("barWidth", Number).defineValue("colorByField", String).defineValue("fullHighlight", Boolean).defineValue("groupWidth", Number).defineGrafanaObject("legend", VizLegendOptions, { onDefault: (options) => new VizLegendOptions(options).setDisplayMode("list").setPlacement("bottom").setShowLegend(false) }).defineValue("orientation", String).defineValue("showValue", String).defineValue("stacking", String).defineGrafanaObject("text", VizTextDisplayOptions).defineGrafanaObject("tooltip", VizTooltipOptions, { onDefault: (options) => new VizTooltipOptions(options).setHideZeros(false).setMode("single").setSort("none") }).defineValue("xField", String).defineValue("xTickLabelMaxLength", Number).defineValue("xTickLabelRotation", Number).defineValue("xTickLabelSpacing", Number).asClass;
+var PanelOptionsBarChart = defineGrafanaItemClass("PanelOptionsBarChart", PanelOptions).defineValue("barRadius", Number).defineValue("barWidth", Number).defineValue("colorByField", String).defineValue("fullHighlight", Boolean).defineValue("groupWidth", Number).defineObject("legend", VizLegendOptions, { onDefault: (options) => new VizLegendOptions(options).setDisplayMode("list").setPlacement("bottom").setShowLegend(false) }).defineValue("orientation", String).defineValue("showValue", String).defineValue("stacking", String).defineObject("text", VizTextDisplayOptions).defineObject("tooltip", VizTooltipOptions, { onDefault: (options) => new VizTooltipOptions(options).setHideZeros(false).setMode("single").setSort("none") }).defineValue("xField", String).defineValue("xTickLabelMaxLength", Number).defineValue("xTickLabelRotation", Number).defineValue("xTickLabelSpacing", Number).asClass;
 //#endregion
 //#region src/items/PanelOptionsGaugeEffect.js
 var PanelOptionsGaugeEffect = defineGrafanaItemClass("PanelOptionsGaugeEffect", GrafanaItem).defineValue("barGlow", Boolean).defineValue("centerGlow", Boolean).defineValue("gradient", Boolean).asClass;
 //#endregion
 //#region src/items/PanelOptionsGaugeReduceOptions.js
-var PanelOptionsGaugeReduceOptions = defineGrafanaItemClass("PanelOptionsGaugeReduceOptions", GrafanaItem).defineArray("calcs", String, { setEmpty: true }).defineValue("fields", String).defineValue("limit", Number).defineValue("values", Boolean).asClass;
+var PanelOptionsGaugeReduceOptions = defineGrafanaItemClass("PanelOptionsGaugeReduceOptions", GrafanaItem).defineBasicArray("calcs", String, { setEmpty: true }).defineValue("fields", String).defineValue("limit", Number).defineValue("values", Boolean).asClass;
 //#endregion
 //#region src/items/PanelOptionsGauge.js
-var PanelOptionsGauge = defineGrafanaItemClass("PanelOptionsGauge", PanelOptions).defineValue("barShape", String).defineValue("barWidthFactor", Number).defineGrafanaObject("effects", PanelOptionsGaugeEffect).defineValue("endpointMarker", String).defineValue("minVizHeight", Number).defineValue("minVizWidth", Number).defineValue("orientation", String).defineGrafanaObject("reduceOptions", PanelOptionsGaugeReduceOptions).defineValue("segmentCount", Number).defineValue("segmentSpacing", Number).defineValue("shape", String).defineValue("showThresholdLabels", Boolean).defineValue("showThresholdMarkers", Boolean).defineValue("sizing", String).defineValue("sparkline", Boolean).defineValue("textMode", String).asClass;
+var PanelOptionsGauge = defineGrafanaItemClass("PanelOptionsGauge", PanelOptions).defineValue("barShape", String).defineValue("barWidthFactor", Number).defineObject("effects", PanelOptionsGaugeEffect).defineValue("endpointMarker", String).defineValue("minVizHeight", Number).defineValue("minVizWidth", Number).defineValue("orientation", String).defineObject("reduceOptions", PanelOptionsGaugeReduceOptions).defineValue("segmentCount", Number).defineValue("segmentSpacing", Number).defineValue("shape", String).defineValue("showThresholdLabels", Boolean).defineValue("showThresholdMarkers", Boolean).defineValue("sizing", String).defineValue("sparkline", Boolean).defineValue("textMode", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapBasemap.js
-var PanelOptionsGeomapBasemap = defineGrafanaItemClass("PanelOptionsGeomapBasemap", GrafanaItem).defineObject("config", Object).defineValue("name", String).defineValue("noRepeat", Boolean).defineValue("type", String).asClass;
+var PanelOptionsGeomapBasemap = defineGrafanaItemClass("PanelOptionsGeomapBasemap", GrafanaItem).defineBasicObject("config", Object).defineValue("name", String).defineValue("noRepeat", Boolean).defineValue("type", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapControls.js
 var PanelOptionsGeomapControls = defineGrafanaItemClass("PanelOptionsGeomapControls", GrafanaItem).defineValue("mouseWheelZoom", Boolean).defineValue("showAttribution", Boolean).defineValue("showDebug", Boolean).defineValue("showMeasure", Boolean).defineValue("showScale", Boolean).defineValue("showZoom", Boolean).asClass;
@@ -1168,16 +1360,16 @@ var StyleSymbolAlign = defineGrafanaItemClass("StyleSymbolAlign", GrafanaItem).d
 var StyleTextConfig = defineGrafanaItemClass("StyleTextConfig", GrafanaItem).defineValue("fontSize", Number).defineValue("offsetX", Number).defineValue("offsetY", Number).defineValue("textAlign", String).defineValue("textBaseline", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapLayerConfigStyle.js
-var PanelOptionsGeomapLayerConfigStyle = defineGrafanaItemClass("PanelOptionsGeomapLayerConfigStyle", GrafanaItem).defineGrafanaObject("color", StyleColor, { onDefault: (options) => new StyleColor(options) }).defineValue("opacity", Number, { onDefault: (options) => 1 }).defineGrafanaObject("rotation", StyleRotation, { onDefault: (options) => new StyleRotation(options) }).defineGrafanaObject("size", StyleSize, { onDefault: (options) => new StyleSize(options) }).defineGrafanaObject("symbol", StyleSymbol, { onDefault: (options) => new StyleSymbol(options) }).defineGrafanaObject("symbolAlign", StyleSymbolAlign, { onDefault: (options) => new StyleSymbolAlign(options) }).defineGrafanaObject("textConfig", StyleTextConfig, { onDefault: (options) => new StyleTextConfig(options) }).asClass;
+var PanelOptionsGeomapLayerConfigStyle = defineGrafanaItemClass("PanelOptionsGeomapLayerConfigStyle", GrafanaItem).defineObject("color", StyleColor, { onDefault: (options) => new StyleColor(options) }).defineValue("opacity", Number, { onDefault: (options) => 1 }).defineObject("rotation", StyleRotation, { onDefault: (options) => new StyleRotation(options) }).defineObject("size", StyleSize, { onDefault: (options) => new StyleSize(options) }).defineObject("symbol", StyleSymbol, { onDefault: (options) => new StyleSymbol(options) }).defineObject("symbolAlign", StyleSymbolAlign, { onDefault: (options) => new StyleSymbolAlign(options) }).defineObject("textConfig", StyleTextConfig, { onDefault: (options) => new StyleTextConfig(options) }).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapLayerConfig.js
-var PanelOptionsGeomapLayerConfig = defineGrafanaItemClass("PanelOptionsGeomapLayerConfig", GrafanaItem).defineValue("showLegend", Boolean).defineGrafanaObject("style", PanelOptionsGeomapLayerConfigStyle, { onDefault: (options) => new PanelOptionsGeomapLayerConfigStyle(options) }).asClass;
+var PanelOptionsGeomapLayerConfig = defineGrafanaItemClass("PanelOptionsGeomapLayerConfig", GrafanaItem).defineValue("showLegend", Boolean).defineObject("style", PanelOptionsGeomapLayerConfigStyle, { onDefault: (options) => new PanelOptionsGeomapLayerConfigStyle(options) }).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapLayerLocation.js
 var PanelOptionsGeomapLayerLocation = defineGrafanaItemClass("PanelOptionsGeomapLayerLocation", GrafanaItem).defineValue("mode", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapLayer.js
-var PanelOptionsGeomapLayer = defineGrafanaItemClass("PanelOptionsGeomapLayer", GrafanaItem).defineGrafanaObject("config", PanelOptionsGeomapLayerConfig).defineGrafanaObject("location", PanelOptionsGeomapLayerLocation).defineValue("name", String).defineValue("tooltip", Boolean).defineValue("type", String).asClass;
+var PanelOptionsGeomapLayer = defineGrafanaItemClass("PanelOptionsGeomapLayer", GrafanaItem).defineObject("config", PanelOptionsGeomapLayerConfig).defineObject("location", PanelOptionsGeomapLayerLocation).defineValue("name", String).defineValue("tooltip", Boolean).defineValue("type", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomapTooltip.js
 var PanelOptionsGeomapTooltip = defineGrafanaItemClass("PanelOptionsGeomapTooltip", GrafanaItem).defineValue("mode", String).asClass;
@@ -1186,13 +1378,13 @@ var PanelOptionsGeomapTooltip = defineGrafanaItemClass("PanelOptionsGeomapToolti
 var PanelOptionsGeomapView = defineGrafanaItemClass("PanelOptionsGeomapView", GrafanaItem).defineValue("allLayers", Boolean).defineValue("id", String).defineValue("lat", Number).defineValue("lon", Number).defineValue("noRepeat", Boolean).defineValue("shared", Boolean).defineValue("zoom", Number).asClass;
 //#endregion
 //#region src/items/PanelOptionsGeomap.js
-var PanelOptionsGeomap = defineGrafanaItemClass("PanelOptionsGeomap", PanelOptions).defineGrafanaObject("basemap", PanelOptionsGeomapBasemap).defineGrafanaObject("controls", PanelOptionsGeomapControls).defineArray("layers", PanelOptionsGeomapLayer).defineGrafanaObject("tooltip", PanelOptionsGeomapTooltip).defineGrafanaObject("view", PanelOptionsGeomapView).asClass;
+var PanelOptionsGeomap = defineGrafanaItemClass("PanelOptionsGeomap", PanelOptions).defineObject("basemap", PanelOptionsGeomapBasemap).defineObject("controls", PanelOptionsGeomapControls).defineArray("layers", PanelOptionsGeomapLayer).defineObject("tooltip", PanelOptionsGeomapTooltip).defineObject("view", PanelOptionsGeomapView).asClass;
 //#endregion
 //#region src/items/PieChartLegendOptions.js
-var PieChartLegendOptions = defineGrafanaItemClass("PieChartLegendOptions", VizLegendOptions).defineArray("values", String).asClass;
+var PieChartLegendOptions = defineGrafanaItemClass("PieChartLegendOptions", VizLegendOptions).defineBasicArray("values", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsPieChart.js
-var PanelOptionsPieChart = defineGrafanaItemClass("PanelOptionsPieChart", PanelOptions).defineArray("displayLabels", String).defineGrafanaObject("legend", PieChartLegendOptions).defineValue("pieType", String).defineValue("sort", String).defineGrafanaObject("tooltip", VizTooltipOptions).asClass;
+var PanelOptionsPieChart = defineGrafanaItemClass("PanelOptionsPieChart", PanelOptions).defineBasicArray("displayLabels", String).defineObject("legend", PieChartLegendOptions).defineValue("pieType", String).defineValue("sort", String).defineObject("tooltip", VizTooltipOptions).asClass;
 //#endregion
 //#region src/items/PanelOptionsStat.js
 var PanelOptionsStat = defineGrafanaItemClass("PanelOptionsStat", PanelOptions).asClass;
@@ -1207,13 +1399,13 @@ var PanelOptionsTable = defineGrafanaItemClass("PanelOptionsTable", PanelOptions
 var PanelOptionsTextCode = defineGrafanaItemClass("PanelOptionsTextCode", GrafanaItem).defineValue("language", String).defineValue("showLineNumbers", Boolean).defineValue("showMiniMap", Boolean).asClass;
 //#endregion
 //#region src/items/PanelOptionsText.js
-var PanelOptionsText = defineGrafanaItemClass("PanelOptionsText", PanelOptions).defineGrafanaObject("code", PanelOptionsTextCode, { onDefault: (options) => new PanelOptionsTextCode(options) }).defineValue("content", String).defineValue("mode", String).asClass;
+var PanelOptionsText = defineGrafanaItemClass("PanelOptionsText", PanelOptions).defineObject("code", PanelOptionsTextCode, { onDefault: (options) => new PanelOptionsTextCode(options) }).defineValue("content", String).defineValue("mode", String).asClass;
 //#endregion
 //#region src/items/PanelOptionsTimeSeries.js
-var PanelOptionsTimeSeries = defineGrafanaItemClass("PanelOptionsTimeSeries", PanelOptions).defineValue("disableKeyboardEvents", Boolean).defineGrafanaObject("legend", VizLegendOptions, { onDefault: (options) => new VizLegendOptions(options).setDisplayMode("list").setPlacement("bottom").setShowLegend(false) }).defineValue("orientation", String).defineGrafanaObject("tooltip", VizTooltipOptions, { onDefault: (options) => new VizTooltipOptions(options).setHideZeros(false).setMode("single").setSort("none") }).asClass;
+var PanelOptionsTimeSeries = defineGrafanaItemClass("PanelOptionsTimeSeries", PanelOptions).defineValue("disableKeyboardEvents", Boolean).defineObject("legend", VizLegendOptions, { onDefault: (options) => new VizLegendOptions(options).setDisplayMode("list").setPlacement("bottom").setShowLegend(false) }).defineValue("orientation", String).defineObject("tooltip", VizTooltipOptions, { onDefault: (options) => new VizTooltipOptions(options).setHideZeros(false).setMode("single").setSort("none") }).asClass;
 //#endregion
 //#region src/items/TargetInfinity.js
-var TargetInfinity = defineGrafanaItemClass("TargetInfinity", Target).defineObject("columns", Object).defineObject("computed_columns", Object, { name: "computedColumns" }).defineValue("format", String).defineValue("parser", String).defineValue("source", String).defineValue("type", String).defineValue("uql", String).defineValue("url", String).defineValue("url_options", Object, { name: "urlOptions" }).asClass;
+var TargetInfinity = defineGrafanaItemClass("TargetInfinity", Target).defineBasicObject("columns", Object).defineBasicObject("computed_columns", Object, { name: "computedColumns" }).defineValue("format", String).defineValue("parser", String).defineValue("source", String).defineValue("type", String).defineValue("uql", String).defineValue("url", String).defineValue("url_options", Object, { name: "urlOptions" }).asClass;
 //#endregion
 //#region src/items/Testdata.js
 var Testdata = defineGrafanaItemClass("Testdata", Datasource).with((builder) => defineDatasource(builder, "grafana-testdata-datasource")).asClass;
@@ -1223,33 +1415,37 @@ var FieldConfigCustomText = defineGrafanaItemClass("FieldConfigCustomText", Fiel
 //#endregion
 //#region src/items/properties/panel.js
 /**
-* @param {GrafanaItemClassBuilder} builder
+* @template T
+* @typedef {import("@gdacm/base-types").MetaConstructor<T>} MetaConstructor
+*/
+/**
+* @template {Panel} T
+* @param {GrafanaItemClassBuilder<T>} builder
 * @param {string} typeName
-* @param {typeof FieldConfigCustom} fieldConfigCustom
-* @param {typeof PanelOptions} panelOptions
+* @param {MetaConstructor<FieldConfigCustom>} fieldConfigCustom
+* @param {MetaConstructor<PanelOptions>} panelOptions
 * @param {Object} [options]
-* @param {(instance: Panel) => void} [options.onInit]
+* @param {(instance: T) => void} [options.onInit]
 */
 var definePanel = (builder, typeName, fieldConfigCustom, panelOptions, options) => {
 	const { onInit } = options ?? {};
 	builder.defineConstructor((instance) => {
-		const self = instance;
-		self.setType(typeName).withFieldConfig((fieldConfig) => fieldConfig.setDefaults(new FieldConfigDefault(instance.metaOptions).setCustom(new fieldConfigCustom(instance.metaOptions))));
-		if (onInit) onInit(self);
+		instance.setType(typeName).withFieldConfig((fieldConfig) => fieldConfig.setDefaults(new FieldConfigDefault(instance.metaOptions).setCustom(new fieldConfigCustom(instance.metaOptions))));
+		if (onInit) onInit(instance);
 	}).defineGetterSetter("custom", `${fieldConfigCustom.name}`, {
 		typesToInclude: [fieldConfigCustom],
 		getter: (instance) => instance.fieldConfig.defaults.custom
 	}).defineMethod(`withCustom`, `(code: (custom: ${fieldConfigCustom.name}) => void): this`, {
 		typesToInclude: [fieldConfigCustom],
 		/** 
-		* @param {Panel} instance 
+		* @param {T} instance 
 		* @param {(custom: FieldConfigCustom) => void} code
 		* */
 		code: (instance, code) => {
 			code(instance.fieldConfig.defaults.custom);
 			return instance;
 		}
-	}).defineGrafanaObject("options", panelOptions, { onDefault: (options) => new panelOptions(options) });
+	}).defineObject("options", panelOptions, { onDefault: (options) => new panelOptions(options) });
 };
 //#endregion
 //#region src/items/TextPanel.js
@@ -1259,8 +1455,13 @@ var TextPanel = defineGrafanaItemClass("TextPanel", Panel).with((builder) => def
 var BarChart = defineGrafanaItemClass("BarChart", Panel).with((instance) => definePanel(instance, "barchart", FieldConfigCustomBarChart, PanelOptionsBarChart, { onInit: (instance) => {
 	instance.fieldConfig.defaults.setColorMode("palette-classic");
 	instance.fieldConfig.defaults.thresholds.setMode("absolute");
-} })).defineMethod("setThresholdsStyleArea", "(): this", { code: (instance) => {
-	instance.custom.thresholdsStyle.setMode("area");
+} })).defineMethod("setThresholdsStyleMode", "(mode: string): this", { 
+/**
+* @param {BarChart} instance 
+* @returns 
+*/
+code: (instance, mode) => {
+	instance.custom.thresholdsStyle.setMode(mode);
 	return instance;
 } }).asClass;
 //#endregion
@@ -1291,8 +1492,13 @@ var Table = defineGrafanaItemClass("Table", Panel).with((builder) => definePanel
 var TimeSeries = defineGrafanaItemClass("TimeSeries", Panel).with((builder) => definePanel(builder, "timeseries", FieldConfigCustomTimeSerie, PanelOptionsTimeSeries, { onInit: (instance) => {
 	instance.fieldConfig.defaults.setColorMode("palette-classic");
 	instance.fieldConfig.defaults.thresholds.setMode("absolute");
-} })).defineMethod("setThresholdsStyleArea", "(): this", { code: (instance) => {
-	instance.custom.thresholdsStyle.setMode("area");
+} })).defineMethod("setThresholdsStyleMode", "(mode: string): this", { 
+/**
+* @param {TimeSeries} instance 
+* @returns 
+*/
+code: (instance, mode) => {
+	instance.custom.thresholdsStyle.setMode(mode);
 	return instance;
 } }).asClass;
 //#endregion