@gdacm/grafana-items 0.1.1

package/dist/index.js

@@ -0,0 +1,1168 @@
+//#region src/utils/json.js
+/**
+* Sort the keys of an object for consistent JSON representation.
+* @param {{[key: String]: any}} obj - The object to sort.
+* @returns {{[key: String]: any}} - The object with sorted keys.
+*/
+var sortKeys = (obj) => {
+	return Object.fromEntries(Object.keys(obj).sort().map((key) => [key, obj[key]]));
+};
+/**
+* Convert an object to a JSON representation, sorting keys for consistency.
+* @param {GrafanaItem|{[key: String]: any}|Array<GrafanaItem|{[key: String]: any}|Number|String|Boolean>|Number|String|Boolean|null|undefined} obj - The object to convert to JSON.
+* @returns {Object|null|undefined} - The JSON representation of the object with sorted keys.
+*/
+var asJson = (obj) => {
+	if (obj instanceof GrafanaItem) return sortKeys(obj.asJson());
+	if (Array.isArray(obj)) return obj.map((item) => asJson(item));
+	if (Number.isInteger(obj) || typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || Number.isFinite(obj)) return obj;
+	if (obj === null || obj === void 0) return obj;
+	return sortKeys(obj);
+};
+//#endregion
+//#region src/utils/typesDefinition.js
+/**
+* @typedef {import("@gdacm/base-types").GenericMetaOptions} GenericMetaOptions
+*/
+/**
+* @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
+*/
+/**
+* @type {Map<typeof GrafanaItem, MetaClassInfo>}
+*/
+var types = /* @__PURE__ */ new Map();
+/**
+* @param {typeof GrafanaItem} cls 
+*/
+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}
+*/
+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 
+*/
+function hasPrototype(cls, name) {
+	return cls.prototype[name] !== void 0;
+}
+/**
+* @param {typeof GrafanaItem} cls
+* @param {string} name 
+* @param {Function} value 
+*/
+function setPrototype(cls, name, value) {
+	cls.prototype[name] = value;
+}
+/**
+* @param {typeof GrafanaItem} cls 
+* @param {string} name 
+* @param {(self: GrafanaItem) => any} getter 
+*/
+function setGetter(cls, name, getter) {
+	Object.defineProperty(cls.prototype, name, {
+		get() {
+			return getter(this);
+		},
+		enumerable: false,
+		configurable: true
+	});
+}
+/**
+* @param {typeof GrafanaItem} cls 
+* @param {string} name 
+* @param {(instance: GrafanaItem, value: any) => void} setter 
+*/
+function setSetter(cls, name, setter) {
+	Object.defineProperty(cls.prototype, name, {
+		set(value) {
+			return setter(this, value);
+		},
+		enumerable: false,
+		configurable: true
+	});
+}
+/**
+* @param {typeof GrafanaItem} cls 
+* @param {string} name 
+* @param {(self: GrafanaItem) => any} getter 
+* @param {(instance: GrafanaItem, value: any) => void} setter 
+*/
+function setGetterAndSetter(cls, name, getter, setter) {
+	Object.defineProperty(cls.prototype, name, {
+		get() {
+			return getter(this);
+		},
+		set(value) {
+			return setter(this, value);
+		},
+		enumerable: false,
+		configurable: true
+	});
+}
+/**
+* @param {typeof GrafanaItem} 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 {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));
+	});
+}
+/**
+* @param {typeof GrafanaItem} 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 {Boolean} [option.setNew]
+* @param {String} [option.typeName]
+*/
+function defineObject(cls, key, type, option) {
+	const metaClassInfo = getMetaClassInfo(cls);
+	const name = option?.name ? option.name : key;
+	const setNew = option?.setNew ?? false;
+	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;`);
+	}
+	const setNewName = `setNew${caseName}`;
+	if (hasPrototype(cls, setNewName) === false && setNew) {
+		setPrototype(
+			cls,
+			setNewName,
+			/**
+			* @this GrafanaItem
+			* @template {GrafanaItem} T
+			* @param {(item: T) => T} [onNewCreated]
+			* @returns {GrafanaItem}
+			*/
+			function(onNewCreated) {
+				if (!onNewCreated) onNewCreated = (item) => item;
+				return this._setObject(key, onNewCreated(new type(this.metaOptions)));
+			}
+		);
+		metaClassInfo.methods.push(`${setNewName}(onNewCreated: ((item: ${typeName}) => ${typeName}) | undefined): this;`);
+	}
+	setPrototype(
+		cls,
+		`with${caseName}`,
+		/**
+		* @this GrafanaItem
+		* @template {GrafanaItem} T
+		* @param {(item: T) => void} onWith
+		* @returns {GrafanaItem}
+		*/
+		function(onWith) {
+			const item = this._getObject(key);
+			if (item) onWith(item);
+			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);
+	}
+}
+/**
+* @param {typeof GrafanaItem} cls 
+* @param {string} key 
+* @param {Function} 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]
+*/
+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(
+		cls,
+		withName,
+		/**
+		* @this GrafanaItem
+		* @template T
+		* @param {(array: T[]) => void} onWith
+		* @returns {GrafanaItem}
+		*/
+		function(onWith) {
+			const array = this._getArray(key);
+			if (array) onWith(array);
+			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);
+	}
+}
+/**
+* @template {typeof GrafanaItem} T
+* @param {typeof GrafanaItem} cls 
+* @param {string|undefined} method
+* @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};`);
+		}
+		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});`);
+		}
+		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});`);
+		}
+	}
+}
+/**
+* @param {typeof GrafanaItem} cls 
+* @param {(instance: GrafanaItem) => void} code
+*/
+function defineConstructor(cls, code) {
+	defineMemberInternal(cls, "constructor(metaOptions: GenericMetaOptions)", { constr: code });
+}
+var GrafanaItemClassBuilder = class {
+	/**
+	* @param {typeof GrafanaItem} cls
+	*/
+	constructor(cls) {
+		this.cls = cls;
+	}
+	/**
+	* @param {typeof GrafanaItem} parent
+	* @returns 
+	*/
+	setParent(parent) {
+		this.parent = parent;
+		return this;
+	}
+	/**
+	* @param {string} key 
+	* @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 {String} [option.typeName]
+	* @return {this}
+	*/
+	defineValue(key, type, option) {
+		defineValue(this.cls, key, type, option);
+		return this;
+	}
+	/**
+	* @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 {Boolean} [option.setNew]
+	* @param {String} [option.typeName]
+	* @return {this}
+	*/
+	defineObject(key, type, option) {
+		defineObject(this.cls, key, type, option);
+		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: GrafanaItem) => void} [option.onInit]
+	* @param {(metaOptions: GenericMetaOptions) => InstanceType<typeof GrafanaItem>} [option.onDefault]
+	* @return {this}
+	*/
+	defineArray(key, type, option) {
+		defineArray(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);
+		return this;
+	}
+	/**
+	* @template {typeof GrafanaItem} T
+	* @param {(instance: InstanceType<T>) => void} code
+	* @return {this}
+	*/
+	defineConstructor(code) {
+		defineConstructor(this.cls, code);
+		return this;
+	}
+	/**
+	* @param {string} name
+	* @param {string} args
+	* @param {Object} option
+	* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
+	* @param {Function} option.code
+	* @return {this}
+	*/
+	defineMethod(name, args, option) {
+		defineMemberInternal(this.cls, `${name}${args}`, {
+			...option,
+			name
+		});
+		return this;
+	}
+	/**
+	* @template {typeof GrafanaItem} T
+	* @param {string} name
+	* @param {string} type
+	* @param {Object} option
+	* @param {(typeof GrafanaItem)[]} [option.typesToInclude]
+	* @param {(instance: InstanceType<T>) => any} [option.getter]
+	* @param {(instance: InstanceType<T>, 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
+		});
+		return this;
+	}
+	/**
+	* @param {(instance: this) => void} code 
+	*/
+	with(code) {
+		code(this);
+		return this;
+	}
+	/**
+	* @returns {typeof GrafanaItem}
+	*/
+	get asClass() {
+		return this.cls;
+	}
+};
+/**
+* @param {string} name
+* @param {typeof GrafanaItem} parent
+* @returns {GrafanaItemClassBuilder}
+*/
+var defineGrafanaItemClass = (name, parent) => {
+	const cls = class extends parent {};
+	Object.defineProperty(cls, "name", { value: name });
+	return defineClass(cls).setParent(parent);
+};
+//#endregion
+//#region src/items/GrafanaItem.js
+var GrafanaItem = class {
+	/**
+	* @param {import("../../../base-types/src/index.js").MetaOptions<import("../../../base-types/src/index.js").GenericOptions>} metaOptions An object with options
+	*/
+	constructor(metaOptions) {
+		this._metaOptions = metaOptions || {};
+		this._grafanaValues = {};
+		this._grafanaArrays = {};
+		this._grafanaObjects = {};
+		this._onInit();
+	}
+	/**
+	* @returns {Object} The meta options of the Grafana item
+	*/
+	get metaOptions() {
+		return this._metaOptions;
+	}
+	/**
+	* @param {(metaOptions: Object) => void} code 
+	* @returns {this}
+	*/
+	withMetaOptions(code) {
+		code(this.metaOptions);
+		return this;
+	}
+	/**
+	* @param {(item: this) => void} code 
+	* @returns {this}
+	*/
+	with(code) {
+		code(this);
+		return this;
+	}
+	/**
+	* 
+	* @template T
+	* @param {string} key 
+	* @param {T} value 
+	* @returns 
+	*/
+	_setValue(key, value) {
+		this._grafanaValues[key] = asJson(value);
+		return this;
+	}
+	/**
+	* 
+	* @template T
+	* @param {string} key
+	* @param {T} value
+	* @returns 
+	*/
+	_getValue(key) {
+		return this._grafanaValues[key];
+	}
+	/**
+	* @returns {Object} The JSON representation of the Grafana item
+	*/
+	asJson() {
+		const values = { ...this._grafanaValues };
+		for (const key in this._grafanaArrays) values[key] = this._grafanaArrays[key].map((item) => asJson(item));
+		for (const key in this._grafanaObjects) values[key] = asJson(this._grafanaObjects[key]);
+		return asJson(values);
+	}
+	/**
+	* @param {string} key
+	*/
+	_initArray(key) {
+		this._getArray(key);
+		return this;
+	}
+	/**
+	* @template T
+	* @param {string} key 
+	* @return {T[]}
+	*/
+	_getArray(key) {
+		if (!this._grafanaArrays[key]) this._grafanaArrays[key] = [];
+		return this._grafanaArrays[key];
+	}
+	/**
+	* @template T
+	* @param {string} key 
+	* @param {T} item 
+	* @returns {this}
+	*/
+	_addArrayItem(key, item) {
+		this._getArray(key).push(item);
+		return this;
+	}
+	/**
+	* @template T
+	* @param {string} key 
+	* @param {T} value 
+	* @returns {this}
+	*/
+	_setObject(key, value) {
+		this._grafanaObjects[key] = value;
+		return this;
+	}
+	/**
+	* @template T
+	* @param {string} key 
+	* @returns {T|undefined}
+	*/
+	_getObject(key) {
+		if (!this._grafanaObjects[key]) this._grafanaObjects[key] = void 0;
+		return this._grafanaObjects[key];
+	}
+	/**
+	* 
+	* @template T
+	* @param {string} key
+	* @param {(item: T) => void} code 
+	* @returns {this}
+	*/
+	_withObject(key, code) {
+		const obj = this._getObject(key);
+		if (obj) code(obj);
+		return this;
+	}
+};
+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;");
+//#endregion
+//#region src/items/OverrideMatcher.js
+var OverrideMatcher = defineGrafanaItemClass("OverrideMatcher", GrafanaItem).defineValue("id", String).defineObject("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;
+//#endregion
+//#region src/items/OverrideProperty.js
+var OverrideProperty = defineGrafanaItemClass("OverrideProperty", GrafanaItem).defineValue("id", String).defineValue("value", Object).asClass;
+//#endregion
+//#region src/items/Datasource.js
+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).defineObject("datasource", Datasource, { setNew: true }).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;
+//#endregion
+//#region src/items/Color.js
+var Color = defineGrafanaItemClass("Color", GrafanaItem).defineValue("mode", String).asClass;
+//#endregion
+//#region src/items/TimeRange.js
+var TimeRange = defineGrafanaItemClass("TimeRange", GrafanaItem).defineValue("from", String).defineValue("to", String).defineMethod("setRange", "(from: string, to: string): this;", { 
+/**
+* @param {TimeRange} timeRange 
+* @param {string} from 
+* @param {string} to 
+* @returns {TimeRange}
+*/
+code: (timeRange, from, to) => {
+	timeRange.setFrom(from);
+	timeRange.setTo(to);
+	return timeRange;
+} }).asClass;
+//#endregion
+//#region src/items/GridPos.js
+var GridPos = defineGrafanaItemClass("GridPos", GrafanaItem).defineValue("x", Number).defineValue("y", Number).defineValue("w", Number).defineValue("h", Number).defineMethod("setPos", "(x: number, y: number, w: number, h: number): this;", { 
+/**
+* @param {GridPos} gridPos
+* @param {number} x
+* @param {number} y
+* @param {number} w
+* @param {number} h
+* @returns {GridPos}
+*/
+code: (gridPos, x, y, w, h) => {
+	gridPos.setX(x);
+	gridPos.setY(y);
+	gridPos.setW(w);
+	gridPos.setH(h);
+	return gridPos;
+} }).asClass;
+//#endregion
+//#region src/items/FieldConfigCustom.js
+var FieldConfigCustom = defineGrafanaItemClass("FieldConfigCustom", GrafanaItem).asClass;
+//#endregion
+//#region src/items/Mapping.js
+var Mapping = defineGrafanaItemClass("Mapping", GrafanaItem).asClass;
+//#endregion
+//#region src/items/ThresholdsStep.js
+var ThresholdsStep = defineGrafanaItemClass("ThresholdsStep", GrafanaItem).defineValue("value", Number).defineValue("color", String).asClass;
+//#endregion
+//#region src/items/Thresholds.js
+var Thresholds = defineGrafanaItemClass("Thresholds", GrafanaItem).defineValue("mode", String).defineArray("steps", ThresholdsStep).defineMethod("addStepWithValueAndColor", "(value: number, color: string): this;", { 
+/**
+* @param {Thresholds} thresholds 
+* @param {number} value 
+* @param {string} color 
+* @returns {Thresholds}
+*/
+code: (thresholds, value, color) => {
+	const step = new ThresholdsStep(thresholds.metaOptions).setValue(value).setColor(color);
+	return thresholds.addStep(step);
+} }).asClass;
+//#endregion
+//#region src/items/FieldConfigDefault.js
+var FieldConfigDefault = defineGrafanaItemClass("FieldConfigDefault", GrafanaItem).defineObject("color", Color, { setNew: true }).defineObject("custom", FieldConfigCustom, {}).defineValue("decimals", Number).defineValue("fieldMinMax", Boolean).defineArray("mappings", Mapping).defineValue("max", Number).defineValue("min", Number).defineObject("thresholds", Thresholds, { onDefault: (options) => new Thresholds(options).setMode("absolute") }).defineValue("unit", String).defineMethod("setColorMode", "(mode: string): this;", { 
+/**
+* @param {FieldConfigDefault} fieldConfigDefault
+* @param {String} mode
+* @returns {FieldConfigDefault}
+*/
+code: (fieldConfigDefault, mode) => {
+	if (fieldConfigDefault.color === void 0) fieldConfigDefault.setNewColor();
+	fieldConfigDefault.color.setMode(mode);
+	return fieldConfigDefault;
+} }).asClass;
+//#endregion
+//#region src/items/FieldConfigOverride.js
+var FieldConfigOverride = defineGrafanaItemClass("FieldConfigOverride", GrafanaItem).defineValue("__systemRef", String, { name: "systemRef" }).defineObject("matcher", OverrideMatcher, { setNew: true }).defineArray("properties", OverrideProperty, { itemName: "property" }).asClass;
+//#endregion
+//#region src/items/HideFrom.js
+var HideFrom = defineGrafanaItemClass("HideFrom", GrafanaItem).defineValue("legend", Boolean).defineValue("tooltip", Boolean).defineValue("viz", Boolean).asClass;
+//#endregion
+//#region src/items/FieldConfig.js
+var FieldConfig = defineGrafanaItemClass("FieldConfig", GrafanaItem).defineObject("defaults", FieldConfigDefault, {}).defineArray("overrides", FieldConfigOverride).defineMethod("addNewOverrideHideSeriesFrom", "(names: string[]): this", { 
+/**
+* @param {FieldConfig} fieldConfig
+* @param {String[]} names
+* @returns {FieldConfigOverride}
+*/
+code: (fieldConfig, names) => {
+	/**
+	* @param {OverrideMatcherOptionsByNames} matcher
+	* @returns {OverrideMatcherOptionsByNames}
+	*/
+	const reduceForNames = (matcher) => names.reduce((matcher, name) => matcher.addName(name), matcher);
+	return fieldConfig.addNewOverride((override) => override.setSystemRef("hideSeriesFrom").setNewMatcher((overrideMatcher) => overrideMatcher.setId("byNames").setOptions(reduceForNames(new OverrideMatcherOptionsByNames()).setMode("exclude").setPrefix("All except:").setReadOnly(true))).addNewProperty((property) => property.setId("custom.hideFrom").setValue(new HideFrom().setLegend(false).setTooltip(true).setViz(true))));
+} }).asClass;
+//#endregion
+//#region src/items/Target.js
+var Target = defineGrafanaItemClass("Target", GrafanaItem).defineValue("alias", String).defineValue("refId", String).defineValue("query", String).defineObject("datasource", Datasource, { setNew: true }).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;
+//#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).defineObject("datasource", Datasource, { onDefault: (options) => void 0 }).defineValue("description", String).defineObject("fieldConfig", FieldConfig, { onDefault: (options) => new FieldConfig(options) }).defineObject("gridPos", GridPos, { setNew: true }).defineMethod("setPos", "(x: number, y: number, w: number, h: number): this;", { 
+/**
+* @param {Panel} panel
+* @param {number} x
+* @param {number} y
+* @param {number} w
+* @param {number} h
+*/
+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).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
+* @param {string} query
+* @param {Datasource} datasource
+*/
+code: (panel, refId, query, datasource) => {
+	return panel.addTarget(new Target(panel.metaOptions).setRefId(refId).setQuery(query).setDatasource(datasource));
+} }).defineValue("timeFrom", String).defineValue("timeShift", String).defineArray("transformations", DataTransformation).defineValue("type", String, { onDefault: (options) => "" }).defineValue("title", String, { onDefault: (options) => "" }).asClass;
+//#endregion
+//#region src/items/TemplateCurrent.js
+var TemplateCurrent = defineGrafanaItemClass("TemplateCurrent", GrafanaItem).defineValue("text", Object).defineValue("value", Object).asClass;
+//#endregion
+//#region src/items/TemplateOption.js
+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).defineObject("current", TemplateCurrent, { setNew: true }).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;
+//#endregion
+//#region src/torefactor/index.js
+/**
+* @typedef {import("@gdacm/base-types").GenericMetaOptions} GenericMetaOptions
+*/
+/**
+* @param {GenericMetaOptions} options 
+* @returns {Annotations}
+*/
+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).defineObject("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;", { 
+/**
+* @param {Dashboard} dashboard
+* @param {Panel} panel
+* @returns {Dashboard}
+*/
+code: (dashboard, panel) => {
+	const max = dashboard.panels.reduce((acc, panel) => {
+		const id = panel._getValue("id");
+		if (id >= acc) return id;
+		else return acc;
+	}, 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, {
+	onDefault: (options) => [],
+	typeName: "Array<String>"
+}).defineObject("templating", Templating, { onDefault: (options) => new Templating(options) }).defineObject("time", TimeRange, { onDefault: (options) => new TimeRange(options) }).defineMethod("setTimeRange", "(from: string, to: string): this;", { 
+/**
+* @param {Dashboard} dashboard
+* @param {string} from
+* @param {string} to
+* @returns {Dashboard}
+*/
+code: (dashboard, from, to) => {
+	dashboard.time.setRange(from, to);
+	return dashboard;
+} }).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
+* @param {string} typeName
+* @param {Object} [options]
+* @param {(instance: Datasource) => void} [options.onInit]
+*/
+var defineDatasource = (builder, typeName, options) => {
+	const { onInit } = options ?? {};
+	builder.defineConstructor((instance) => {
+		const self = instance;
+		self.setType(typeName);
+		if (onInit) onInit(self);
+	});
+};
+//#endregion
+//#region src/items/DatasourceInfinity.js
+var DatasourceInfinity = defineGrafanaItemClass("DatasourceInfinity", Datasource).with((builder) => defineDatasource(builder, "yesoreyeram-infinity-datasource")).asClass;
+//#endregion
+//#region src/items/ScaleDistribution.js
+var ScaleDistribution = defineGrafanaItemClass("ScaleDistribution", GrafanaItem).defineValue("type", String).asClass;
+//#endregion
+//#region src/items/properties/axisConfig.js
+/**
+* @param {GrafanaItemClassBuilder} 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") });
+};
+//#endregion
+//#region src/items/properties/hideableFieldConfig.js
+/**
+* @param {GrafanaItemClassBuilder} builder
+*/
+var defineHideableFieldConfig = (builder) => {
+	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).defineObject("thresholdsStyle", ThresholdStyle, { onDefault: (options) => new ThresholdStyle(options).setMode("off") }).defineMethod("setThresholdsStyleMode", "(mode: string): this;", { 
+/**
+* @param {FieldConfigCustomBarChart} fieldConfigCustomBarChart
+* @param {String} mode
+* @returns {FieldConfigCustomBarChart}
+*/
+code: (fieldConfigCustomBarChart, mode) => {
+	fieldConfigCustomBarChart.thresholdsStyle.setMode(mode);
+	return fieldConfigCustomBarChart;
+} }).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomGauge.js
+var FieldConfigCustomGauge = defineGrafanaItemClass("FieldConfigCustomGauge", FieldConfigCustom).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomGeomap.js
+var FieldConfigCustomGeomap = defineGrafanaItemClass("FieldConfigCustomGeomap", FieldConfigCustom).defineObject("hideFrom", HideFrom, { onDefault: (options) => new HideFrom(options).setLegend(false).setTooltip(false).setViz(false) }).asClass;
+//#endregion
+//#region src/items/LineStyle.js
+var LineStyle = defineGrafanaItemClass("LineStyle", GrafanaItem).defineValue("fill", String).asClass;
+//#endregion
+//#region src/items/Stacking.js
+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).defineObject("lineStyle", LineStyle, { onDefault: (options) => new LineStyle(options).setFill("solid") }).defineMethod("setLineStyleFill", "(fill: string): this;", { 
+/**
+* @param {FieldConfigCustomTimeSerie} fieldConfigCustomTimeSerie
+* @param {String} fill
+* @returns {FieldConfigCustomTimeSerie}
+*/
+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).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
+* @returns {FieldConfigCustomTimeSerie}
+*/
+code: (fieldConfigCustomTimeSerie, mode) => {
+	fieldConfigCustomTimeSerie.thresholdsStyle.setMode(mode);
+	return fieldConfigCustomTimeSerie;
+} }).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomTableCellOptions.js
+var FieldConfigCustomTableCellOptions = defineGrafanaItemClass("FieldConfigCustomTableCellOptions", GrafanaItem).defineValue("type", String).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomTableFooter.js
+var FieldConfigCustomTableFooter = defineGrafanaItemClass("FieldConfigCustomTableFooter", GrafanaItem).defineArray("reducers", String).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomTable.js
+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;
+//#endregion
+//#region src/items/PanelOptions.js
+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;
+//#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;
+//#endregion
+//#region src/items/VizTextDisplayOptions.js
+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).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;
+//#endregion
+//#region src/items/PanelOptionsGauge.js
+var PanelOptionsGauge = defineGrafanaItemClass("PanelOptionsGauge", PanelOptions).defineValue("barShape", String).defineValue("barWidthFactor", Number).defineObject("effects", PanelOptionsGaugeEffect, { setNew: true }).defineValue("endpointMarker", String).defineValue("minVizHeight", Number).defineValue("minVizWidth", Number).defineValue("orientation", String).defineObject("reduceOptions", PanelOptionsGaugeReduceOptions, { setNew: true }).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, { setNew: true }).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;
+//#endregion
+//#region src/items/StyleColor.js
+var StyleColor = defineGrafanaItemClass("StyleColor", GrafanaItem).defineValue("fixed", String).asClass;
+//#endregion
+//#region src/items/StyleRotation.js
+var StyleRotation = defineGrafanaItemClass("StyleRotation", GrafanaItem).defineValue("fixed", Number).defineValue("max", Number).defineValue("min", Number).defineValue("mode", String).asClass;
+//#endregion
+//#region src/items/StyleSize.js
+var StyleSize = defineGrafanaItemClass("StyleSize", GrafanaItem).defineValue("fixed", Number).defineValue("max", Number).defineValue("min", Number).asClass;
+//#endregion
+//#region src/items/StyleSymbol.js
+var StyleSymbol = defineGrafanaItemClass("StyleSymbol", GrafanaItem).defineValue("field", String).defineValue("fixed", String).defineValue("mode", String).asClass;
+//#endregion
+//#region src/items/StyleSymbolAlign.js
+var StyleSymbolAlign = defineGrafanaItemClass("StyleSymbolAlign", GrafanaItem).defineValue("horizontal", String).defineValue("vertical", String).asClass;
+//#endregion
+//#region src/items/StyleTextConfig.js
+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).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).defineObject("style", PanelOptionsGeomapLayerConfigStyle, {
+	onDefault: (options) => new PanelOptionsGeomapLayerConfigStyle(options),
+	setNew: true
+}).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).defineObject("config", PanelOptionsGeomapLayerConfig, { setNew: true }).defineObject("location", PanelOptionsGeomapLayerLocation, { setNew: true }).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;
+//#endregion
+//#region src/items/PanelOptionsGeomapView.js
+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).defineObject("basemap", PanelOptionsGeomapBasemap, { setNew: true }).defineObject("controls", PanelOptionsGeomapControls, { setNew: true }).defineArray("layers", PanelOptionsGeomapLayer).defineObject("tooltip", PanelOptionsGeomapTooltip, { setNew: true }).defineObject("view", PanelOptionsGeomapView, { setNew: true }).asClass;
+//#endregion
+//#region src/items/PanelOptionsStat.js
+var PanelOptionsStat = defineGrafanaItemClass("PanelOptionsStat", PanelOptions).asClass;
+//#endregion
+//#region src/items/PanelOptionsTableSortBy.js
+var PanelOptionsTableSortBy = defineGrafanaItemClass("PanelOptionsTableSortBy", GrafanaItem).defineValue("desc", Boolean).defineValue("displayName", String).asClass;
+//#endregion
+//#region src/items/PanelOptionsTable.js
+var PanelOptionsTable = defineGrafanaItemClass("PanelOptionsTable", PanelOptions).defineValue("cellHeight", String).defineValue("showHeader", Boolean).defineArray("sortBy", PanelOptionsTableSortBy).asClass;
+//#endregion
+//#region src/items/PanelOptionsTextCode.js
+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).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).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;
+//#endregion
+//#region src/items/Testdata.js
+var Testdata = defineGrafanaItemClass("Testdata", Datasource).with((builder) => defineDatasource(builder, "grafana-testdata-datasource")).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomText.js
+var FieldConfigCustomText = defineGrafanaItemClass("FieldConfigCustomText", FieldConfigCustom).asClass;
+//#endregion
+//#region src/items/properties/panel.js
+/**
+* @param {GrafanaItemClassBuilder} builder
+* @param {string} typeName
+* @param {typeof FieldConfigCustom} fieldConfigCustom
+* @param {typeof PanelOptions} panelOptions
+* @param {Object} [options]
+* @param {(instance: Panel) => 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);
+	}).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 {(custom: FieldConfigCustom) => void} code
+		* */
+		code: (instance, code) => {
+			code(instance.fieldConfig.defaults.custom);
+			return instance;
+		}
+	}).defineObject("options", panelOptions, {
+		setNew: true,
+		onDefault: (options) => new panelOptions(options)
+	});
+};
+//#endregion
+//#region src/items/TextPanel.js
+var TextPanel = defineGrafanaItemClass("TextPanel", Panel).with((builder) => definePanel(builder, "text", FieldConfigCustomText, PanelOptionsText)).asClass;
+//#endregion
+//#region src/items/BarChart.js
+var BarChart = defineGrafanaItemClass("BarChart", Panel).with((instance) => definePanel(instance, "barchart", FieldConfigCustomBarChart, PanelOptionsBarChart, { onInit: (instance) => {
+	instance.fieldConfig.defaults.setColorMode("palette-classic");
+} })).defineMethod("setThresholdsStyleArea", "(): this", { code: (instance) => {
+	instance.custom.thresholdsStyle.setMode("area");
+	return instance;
+} }).asClass;
+//#endregion
+//#region src/items/Gauge.js
+var Gauge = defineGrafanaItemClass("Gauge", Panel).with((builder) => definePanel(builder, "gauge", FieldConfigCustomGauge, PanelOptionsGauge, { onInit: (instance) => {
+	instance.fieldConfig.defaults.setColorMode("palette-classic");
+} })).asClass;
+//#endregion
+//#region src/items/Geomap.js
+var Geomap = defineGrafanaItemClass("Geomap", Panel).with((builder) => definePanel(builder, "geomap", FieldConfigCustomGeomap, PanelOptionsGeomap)).asClass;
+//#endregion
+//#region src/items/FieldConfigCustomStat.js
+var FieldConfigCustomStat = defineGrafanaItemClass("FieldConfigCustomStat", FieldConfigCustom).asClass;
+//#endregion
+//#region src/items/Stat.js
+var Stat = defineGrafanaItemClass("Stat", Panel).with((builder) => definePanel(builder, "stat", FieldConfigCustomStat, PanelOptionsStat, { onInit: (instance) => instance.fieldConfig.defaults.setColorMode("palette-classic") })).asClass;
+//#endregion
+//#region src/items/Table.js
+var Table = defineGrafanaItemClass("Table", Panel).with((builder) => definePanel(builder, "table", FieldConfigCustomTable, PanelOptionsTable, { onInit: (instance) => instance.withCustom((custom) => custom.setAlign("auto").setCellOptions(new FieldConfigCustomTableCellOptions(instance.metaOptions)).withCellOptions((cellOptions) => cellOptions.setType("auto")).setFooter(new FieldConfigCustomTableFooter(instance.metaOptions)).setInspect(false)) })).asClass;
+//#endregion
+//#region src/items/TimeSeries.js
+var TimeSeries = defineGrafanaItemClass("TimeSeries", Panel).with((builder) => definePanel(builder, "timeseries", FieldConfigCustomTimeSerie, PanelOptionsTimeSeries, { onInit: (instance) => instance.fieldConfig.defaults.setColorMode("palette-classic") })).defineMethod("setThresholdsStyleArea", "(): this", { code: (instance) => {
+	instance.custom.thresholdsStyle.setMode("area");
+	return instance;
+} }).asClass;
+//#endregion
+export { Annotation, Annotations, BarChart, Color, Dashboard, DataTransformation, Datasource, DatasourceInfinity, FieldConfig, FieldConfigCustom, FieldConfigCustomBarChart, FieldConfigCustomGauge, FieldConfigCustomGeomap, FieldConfigCustomTable, FieldConfigCustomTableCellOptions, FieldConfigCustomTableFooter, FieldConfigCustomTimeSerie, FieldConfigDefault, FieldConfigOverride, Gauge, Geomap, GrafanaItem, GridPos, HideFrom, Influxdb, LineStyle, Link, Mapping, OverrideMatcher, OverrideMatcherOptionsByNames, OverrideProperty, Panel, PanelOptions, PanelOptionsBarChart, PanelOptionsGauge, PanelOptionsGaugeEffect, PanelOptionsGaugeReduceOptions, PanelOptionsGeomap, PanelOptionsGeomapBasemap, PanelOptionsGeomapControls, PanelOptionsGeomapLayer, PanelOptionsGeomapLayerConfig, PanelOptionsGeomapLayerConfigStyle, PanelOptionsGeomapLayerLocation, PanelOptionsGeomapTooltip, PanelOptionsGeomapView, PanelOptionsStat, PanelOptionsTable, PanelOptionsTableSortBy, PanelOptionsText, PanelOptionsTextCode, PanelOptionsTimeSeries, ScaleDistribution, Stacking, Stat, StyleColor, StyleRotation, StyleSize, StyleSymbol, StyleSymbolAlign, StyleTextConfig, Table, Target, TargetInfinity, Template, TemplateCurrent, TemplateOption, Templating, Testdata, TextPanel, ThresholdStyle, Thresholds, ThresholdsStep, TimePicker, TimeRange, TimeSeries, VizLegendOptions, VizTextDisplayOptions, VizTooltipOptions };
+
+//# sourceMappingURL=index.js.map