// Automatically generated from ./ucentral.schema.pretty.json - do not edit!
"use strict";

function matchUcCidr4(value) {
	let m = match(value, /^(auto|[0-9.]+)\/([0-9]+)$/);
	return m ? ((m[1] == "auto" || length(iptoarr(m[1])) == 4) && +m[2] <= 32) : false;
}

function matchUcCidr6(value) {
	let m = match(value, /^(auto|[0-9a-fA-F:.]+)\/([0-9]+)$/);
	return m ? ((m[1] == "auto" || length(iptoarr(m[1])) == 16) && +m[2] <= 128) : false;
}

function matchUcCidr(value) {
	let m = match(value, /^(auto|[0-9a-fA-F:.]+)\/([0-9]+)$/);
	if (!m) return false;
	let l = (m[1] == "auto") ? 16 : length(iptoarr(m[1]));
	return (l > 0 && +m[2] <= (l * 8));
}

function matchUcMac(value) {
	return match(value, /^[0-9a-f][0-9a-f]:[0-9a-f][0-9a-f]:[0-9a-f][0-9a-f]:[0-9a-f][0-9a-f]:[0-9a-f][0-9a-f]:[0-9a-f][0-9a-f]$/i);
}

function matchUcHost(value) {
	if (length(iptoarr(value)) != 0) return true;
	if (length(value) > 255) return false;
	let labels = split(value, ".");
	return (length(filter(labels, label => !match(label, /^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/))) == 0 && length(labels) > 0);
}

function matchUcTimeout(value) {
	return match(value, /^[0-9]+[smhdw]$/);
}

function matchUcBase64(value) {
	return b64dec(value) != null;
}

function matchUcPortrange(value) {
	let ports = match(value, /^([0-9]|[1-9][0-9]*)(-([0-9]|[1-9][0-9]*))?$/);
	if (!ports) return false;
	let min = +ports[1], max = ports[2] ? +ports[3] : min;
	return (min <= 65535 && max <= 65535 && max >= min);
}

function matchHostname(value) {
	if (length(value) > 255) return false;
	let labels = split(value, ".");
	return (length(filter(labels, label => !match(label, /^([a-zA-Z0-9]{1,2}|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/))) == 0 && length(labels) > 0);
}

function matchUcFqdn(value) {
	if (length(value) > 255) return false;
	let labels = split(value, ".");
	return (length(filter(labels, label => !match(label, /^([a-zA-Z0-9]{1,2}|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/))) == 0 && length(labels) > 1);
}

function matchUcIp(value) {
	return (length(iptoarr(value)) == 4 || length(iptoarr(value)) == 16);
}

function matchIpv4(value) {
	return (length(iptoarr(value)) == 4);
}

function matchIpv6(value) {
	return (length(iptoarr(value)) == 16);
}

function matchUri(value) {
	if (index(value, "data:") == 0) return true;
	let m = match(value, /^[a-z+-]+:\/\/([^\/]+).*$/);
	if (!m) return false;
	if (length(iptoarr(m[1])) != 0) return true;
	if (length(m[1]) > 255) return false;
	let labels = split(m[1], ".");
	return (length(filter(labels, label => !match(label, /^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/))) == 0 && length(labels) > 0);
}

function instantiateUnit(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "name")) {
			obj.name = parseName(location + "/name", value["name"], errors);
		}

		function parseHostname(location, value, errors) {
			if (type(value) == "string") {
				if (!matchHostname(value))
					push(errors, [ location, "must be a valid hostname" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "hostname")) {
			obj.hostname = parseHostname(location + "/hostname", value["hostname"], errors);
		}

		function parseLocation(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "location")) {
			obj.location = parseLocation(location + "/location", value["location"], errors);
		}

		function parseTimezone(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "timezone")) {
			obj.timezone = parseTimezone(location + "/timezone", value["timezone"], errors);
		}

		function parseLedsActive(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "leds-active")) {
			obj.leds_active = parseLedsActive(location + "/leds-active", value["leds-active"], errors);
		}
		else {
			obj.leds_active = true;
		}

		function parseRandomPassword(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "random-password")) {
			obj.random_password = parseRandomPassword(location + "/random-password", value["random-password"], errors);
		}
		else {
			obj.random_password = false;
		}

		function parseSystemPassword(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "system-password")) {
			obj.system_password = parseSystemPassword(location + "/system-password", value["system-password"], errors);
		}

		function parseBeaconAdvertisement(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseDeviceName(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "device-name")) {
					obj.device_name = parseDeviceName(location + "/device-name", value["device-name"], errors);
				}

				function parseDeviceSerial(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "device-serial")) {
					obj.device_serial = parseDeviceSerial(location + "/device-serial", value["device-serial"], errors);
				}

				function parseNetworkId(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "network-id")) {
					obj.network_id = parseNetworkId(location + "/network-id", value["network-id"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "beacon-advertisement")) {
			obj.beacon_advertisement = parseBeaconAdvertisement(location + "/beacon-advertisement", value["beacon-advertisement"], errors);
		}

		function parsePoe(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parsePowerManagement(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "power-management")) {
					obj.power_management = parsePowerManagement(location + "/power-management", value["power-management"], errors);
				}

				function parseUsageThreshold(location, value, errors) {
					if (!(type(value) in [ "int", "double" ]))
						push(errors, [ location, "must be of type number" ]);

					return value;
				}

				if (exists(value, "usage-threshold")) {
					obj.usage_threshold = parseUsageThreshold(location + "/usage-threshold", value["usage-threshold"], errors);
				}
				else {
					obj.usage_threshold = 90;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "poe")) {
			obj.poe = parsePoe(location + "/poe", value["poe"], errors);
		}

		function parseMulticast(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseIgmpSnoopingEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "igmp-snooping-enable")) {
					obj.igmp_snooping_enable = parseIgmpSnoopingEnable(location + "/igmp-snooping-enable", value["igmp-snooping-enable"], errors);
				}
				else {
					obj.igmp_snooping_enable = true;
				}

				function parseMldSnoopingEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "mld-snooping-enable")) {
					obj.mld_snooping_enable = parseMldSnoopingEnable(location + "/mld-snooping-enable", value["mld-snooping-enable"], errors);
				}
				else {
					obj.mld_snooping_enable = true;
				}

				function parseUnknownMulticastFloodControl(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "unknown-multicast-flood-control")) {
					obj.unknown_multicast_flood_control = parseUnknownMulticastFloodControl(location + "/unknown-multicast-flood-control", value["unknown-multicast-flood-control"], errors);
				}
				else {
					obj.unknown_multicast_flood_control = false;
				}

				function parseQuerierEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "querier-enable")) {
					obj.querier_enable = parseQuerierEnable(location + "/querier-enable", value["querier-enable"], errors);
				}
				else {
					obj.querier_enable = false;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "multicast")) {
			obj.multicast = parseMulticast(location + "/multicast", value["multicast"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateGlobals(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseIpv4Network(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcCidr4(value))
					push(errors, [ location, "must be a valid IPv4 CIDR" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "ipv4-network")) {
			obj.ipv4_network = parseIpv4Network(location + "/ipv4-network", value["ipv4-network"], errors);
		}

		function parseIpv6Network(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcCidr6(value))
					push(errors, [ location, "must be a valid IPv6 CIDR" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "ipv6-network")) {
			obj.ipv6_network = parseIpv6Network(location + "/ipv6-network", value["ipv6-network"], errors);
		}

		function parseIpv4Blackhole(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parsePrefix(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcCidr4(value))
									push(errors, [ location, "must be a valid IPv4 CIDR" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "prefix")) {
							obj.prefix = parsePrefix(location + "/prefix", value["prefix"], errors);
						}

						function parseVrf(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "vrf")) {
							obj.vrf = parseVrf(location + "/vrf", value["vrf"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "ipv4-blackhole")) {
			obj.ipv4_blackhole = parseIpv4Blackhole(location + "/ipv4-blackhole", value["ipv4-blackhole"], errors);
		}

		function parseIpv4Unreachable(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parsePrefix(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcCidr4(value))
									push(errors, [ location, "must be a valid IPv4 CIDR" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "prefix")) {
							obj.prefix = parsePrefix(location + "/prefix", value["prefix"], errors);
						}

						function parseVrf(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "vrf")) {
							obj.vrf = parseVrf(location + "/vrf", value["vrf"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "ipv4-unreachable")) {
			obj.ipv4_unreachable = parseIpv4Unreachable(location + "/ipv4-unreachable", value["ipv4-unreachable"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateEthernet(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseSelectPorts(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "select-ports")) {
			obj.select_ports = parseSelectPorts(location + "/select-ports", value["select-ports"], errors);
		}

		function parseName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "name")) {
			obj.name = parseName(location + "/name", value["name"], errors);
		}

		function parseSpeed(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			if (!(value in [ 10, 100, 1000, 2500, 5000, 10000, 25000, 40000, 50000, 100000, 200000 ]))
				push(errors, [ location, "must be one of 10, 100, 1000, 2500, 5000, 10000, 25000, 40000, 50000, 100000 or 200000" ]);

			return value;
		}

		if (exists(value, "speed")) {
			obj.speed = parseSpeed(location + "/speed", value["speed"], errors);
		}
		else {
			obj.speed = 1000;
		}

		function parseDuplex(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "half", "full" ]))
				push(errors, [ location, "must be one of \"half\" or \"full\"" ]);

			return value;
		}

		if (exists(value, "duplex")) {
			obj.duplex = parseDuplex(location + "/duplex", value["duplex"], errors);
		}
		else {
			obj.duplex = "full";
		}

		function parseEnabled(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enabled")) {
			obj.enabled = parseEnabled(location + "/enabled", value["enabled"], errors);
		}
		else {
			obj.enabled = true;
		}

		function parseServices(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "services")) {
			obj.services = parseServices(location + "/services", value["services"], errors);
		}

		function parsePoe(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseAdminMode(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "admin-mode")) {
					obj.admin_mode = parseAdminMode(location + "/admin-mode", value["admin-mode"], errors);
				}
				else {
					obj.admin_mode = false;
				}

				function parseDoReset(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "do-reset")) {
					obj.do_reset = parseDoReset(location + "/do-reset", value["do-reset"], errors);
				}

				function parseDetection(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "detection")) {
					obj.detection = parseDetection(location + "/detection", value["detection"], errors);
				}
				else {
					obj.detection = "dot3bt";
				}

				function parsePowerLimit(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "power-limit")) {
					obj.power_limit = parsePowerLimit(location + "/power-limit", value["power-limit"], errors);
				}
				else {
					obj.power_limit = 99900;
				}

				function parsePriority(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "priority")) {
					obj.priority = parsePriority(location + "/priority", value["priority"], errors);
				}
				else {
					obj.priority = "low";
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "poe")) {
			obj.poe = parsePoe(location + "/poe", value["poe"], errors);
		}

		function parseIeee8021x(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseIsAuthenticator(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "is-authenticator")) {
					obj.is_authenticator = parseIsAuthenticator(location + "/is-authenticator", value["is-authenticator"], errors);
				}
				else {
					obj.is_authenticator = false;
				}

				function parseAuthenticationMode(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "force-authorized", "force-unauthorized", "auto" ]))
						push(errors, [ location, "must be one of \"force-authorized\", \"force-unauthorized\" or \"auto\"" ]);

					return value;
				}

				if (exists(value, "authentication-mode")) {
					obj.authentication_mode = parseAuthenticationMode(location + "/authentication-mode", value["authentication-mode"], errors);
				}
				else {
					obj.authentication_mode = "force-authorized";
				}

				function parseHostMode(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "multi-auth", "multi-domain", "multi-host", "single-host" ]))
						push(errors, [ location, "must be one of \"multi-auth\", \"multi-domain\", \"multi-host\" or \"single-host\"" ]);

					return value;
				}

				if (exists(value, "host-mode")) {
					obj.host_mode = parseHostMode(location + "/host-mode", value["host-mode"], errors);
				}
				else {
					obj.host_mode = "multi-auth";
				}

				function parseGuestVlan(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 4094)
							push(errors, [ location, "must be lower than or equal to 4094" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "guest-vlan")) {
					obj.guest_vlan = parseGuestVlan(location + "/guest-vlan", value["guest-vlan"], errors);
				}

				function parseUnauthenticatedVlan(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 4094)
							push(errors, [ location, "must be lower than or equal to 4094" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "unauthenticated-vlan")) {
					obj.unauthenticated_vlan = parseUnauthenticatedVlan(location + "/unauthenticated-vlan", value["unauthenticated-vlan"], errors);
				}

				function parseMacAddressBypass(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "mac-address-bypass")) {
					obj.mac_address_bypass = parseMacAddressBypass(location + "/mac-address-bypass", value["mac-address-bypass"], errors);
				}

				function parseMacAddressBypassTimeoutMinutes(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "mac-address-bypass-timeout-minutes")) {
					obj.mac_address_bypass_timeout_minutes = parseMacAddressBypassTimeoutMinutes(location + "/mac-address-bypass-timeout-minutes", value["mac-address-bypass-timeout-minutes"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "ieee8021x")) {
			obj.ieee8021x = parseIeee8021x(location + "/ieee8021x", value["ieee8021x"], errors);
		}

		function parseTrunkGroup(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 64)
					push(errors, [ location, "must be lower than or equal to 64" ]);

				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "trunk-group")) {
			obj.trunk_group = parseTrunkGroup(location + "/trunk-group", value["trunk-group"], errors);
		}

		function parseLacpConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseLacpEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lacp-enable")) {
					obj.lacp_enable = parseLacpEnable(location + "/lacp-enable", value["lacp-enable"], errors);
				}
				else {
					obj.lacp_enable = false;
				}

				function parseLacpRole(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "actor", "partner" ]))
						push(errors, [ location, "must be one of \"actor\" or \"partner\"" ]);

					return value;
				}

				if (exists(value, "lacp-role")) {
					obj.lacp_role = parseLacpRole(location + "/lacp-role", value["lacp-role"], errors);
				}
				else {
					obj.lacp_role = "actor";
				}

				function parseLacpMode(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "active", "passive" ]))
						push(errors, [ location, "must be one of \"active\" or \"passive\"" ]);

					return value;
				}

				if (exists(value, "lacp-mode")) {
					obj.lacp_mode = parseLacpMode(location + "/lacp-mode", value["lacp-mode"], errors);
				}
				else {
					obj.lacp_mode = "passive";
				}

				function parseLacpPortAdminKey(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lacp-port-admin-key")) {
					obj.lacp_port_admin_key = parseLacpPortAdminKey(location + "/lacp-port-admin-key", value["lacp-port-admin-key"], errors);
				}
				else {
					obj.lacp_port_admin_key = 1;
				}

				function parseLacpPortPriority(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lacp-port-priority")) {
					obj.lacp_port_priority = parseLacpPortPriority(location + "/lacp-port-priority", value["lacp-port-priority"], errors);
				}
				else {
					obj.lacp_port_priority = 32768;
				}

				function parseLacpSystemPriority(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lacp-system-priority")) {
					obj.lacp_system_priority = parseLacpSystemPriority(location + "/lacp-system-priority", value["lacp-system-priority"], errors);
				}
				else {
					obj.lacp_system_priority = 32768;
				}

				function parseLacpPchanAdminKey(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lacp-pchan-admin-key")) {
					obj.lacp_pchan_admin_key = parseLacpPchanAdminKey(location + "/lacp-pchan-admin-key", value["lacp-pchan-admin-key"], errors);
				}

				function parseLacpTimeout(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "short", "long" ]))
						push(errors, [ location, "must be one of \"short\" or \"long\"" ]);

					return value;
				}

				if (exists(value, "lacp-timeout")) {
					obj.lacp_timeout = parseLacpTimeout(location + "/lacp-timeout", value["lacp-timeout"], errors);
				}
				else {
					obj.lacp_timeout = "long";
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "lacp-config")) {
			obj.lacp_config = parseLacpConfig(location + "/lacp-config", value["lacp-config"], errors);
		}

		function parseLldpInterfaceConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseLldpAdminStatus(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "rx", "tx", "rx-tx" ]))
						push(errors, [ location, "must be one of \"rx\", \"tx\" or \"rx-tx\"" ]);

					return value;
				}

				if (exists(value, "lldp-admin-status")) {
					obj.lldp_admin_status = parseLldpAdminStatus(location + "/lldp-admin-status", value["lldp-admin-status"], errors);
				}

				function parseLldpBasicTlvMgmtIpV4(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-basic-tlv-mgmt-ip-v4")) {
					obj.lldp_basic_tlv_mgmt_ip_v4 = parseLldpBasicTlvMgmtIpV4(location + "/lldp-basic-tlv-mgmt-ip-v4", value["lldp-basic-tlv-mgmt-ip-v4"], errors);
				}
				else {
					obj.lldp_basic_tlv_mgmt_ip_v4 = true;
				}

				function parseLldpBasicTlvMgmtIpV6(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-basic-tlv-mgmt-ip-v6")) {
					obj.lldp_basic_tlv_mgmt_ip_v6 = parseLldpBasicTlvMgmtIpV6(location + "/lldp-basic-tlv-mgmt-ip-v6", value["lldp-basic-tlv-mgmt-ip-v6"], errors);
				}
				else {
					obj.lldp_basic_tlv_mgmt_ip_v6 = false;
				}

				function parseLldpBasicTlvPortDescr(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-basic-tlv-port-descr")) {
					obj.lldp_basic_tlv_port_descr = parseLldpBasicTlvPortDescr(location + "/lldp-basic-tlv-port-descr", value["lldp-basic-tlv-port-descr"], errors);
				}
				else {
					obj.lldp_basic_tlv_port_descr = true;
				}

				function parseLldpBasicTlvSysCapab(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-basic-tlv-sys-capab")) {
					obj.lldp_basic_tlv_sys_capab = parseLldpBasicTlvSysCapab(location + "/lldp-basic-tlv-sys-capab", value["lldp-basic-tlv-sys-capab"], errors);
				}
				else {
					obj.lldp_basic_tlv_sys_capab = true;
				}

				function parseLldpBasicTlvSysDescr(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-basic-tlv-sys-descr")) {
					obj.lldp_basic_tlv_sys_descr = parseLldpBasicTlvSysDescr(location + "/lldp-basic-tlv-sys-descr", value["lldp-basic-tlv-sys-descr"], errors);
				}
				else {
					obj.lldp_basic_tlv_sys_descr = true;
				}

				function parseLldpBasicTlvSysName(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-basic-tlv-sys-name")) {
					obj.lldp_basic_tlv_sys_name = parseLldpBasicTlvSysName(location + "/lldp-basic-tlv-sys-name", value["lldp-basic-tlv-sys-name"], errors);
				}
				else {
					obj.lldp_basic_tlv_sys_name = true;
				}

				function parseLldpDot1TlvProtoIdent(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot1-tlv-proto-ident")) {
					obj.lldp_dot1_tlv_proto_ident = parseLldpDot1TlvProtoIdent(location + "/lldp-dot1-tlv-proto-ident", value["lldp-dot1-tlv-proto-ident"], errors);
				}
				else {
					obj.lldp_dot1_tlv_proto_ident = true;
				}

				function parseLldpDot1TlvProtoVid(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot1-tlv-proto-vid")) {
					obj.lldp_dot1_tlv_proto_vid = parseLldpDot1TlvProtoVid(location + "/lldp-dot1-tlv-proto-vid", value["lldp-dot1-tlv-proto-vid"], errors);
				}
				else {
					obj.lldp_dot1_tlv_proto_vid = true;
				}

				function parseLldpDot1TlvPvid(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot1-tlv-pvid")) {
					obj.lldp_dot1_tlv_pvid = parseLldpDot1TlvPvid(location + "/lldp-dot1-tlv-pvid", value["lldp-dot1-tlv-pvid"], errors);
				}
				else {
					obj.lldp_dot1_tlv_pvid = true;
				}

				function parseLldpDot1TlvVlanName(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot1-tlv-vlan-name")) {
					obj.lldp_dot1_tlv_vlan_name = parseLldpDot1TlvVlanName(location + "/lldp-dot1-tlv-vlan-name", value["lldp-dot1-tlv-vlan-name"], errors);
				}
				else {
					obj.lldp_dot1_tlv_vlan_name = true;
				}

				function parseLldpDot3TlvLinkAgg(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot3-tlv-link-agg")) {
					obj.lldp_dot3_tlv_link_agg = parseLldpDot3TlvLinkAgg(location + "/lldp-dot3-tlv-link-agg", value["lldp-dot3-tlv-link-agg"], errors);
				}
				else {
					obj.lldp_dot3_tlv_link_agg = true;
				}

				function parseLldpDot3TlvMacPhy(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot3-tlv-mac-phy")) {
					obj.lldp_dot3_tlv_mac_phy = parseLldpDot3TlvMacPhy(location + "/lldp-dot3-tlv-mac-phy", value["lldp-dot3-tlv-mac-phy"], errors);
				}
				else {
					obj.lldp_dot3_tlv_mac_phy = true;
				}

				function parseLldpDot3TlvMaxFrame(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot3-tlv-max-frame")) {
					obj.lldp_dot3_tlv_max_frame = parseLldpDot3TlvMaxFrame(location + "/lldp-dot3-tlv-max-frame", value["lldp-dot3-tlv-max-frame"], errors);
				}
				else {
					obj.lldp_dot3_tlv_max_frame = true;
				}

				function parseLldpDot3TlvPoe(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-dot3-tlv-poe")) {
					obj.lldp_dot3_tlv_poe = parseLldpDot3TlvPoe(location + "/lldp-dot3-tlv-poe", value["lldp-dot3-tlv-poe"], errors);
				}
				else {
					obj.lldp_dot3_tlv_poe = true;
				}

				function parseLldpMedLocationCivicAddr(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseLldpMedLocationCivicAddrAdminStatus(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "lldp-med-location-civic-addr-admin-status")) {
							obj.lldp_med_location_civic_addr_admin_status = parseLldpMedLocationCivicAddrAdminStatus(location + "/lldp-med-location-civic-addr-admin-status", value["lldp-med-location-civic-addr-admin-status"], errors);
						}
						else {
							obj.lldp_med_location_civic_addr_admin_status = false;
						}

						function parseLldpMedLocationCivicCountryCode(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "lldp-med-location-civic-country-code")) {
							obj.lldp_med_location_civic_country_code = parseLldpMedLocationCivicCountryCode(location + "/lldp-med-location-civic-country-code", value["lldp-med-location-civic-country-code"], errors);
						}

						function parseLldpMedLocationCivicDeviceType(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "lldp-med-location-civic-device-type")) {
							obj.lldp_med_location_civic_device_type = parseLldpMedLocationCivicDeviceType(location + "/lldp-med-location-civic-device-type", value["lldp-med-location-civic-device-type"], errors);
						}

						function parseLldpMedLocationCivicCa(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseLldpMedLocationCivicCaType(location, value, errors) {
											if (type(value) in [ "int", "double" ]) {
												if (value > 255)
													push(errors, [ location, "must be lower than or equal to 255" ]);

												if (value < 0)
													push(errors, [ location, "must be bigger than or equal to 0" ]);

											}

											if (type(value) != "int")
												push(errors, [ location, "must be of type integer" ]);

											return value;
										}

										if (exists(value, "lldp-med-location-civic-ca-type")) {
											obj.lldp_med_location_civic_ca_type = parseLldpMedLocationCivicCaType(location + "/lldp-med-location-civic-ca-type", value["lldp-med-location-civic-ca-type"], errors);
										}

										function parseLldpMedLocationCivicCaValue(location, value, errors) {
											if (type(value) == "string") {
												if (length(value) > 32)
													push(errors, [ location, "must be at most 32 characters long" ]);

												if (length(value) < 1)
													push(errors, [ location, "must be at least 1 characters long" ]);

											}

											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											return value;
										}

										if (exists(value, "lldp-med-location-civic-ca-value")) {
											obj.lldp_med_location_civic_ca_value = parseLldpMedLocationCivicCaValue(location + "/lldp-med-location-civic-ca-value", value["lldp-med-location-civic-ca-value"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "lldp-med-location-civic-ca")) {
							obj.lldp_med_location_civic_ca = parseLldpMedLocationCivicCa(location + "/lldp-med-location-civic-ca", value["lldp-med-location-civic-ca"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				if (exists(value, "lldp-med-location-civic-addr")) {
					obj.lldp_med_location_civic_addr = parseLldpMedLocationCivicAddr(location + "/lldp-med-location-civic-addr", value["lldp-med-location-civic-addr"], errors);
				}

				function parseLldpMedNotification(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-med-notification")) {
					obj.lldp_med_notification = parseLldpMedNotification(location + "/lldp-med-notification", value["lldp-med-notification"], errors);
				}
				else {
					obj.lldp_med_notification = false;
				}

				function parseLldpMedTlvExtPoe(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-med-tlv-ext-poe")) {
					obj.lldp_med_tlv_ext_poe = parseLldpMedTlvExtPoe(location + "/lldp-med-tlv-ext-poe", value["lldp-med-tlv-ext-poe"], errors);
				}
				else {
					obj.lldp_med_tlv_ext_poe = true;
				}

				function parseLldpMedTlvInventory(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-med-tlv-inventory")) {
					obj.lldp_med_tlv_inventory = parseLldpMedTlvInventory(location + "/lldp-med-tlv-inventory", value["lldp-med-tlv-inventory"], errors);
				}
				else {
					obj.lldp_med_tlv_inventory = true;
				}

				function parseLldpMedTlvLocation(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-med-tlv-location")) {
					obj.lldp_med_tlv_location = parseLldpMedTlvLocation(location + "/lldp-med-tlv-location", value["lldp-med-tlv-location"], errors);
				}
				else {
					obj.lldp_med_tlv_location = true;
				}

				function parseLldpMedTlvMedCap(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-med-tlv-med-cap")) {
					obj.lldp_med_tlv_med_cap = parseLldpMedTlvMedCap(location + "/lldp-med-tlv-med-cap", value["lldp-med-tlv-med-cap"], errors);
				}
				else {
					obj.lldp_med_tlv_med_cap = true;
				}

				function parseLldpMedTlvNetworkPolicy(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-med-tlv-network-policy")) {
					obj.lldp_med_tlv_network_policy = parseLldpMedTlvNetworkPolicy(location + "/lldp-med-tlv-network-policy", value["lldp-med-tlv-network-policy"], errors);
				}
				else {
					obj.lldp_med_tlv_network_policy = true;
				}

				function parseLldpNotification(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-notification")) {
					obj.lldp_notification = parseLldpNotification(location + "/lldp-notification", value["lldp-notification"], errors);
				}
				else {
					obj.lldp_notification = false;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "lldp-interface-config")) {
			obj.lldp_interface_config = parseLldpInterfaceConfig(location + "/lldp-interface-config", value["lldp-interface-config"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateSwitch(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parsePortMirror(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseMonitorPorts(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "monitor-ports")) {
							obj.monitor_ports = parseMonitorPorts(location + "/monitor-ports", value["monitor-ports"], errors);
						}

						function parseAnalysisPort(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "analysis-port")) {
							obj.analysis_port = parseAnalysisPort(location + "/analysis-port", value["analysis-port"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "port-mirror")) {
			obj.port_mirror = parsePortMirror(location + "/port-mirror", value["port-mirror"], errors);
		}

		function parseLoopDetection(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseProtocol(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "none", "stp", "rstp", "mstp", "pvstp", "rpvstp" ]))
						push(errors, [ location, "must be one of \"none\", \"stp\", \"rstp\", \"mstp\", \"pvstp\" or \"rpvstp\"" ]);

					return value;
				}

				if (exists(value, "protocol")) {
					obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
				}
				else {
					obj.protocol = "rstp";
				}

				function parseRoles(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "upstream", "downstream" ]))
								push(errors, [ location, "must be one of \"upstream\" or \"downstream\"" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "roles")) {
					obj.roles = parseRoles(location + "/roles", value["roles"], errors);
				}

				function parseInstances(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) == "object") {
								let obj = {};

								function parseId(location, value, errors) {
									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "id")) {
									obj.id = parseId(location + "/id", value["id"], errors);
								}

								function parseEnabled(location, value, errors) {
									if (type(value) != "bool")
										push(errors, [ location, "must be of type boolean" ]);

									return value;
								}

								if (exists(value, "enabled")) {
									obj.enabled = parseEnabled(location + "/enabled", value["enabled"], errors);
								}
								else {
									obj.enabled = true;
								}

								function parsePriority(location, value, errors) {
									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "priority")) {
									obj.priority = parsePriority(location + "/priority", value["priority"], errors);
								}
								else {
									obj.priority = 32768;
								}

								function parseForward_delay(location, value, errors) {
									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "forward_delay")) {
									obj.forward_delay = parseForward_delay(location + "/forward_delay", value["forward_delay"], errors);
								}
								else {
									obj.forward_delay = 15;
								}

								function parseHello_time(location, value, errors) {
									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "hello_time")) {
									obj.hello_time = parseHello_time(location + "/hello_time", value["hello_time"], errors);
								}
								else {
									obj.hello_time = 2;
								}

								function parseMax_age(location, value, errors) {
									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "max_age")) {
									obj.max_age = parseMax_age(location + "/max_age", value["max_age"], errors);
								}
								else {
									obj.max_age = 20;
								}

								return obj;
							}

							if (type(value) != "object")
								push(errors, [ location, "must be of type object" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "instances")) {
					obj.instances = parseInstances(location + "/instances", value["instances"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "loop-detection")) {
			obj.loop_detection = parseLoopDetection(location + "/loop-detection", value["loop-detection"], errors);
		}

		function parseIeee8021x(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseAuthControlEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "auth-control-enable")) {
					obj.auth_control_enable = parseAuthControlEnable(location + "/auth-control-enable", value["auth-control-enable"], errors);
				}
				else {
					obj.auth_control_enable = false;
				}

				function parseRadius(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) == "object") {
								let obj = {};

								function parseServerHost(location, value, errors) {
									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								if (exists(value, "server-host")) {
									obj.server_host = parseServerHost(location + "/server-host", value["server-host"], errors);
								}

								function parseServerAuthenticationPort(location, value, errors) {
									if (type(value) in [ "int", "double" ]) {
										if (value > 65535)
											push(errors, [ location, "must be lower than or equal to 65535" ]);

										if (value < 1)
											push(errors, [ location, "must be bigger than or equal to 1" ]);

									}

									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "server-authentication-port")) {
									obj.server_authentication_port = parseServerAuthenticationPort(location + "/server-authentication-port", value["server-authentication-port"], errors);
								}

								function parseServerKey(location, value, errors) {
									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								if (exists(value, "server-key")) {
									obj.server_key = parseServerKey(location + "/server-key", value["server-key"], errors);
								}

								function parseServerPriority(location, value, errors) {
									if (type(value) in [ "int", "double" ]) {
										if (value > 64)
											push(errors, [ location, "must be lower than or equal to 64" ]);

										if (value < 1)
											push(errors, [ location, "must be bigger than or equal to 1" ]);

									}

									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "server-priority")) {
									obj.server_priority = parseServerPriority(location + "/server-priority", value["server-priority"], errors);
								}

								return obj;
							}

							if (type(value) != "object")
								push(errors, [ location, "must be of type object" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "radius")) {
					obj.radius = parseRadius(location + "/radius", value["radius"], errors);
				}

				function parseDynamicAuthorization(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseAuthType(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "all", "any", "session-key" ]))
								push(errors, [ location, "must be one of \"all\", \"any\" or \"session-key\"" ]);

							return value;
						}

						if (exists(value, "auth-type")) {
							obj.auth_type = parseAuthType(location + "/auth-type", value["auth-type"], errors);
						}

						function parseBouncePortIgnore(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "bounce-port-ignore")) {
							obj.bounce_port_ignore = parseBouncePortIgnore(location + "/bounce-port-ignore", value["bounce-port-ignore"], errors);
						}
						else {
							obj.bounce_port_ignore = false;
						}

						function parseDisablePortIgnore(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "disable-port-ignore")) {
							obj.disable_port_ignore = parseDisablePortIgnore(location + "/disable-port-ignore", value["disable-port-ignore"], errors);
						}
						else {
							obj.disable_port_ignore = false;
						}

						function parseIgnoreServerKey(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "ignore-server-key")) {
							obj.ignore_server_key = parseIgnoreServerKey(location + "/ignore-server-key", value["ignore-server-key"], errors);
						}
						else {
							obj.ignore_server_key = false;
						}

						function parseIgnoreSessionKey(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "ignore-session-key")) {
							obj.ignore_session_key = parseIgnoreSessionKey(location + "/ignore-session-key", value["ignore-session-key"], errors);
						}
						else {
							obj.ignore_session_key = false;
						}

						function parseServerKey(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "server-key")) {
							obj.server_key = parseServerKey(location + "/server-key", value["server-key"], errors);
						}

						function parseClient(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseAddress(location, value, errors) {
											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											return value;
										}

										if (exists(value, "address")) {
											obj.address = parseAddress(location + "/address", value["address"], errors);
										}

										function parseServerKey(location, value, errors) {
											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											return value;
										}

										if (exists(value, "server-key")) {
											obj.server_key = parseServerKey(location + "/server-key", value["server-key"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "client")) {
							obj.client = parseClient(location + "/client", value["client"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				if (exists(value, "dynamic-authorization")) {
					obj.dynamic_authorization = parseDynamicAuthorization(location + "/dynamic-authorization", value["dynamic-authorization"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "ieee8021x")) {
			obj.ieee8021x = parseIeee8021x(location + "/ieee8021x", value["ieee8021x"], errors);
		}

		function parsePortIsolation(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseSessions(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) == "object") {
								let obj = {};

								function parseId(location, value, errors) {
									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "id")) {
									obj.id = parseId(location + "/id", value["id"], errors);
								}

								function parseUplink(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseInterfaceList(location, value, errors) {
											if (type(value) == "array") {
												function parseItem(location, value, errors) {
													if (type(value) != "string")
														push(errors, [ location, "must be of type string" ]);

													return value;
												}

												return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
											}

											if (type(value) != "array")
												push(errors, [ location, "must be of type array" ]);

											return value;
										}

										if (exists(value, "interface-list")) {
											obj.interface_list = parseInterfaceList(location + "/interface-list", value["interface-list"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								if (exists(value, "uplink")) {
									obj.uplink = parseUplink(location + "/uplink", value["uplink"], errors);
								}

								function parseDownlink(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseInterfaceList(location, value, errors) {
											if (type(value) == "array") {
												function parseItem(location, value, errors) {
													if (type(value) != "string")
														push(errors, [ location, "must be of type string" ]);

													return value;
												}

												return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
											}

											if (type(value) != "array")
												push(errors, [ location, "must be of type array" ]);

											return value;
										}

										if (exists(value, "interface-list")) {
											obj.interface_list = parseInterfaceList(location + "/interface-list", value["interface-list"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								if (exists(value, "downlink")) {
									obj.downlink = parseDownlink(location + "/downlink", value["downlink"], errors);
								}

								return obj;
							}

							if (type(value) != "object")
								push(errors, [ location, "must be of type object" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "sessions")) {
					obj.sessions = parseSessions(location + "/sessions", value["sessions"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "port-isolation")) {
			obj.port_isolation = parsePortIsolation(location + "/port-isolation", value["port-isolation"], errors);
		}

		function parseTrunkBalanceMethod(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "dst-ip", "dst-mac", "src-dst-ip", "src-dst-mac", "src-ip", "src-mac" ]))
				push(errors, [ location, "must be one of \"dst-ip\", \"dst-mac\", \"src-dst-ip\", \"src-dst-mac\", \"src-ip\" or \"src-mac\"" ]);

			return value;
		}

		if (exists(value, "trunk-balance-method")) {
			obj.trunk_balance_method = parseTrunkBalanceMethod(location + "/trunk-balance-method", value["trunk-balance-method"], errors);
		}
		else {
			obj.trunk_balance_method = "src-dst-mac";
		}

		function parseJumboFrames(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "jumbo-frames")) {
			obj.jumbo_frames = parseJumboFrames(location + "/jumbo-frames", value["jumbo-frames"], errors);
		}
		else {
			obj.jumbo_frames = false;
		}

		function parseDhcpSnooping(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseDhcpSnoopEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-enable")) {
					obj.dhcp_snoop_enable = parseDhcpSnoopEnable(location + "/dhcp-snoop-enable", value["dhcp-snoop-enable"], errors);
				}
				else {
					obj.dhcp_snoop_enable = false;
				}

				function parseDhcpSnoopRateLimit(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 2048)
							push(errors, [ location, "must be lower than or equal to 2048" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-rate-limit")) {
					obj.dhcp_snoop_rate_limit = parseDhcpSnoopRateLimit(location + "/dhcp-snoop-rate-limit", value["dhcp-snoop-rate-limit"], errors);
				}

				function parseDhcpSnoopMacVerify(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-mac-verify")) {
					obj.dhcp_snoop_mac_verify = parseDhcpSnoopMacVerify(location + "/dhcp-snoop-mac-verify", value["dhcp-snoop-mac-verify"], errors);
				}
				else {
					obj.dhcp_snoop_mac_verify = false;
				}

				function parseDhcpSnoopInfOpt82(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-inf-opt-82")) {
					obj.dhcp_snoop_inf_opt_82 = parseDhcpSnoopInfOpt82(location + "/dhcp-snoop-inf-opt-82", value["dhcp-snoop-inf-opt-82"], errors);
				}
				else {
					obj.dhcp_snoop_inf_opt_82 = false;
				}

				function parseDhcpSnoopInfOptEncodeSubopt(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-inf-opt-encode-subopt")) {
					obj.dhcp_snoop_inf_opt_encode_subopt = parseDhcpSnoopInfOptEncodeSubopt(location + "/dhcp-snoop-inf-opt-encode-subopt", value["dhcp-snoop-inf-opt-encode-subopt"], errors);
				}
				else {
					obj.dhcp_snoop_inf_opt_encode_subopt = false;
				}

				function parseDhcpSnoopInfOptRemoteid(location, value, errors) {
					if (type(value) == "string") {
						if (length(value) > 32)
							push(errors, [ location, "must be at most 32 characters long" ]);

						if (length(value) < 1)
							push(errors, [ location, "must be at least 1 characters long" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-inf-opt-remoteid")) {
					obj.dhcp_snoop_inf_opt_remoteid = parseDhcpSnoopInfOptRemoteid(location + "/dhcp-snoop-inf-opt-remoteid", value["dhcp-snoop-inf-opt-remoteid"], errors);
				}

				function parseDhcpSnoopInfOptPolicy(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "drop", "keep", "replace" ]))
						push(errors, [ location, "must be one of \"drop\", \"keep\" or \"replace\"" ]);

					return value;
				}

				if (exists(value, "dhcp-snoop-inf-opt-policy")) {
					obj.dhcp_snoop_inf_opt_policy = parseDhcpSnoopInfOptPolicy(location + "/dhcp-snoop-inf-opt-policy", value["dhcp-snoop-inf-opt-policy"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "dhcp-snooping")) {
			obj.dhcp_snooping = parseDhcpSnooping(location + "/dhcp-snooping", value["dhcp-snooping"], errors);
		}

		function parseAcl(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseAclType(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "ipv4", "ipv6", "ipv4Ext", "ipv6Ext", "mac", "arp" ]))
								push(errors, [ location, "must be one of \"ipv4\", \"ipv6\", \"ipv4Ext\", \"ipv6Ext\", \"mac\" or \"arp\"" ]);

							return value;
						}

						if (exists(value, "acl-type")) {
							obj.acl_type = parseAclType(location + "/acl-type", value["acl-type"], errors);
						}

						function parseAclName(location, value, errors) {
							if (type(value) == "string") {
								if (length(value) > 32)
									push(errors, [ location, "must be at most 32 characters long" ]);

								if (length(value) < 1)
									push(errors, [ location, "must be at least 1 characters long" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-name")) {
							obj.acl_name = parseAclName(location + "/acl-name", value["acl-name"], errors);
						}

						function parseAclRuleAction(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "permit", "deny" ]))
								push(errors, [ location, "must be one of \"permit\" or \"deny\"" ]);

							return value;
						}

						if (exists(value, "acl-rule-action")) {
							obj.acl_rule_action = parseAclRuleAction(location + "/acl-rule-action", value["acl-rule-action"], errors);
						}

						function parseAclSourceMacaddress(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcMac(value))
									push(errors, [ location, "must be a valid MAC address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-source-macaddress")) {
							obj.acl_source_macaddress = parseAclSourceMacaddress(location + "/acl-source-macaddress", value["acl-source-macaddress"], errors);
						}

						function parseAclSourceMacbitmask(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcMac(value))
									push(errors, [ location, "must be a valid MAC address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-source-macbitmask")) {
							obj.acl_source_macbitmask = parseAclSourceMacbitmask(location + "/acl-source-macbitmask", value["acl-source-macbitmask"], errors);
						}

						function parseAclDestMacaddress(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcMac(value))
									push(errors, [ location, "must be a valid MAC address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-dest-macaddress")) {
							obj.acl_dest_macaddress = parseAclDestMacaddress(location + "/acl-dest-macaddress", value["acl-dest-macaddress"], errors);
						}

						function parseAclDestMacbitmask(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcMac(value))
									push(errors, [ location, "must be a valid MAC address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-dest-macbitmask")) {
							obj.acl_dest_macbitmask = parseAclDestMacbitmask(location + "/acl-dest-macbitmask", value["acl-dest-macbitmask"], errors);
						}

						function parseAclPacketFormat(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "any", "untagged-eth2", "untagged-802.3", "tagged-eth2", "tagged-802.3" ]))
								push(errors, [ location, "must be one of \"any\", \"untagged-eth2\", \"untagged-802.3\", \"tagged-eth2\" or \"tagged-802.3\"" ]);

							return value;
						}

						if (exists(value, "acl-packet-format")) {
							obj.acl_packet_format = parseAclPacketFormat(location + "/acl-packet-format", value["acl-packet-format"], errors);
						}

						function parseAclVlanid(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 4094)
									push(errors, [ location, "must be lower than or equal to 4094" ]);

								if (value < 1)
									push(errors, [ location, "must be bigger than or equal to 1" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-vlanid")) {
							obj.acl_vlanid = parseAclVlanid(location + "/acl-vlanid", value["acl-vlanid"], errors);
						}

						function parseAclVidBitmask(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 4095)
									push(errors, [ location, "must be lower than or equal to 4095" ]);

								if (value < 1)
									push(errors, [ location, "must be bigger than or equal to 1" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-vid-bitmask")) {
							obj.acl_vid_bitmask = parseAclVidBitmask(location + "/acl-vid-bitmask", value["acl-vid-bitmask"], errors);
						}

						function parseAclEthertype(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ethertype")) {
							obj.acl_ethertype = parseAclEthertype(location + "/acl-ethertype", value["acl-ethertype"], errors);
						}
						else {
							obj.acl_ethertype = "800";
						}

						function parseAclEthertypeBitmask(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ethertype-bitmask")) {
							obj.acl_ethertype_bitmask = parseAclEthertypeBitmask(location + "/acl-ethertype-bitmask", value["acl-ethertype-bitmask"], errors);
						}
						else {
							obj.acl_ethertype_bitmask = "FFFF";
						}

						function parseAclCos(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 7)
									push(errors, [ location, "must be lower than or equal to 7" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-cos")) {
							obj.acl_cos = parseAclCos(location + "/acl-cos", value["acl-cos"], errors);
						}

						function parseAclCosBitmask(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 7)
									push(errors, [ location, "must be lower than or equal to 7" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-cos-bitmask")) {
							obj.acl_cos_bitmask = parseAclCosBitmask(location + "/acl-cos-bitmask", value["acl-cos-bitmask"], errors);
						}

						function parseAclIpv4SourceAddress(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ipv4-source-address")) {
							obj.acl_ipv4_source_address = parseAclIpv4SourceAddress(location + "/acl-ipv4-source-address", value["acl-ipv4-source-address"], errors);
						}

						function parseAclIpv4SourceSubnetmask(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ipv4-source-subnetmask")) {
							obj.acl_ipv4_source_subnetmask = parseAclIpv4SourceSubnetmask(location + "/acl-ipv4-source-subnetmask", value["acl-ipv4-source-subnetmask"], errors);
						}

						function parseAclIpv4DestAddress(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ipv4-dest-address")) {
							obj.acl_ipv4_dest_address = parseAclIpv4DestAddress(location + "/acl-ipv4-dest-address", value["acl-ipv4-dest-address"], errors);
						}

						function parseAclIpv4DestSubnetmask(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ipv4-dest-subnetmask")) {
							obj.acl_ipv4_dest_subnetmask = parseAclIpv4DestSubnetmask(location + "/acl-ipv4-dest-subnetmask", value["acl-ipv4-dest-subnetmask"], errors);
						}

						function parseAclIpv6SourceAddress(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv6(value))
									push(errors, [ location, "must be a valid IPv6 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-source-address")) {
							obj.acl_ipv6_source_address = parseAclIpv6SourceAddress(location + "/acl-ipv6-source-address", value["acl-ipv6-source-address"], errors);
						}

						function parseAclIpv6SourcePrefixLength(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 128)
									push(errors, [ location, "must be lower than or equal to 128" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-source-prefix-length")) {
							obj.acl_ipv6_source_prefix_length = parseAclIpv6SourcePrefixLength(location + "/acl-ipv6-source-prefix-length", value["acl-ipv6-source-prefix-length"], errors);
						}

						function parseAclIpv6DestAddress(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv6(value))
									push(errors, [ location, "must be a valid IPv6 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-dest-address")) {
							obj.acl_ipv6_dest_address = parseAclIpv6DestAddress(location + "/acl-ipv6-dest-address", value["acl-ipv6-dest-address"], errors);
						}

						function parseAclIpv6DestPrefixLength(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 128)
									push(errors, [ location, "must be lower than or equal to 128" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-dest-prefix-length")) {
							obj.acl_ipv6_dest_prefix_length = parseAclIpv6DestPrefixLength(location + "/acl-ipv6-dest-prefix-length", value["acl-ipv6-dest-prefix-length"], errors);
						}

						function parseAclIpProto(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 255)
									push(errors, [ location, "must be lower than or equal to 255" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ip-proto")) {
							obj.acl_ip_proto = parseAclIpProto(location + "/acl-ip-proto", value["acl-ip-proto"], errors);
						}

						function parseAclIpv6NextHeader(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 255)
									push(errors, [ location, "must be lower than or equal to 255" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-next-header")) {
							obj.acl_ipv6_next_header = parseAclIpv6NextHeader(location + "/acl-ipv6-next-header", value["acl-ipv6-next-header"], errors);
						}

						function parseAclIpv6FlowLabel(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 1048575)
									push(errors, [ location, "must be lower than or equal to 1048575" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-flow-label")) {
							obj.acl_ipv6_flow_label = parseAclIpv6FlowLabel(location + "/acl-ipv6-flow-label", value["acl-ipv6-flow-label"], errors);
						}

						function parseAclIpSourcePort(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 65535)
									push(errors, [ location, "must be lower than or equal to 65535" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ip-source-port")) {
							obj.acl_ip_source_port = parseAclIpSourcePort(location + "/acl-ip-source-port", value["acl-ip-source-port"], errors);
						}

						function parseAclIpSourcePortBitmask(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 65535)
									push(errors, [ location, "must be lower than or equal to 65535" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ip-source-port-bitmask")) {
							obj.acl_ip_source_port_bitmask = parseAclIpSourcePortBitmask(location + "/acl-ip-source-port-bitmask", value["acl-ip-source-port-bitmask"], errors);
						}

						function parseAclIpDestPort(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 65535)
									push(errors, [ location, "must be lower than or equal to 65535" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ip-dest-port")) {
							obj.acl_ip_dest_port = parseAclIpDestPort(location + "/acl-ip-dest-port", value["acl-ip-dest-port"], errors);
						}

						function parseAclIpDestPortBitmask(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 65535)
									push(errors, [ location, "must be lower than or equal to 65535" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ip-dest-port-bitmask")) {
							obj.acl_ip_dest_port_bitmask = parseAclIpDestPortBitmask(location + "/acl-ip-dest-port-bitmask", value["acl-ip-dest-port-bitmask"], errors);
						}

						function parseAclIpv4FragmentOffset(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 8191)
									push(errors, [ location, "must be lower than or equal to 8191" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv4-fragment-offset")) {
							obj.acl_ipv4_fragment_offset = parseAclIpv4FragmentOffset(location + "/acl-ipv4-fragment-offset", value["acl-ipv4-fragment-offset"], errors);
						}

						function parseAclIpv6FragmentOffset(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 8191)
									push(errors, [ location, "must be lower than or equal to 8191" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-fragment-offset")) {
							obj.acl_ipv6_fragment_offset = parseAclIpv6FragmentOffset(location + "/acl-ipv6-fragment-offset", value["acl-ipv6-fragment-offset"], errors);
						}

						function parseAclIpTtl(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 255)
									push(errors, [ location, "must be lower than or equal to 255" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ip-ttl")) {
							obj.acl_ip_ttl = parseAclIpTtl(location + "/acl-ip-ttl", value["acl-ip-ttl"], errors);
						}

						function parseAclIpv6HopLimit(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 255)
									push(errors, [ location, "must be lower than or equal to 255" ]);

								if (value < 0)
									push(errors, [ location, "must be bigger than or equal to 0" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "acl-ipv6-hop-limit")) {
							obj.acl_ipv6_hop_limit = parseAclIpv6HopLimit(location + "/acl-ipv6-hop-limit", value["acl-ipv6-hop-limit"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "acl")) {
			obj.acl = parseAcl(location + "/acl", value["acl"], errors);
		}

		function parseMvrConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseMvrEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "mvr-enable")) {
					obj.mvr_enable = parseMvrEnable(location + "/mvr-enable", value["mvr-enable"], errors);
				}
				else {
					obj.mvr_enable = false;
				}

				function parseMvrProxyQueryIntvl(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 43200)
							push(errors, [ location, "must be lower than or equal to 43200" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "mvr-proxy-query-intvl")) {
					obj.mvr_proxy_query_intvl = parseMvrProxyQueryIntvl(location + "/mvr-proxy-query-intvl", value["mvr-proxy-query-intvl"], errors);
				}
				else {
					obj.mvr_proxy_query_intvl = 125;
				}

				function parseMvrProxySwitching(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "mvr-proxy-switching")) {
					obj.mvr_proxy_switching = parseMvrProxySwitching(location + "/mvr-proxy-switching", value["mvr-proxy-switching"], errors);
				}
				else {
					obj.mvr_proxy_switching = false;
				}

				function parseMvrRobustnessVal(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 255)
							push(errors, [ location, "must be lower than or equal to 255" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "mvr-robustness-val")) {
					obj.mvr_robustness_val = parseMvrRobustnessVal(location + "/mvr-robustness-val", value["mvr-robustness-val"], errors);
				}
				else {
					obj.mvr_robustness_val = 2;
				}

				function parseMvrSourcePortMode(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "dynamic", "forward" ]))
						push(errors, [ location, "must be one of \"dynamic\" or \"forward\"" ]);

					return value;
				}

				if (exists(value, "mvr-source-port-mode")) {
					obj.mvr_source_port_mode = parseMvrSourcePortMode(location + "/mvr-source-port-mode", value["mvr-source-port-mode"], errors);
				}
				else {
					obj.mvr_source_port_mode = "forward";
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "mvr-config")) {
			obj.mvr_config = parseMvrConfig(location + "/mvr-config", value["mvr-config"], errors);
		}

		function parseMvrDomainConfig(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseMvrDomainId(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 10)
									push(errors, [ location, "must be lower than or equal to 10" ]);

								if (value < 1)
									push(errors, [ location, "must be bigger than or equal to 1" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "mvr-domain-id")) {
							obj.mvr_domain_id = parseMvrDomainId(location + "/mvr-domain-id", value["mvr-domain-id"], errors);
						}
						else {
							obj.mvr_domain_id = 1;
						}

						function parseMvrDomainEnable(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "mvr-domain-enable")) {
							obj.mvr_domain_enable = parseMvrDomainEnable(location + "/mvr-domain-enable", value["mvr-domain-enable"], errors);
						}
						else {
							obj.mvr_domain_enable = false;
						}

						function parseMvrDomainVlanId(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 4094)
									push(errors, [ location, "must be lower than or equal to 4094" ]);

								if (value < 1)
									push(errors, [ location, "must be bigger than or equal to 1" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "mvr-domain-vlan-id")) {
							obj.mvr_domain_vlan_id = parseMvrDomainVlanId(location + "/mvr-domain-vlan-id", value["mvr-domain-vlan-id"], errors);
						}
						else {
							obj.mvr_domain_vlan_id = 1;
						}

						function parseMvrDomainUpstreamSip(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "mvr-domain-upstream-sip")) {
							obj.mvr_domain_upstream_sip = parseMvrDomainUpstreamSip(location + "/mvr-domain-upstream-sip", value["mvr-domain-upstream-sip"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "mvr-domain-config")) {
			obj.mvr_domain_config = parseMvrDomainConfig(location + "/mvr-domain-config", value["mvr-domain-config"], errors);
		}

		function parseMvrGroupConfig(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseMvrGroupName(location, value, errors) {
							if (type(value) == "string") {
								if (length(value) > 16)
									push(errors, [ location, "must be at most 16 characters long" ]);

								if (length(value) < 1)
									push(errors, [ location, "must be at least 1 characters long" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "mvr-group-name")) {
							obj.mvr_group_name = parseMvrGroupName(location + "/mvr-group-name", value["mvr-group-name"], errors);
						}
						else {
							push(errors, [ location, "is required" ]);
						}

						function parseMvrGroupRangeStart(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "mvr-group-range-start")) {
							obj.mvr_group_range_start = parseMvrGroupRangeStart(location + "/mvr-group-range-start", value["mvr-group-range-start"], errors);
						}
						else {
							push(errors, [ location, "is required" ]);
						}

						function parseMvrGroupRangeEnd(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "mvr-group-range-end")) {
							obj.mvr_group_range_end = parseMvrGroupRangeEnd(location + "/mvr-group-range-end", value["mvr-group-range-end"], errors);
						}
						else {
							push(errors, [ location, "is required" ]);
						}

						function parseMvrGroupAssocDomain(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) in [ "int", "double" ]) {
										if (value > 10)
											push(errors, [ location, "must be lower than or equal to 10" ]);

										if (value < 1)
											push(errors, [ location, "must be bigger than or equal to 1" ]);

									}

									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "mvr-group-assoc-domain")) {
							obj.mvr_group_assoc_domain = parseMvrGroupAssocDomain(location + "/mvr-group-assoc-domain", value["mvr-group-assoc-domain"], errors);
						}
						else {
							push(errors, [ location, "is required" ]);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "mvr-group-config")) {
			obj.mvr_group_config = parseMvrGroupConfig(location + "/mvr-group-config", value["mvr-group-config"], errors);
		}

		function parseLldpGlobalConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseLldpEnable(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "lldp-enable")) {
					obj.lldp_enable = parseLldpEnable(location + "/lldp-enable", value["lldp-enable"], errors);
				}
				else {
					obj.lldp_enable = true;
				}

				function parseLldpHoldtimeMultiplier(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lldp-holdtime-multiplier")) {
					obj.lldp_holdtime_multiplier = parseLldpHoldtimeMultiplier(location + "/lldp-holdtime-multiplier", value["lldp-holdtime-multiplier"], errors);
				}
				else {
					obj.lldp_holdtime_multiplier = 4;
				}

				function parseLldpMedFastStartCount(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lldp-med-fast-start-count")) {
					obj.lldp_med_fast_start_count = parseLldpMedFastStartCount(location + "/lldp-med-fast-start-count", value["lldp-med-fast-start-count"], errors);
				}
				else {
					obj.lldp_med_fast_start_count = 4;
				}

				function parseLldpRefreshInterval(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lldp-refresh-interval")) {
					obj.lldp_refresh_interval = parseLldpRefreshInterval(location + "/lldp-refresh-interval", value["lldp-refresh-interval"], errors);
				}
				else {
					obj.lldp_refresh_interval = 30;
				}

				function parseLldpReinitDelay(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lldp-reinit-delay")) {
					obj.lldp_reinit_delay = parseLldpReinitDelay(location + "/lldp-reinit-delay", value["lldp-reinit-delay"], errors);
				}
				else {
					obj.lldp_reinit_delay = 2;
				}

				function parseLldpTxDelay(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 8192)
							push(errors, [ location, "must be lower than or equal to 8192" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lldp-tx-delay")) {
					obj.lldp_tx_delay = parseLldpTxDelay(location + "/lldp-tx-delay", value["lldp-tx-delay"], errors);
				}

				function parseLldpNotificationInterval(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "lldp-notification-interval")) {
					obj.lldp_notification_interval = parseLldpNotificationInterval(location + "/lldp-notification-interval", value["lldp-notification-interval"], errors);
				}
				else {
					obj.lldp_notification_interval = 5;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "lldp-global-config")) {
			obj.lldp_global_config = parseLldpGlobalConfig(location + "/lldp-global-config", value["lldp-global-config"], errors);
		}

		function parseMcLag(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "mc-lag")) {
			obj.mc_lag = parseMcLag(location + "/mc-lag", value["mc-lag"], errors);
		}
		else {
			obj.mc_lag = false;
		}

		function parseMclagConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseMclagDomains(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) == "object") {
								let obj = {};

								function parseMclagDomain(location, value, errors) {
									if (type(value) in [ "int", "double" ]) {
										if (value > 1024)
											push(errors, [ location, "must be lower than or equal to 1024" ]);

										if (value < 1)
											push(errors, [ location, "must be bigger than or equal to 1" ]);

									}

									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "mclag-domain")) {
									obj.mclag_domain = parseMclagDomain(location + "/mclag-domain", value["mclag-domain"], errors);
								}
								else {
									obj.mclag_domain = 1;
								}

								function parsePeerLink(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseType(location, value, errors) {
											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											if (!(value in [ "port", "trunk-group" ]))
												push(errors, [ location, "must be one of \"port\" or \"trunk-group\"" ]);

											return value;
										}

										if (exists(value, "type")) {
											obj.type = parseType(location + "/type", value["type"], errors);
										}
										else {
											obj.type = "trunk-group";
										}

										function parseValue(location, value, errors) {
											if (type(value) in [ "int", "double" ]) {
												if (value > 64)
													push(errors, [ location, "must be lower than or equal to 64" ]);

												if (value < 1)
													push(errors, [ location, "must be bigger than or equal to 1" ]);

											}

											if (type(value) != "int")
												push(errors, [ location, "must be of type integer" ]);

											return value;
										}

										if (exists(value, "value")) {
											obj.value = parseValue(location + "/value", value["value"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								if (exists(value, "peer-link")) {
									obj.peer_link = parsePeerLink(location + "/peer-link", value["peer-link"], errors);
								}

								function parseMclagGroup(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseGroupId(location, value, errors) {
											if (type(value) in [ "int", "double" ]) {
												if (value > 128)
													push(errors, [ location, "must be lower than or equal to 128" ]);

												if (value < 1)
													push(errors, [ location, "must be bigger than or equal to 1" ]);

											}

											if (type(value) != "int")
												push(errors, [ location, "must be of type integer" ]);

											return value;
										}

										if (exists(value, "group-id")) {
											obj.group_id = parseGroupId(location + "/group-id", value["group-id"], errors);
										}

										function parseMembers(location, value, errors) {
											if (type(value) == "array") {
												function parseItem(location, value, errors) {
													if (type(value) != "string")
														push(errors, [ location, "must be of type string" ]);

													return value;
												}

												return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
											}

											if (type(value) != "array")
												push(errors, [ location, "must be of type array" ]);

											return value;
										}

										if (exists(value, "members")) {
											obj.members = parseMembers(location + "/members", value["members"], errors);
										}

										function parseLacpConfig(location, value, errors) {
											if (type(value) == "object") {
												let obj = {};

												function parseLacpEnable(location, value, errors) {
													if (type(value) != "bool")
														push(errors, [ location, "must be of type boolean" ]);

													return value;
												}

												if (exists(value, "lacp-enable")) {
													obj.lacp_enable = parseLacpEnable(location + "/lacp-enable", value["lacp-enable"], errors);
												}
												else {
													obj.lacp_enable = true;
												}

												function parseLacpRole(location, value, errors) {
													if (type(value) != "string")
														push(errors, [ location, "must be of type string" ]);

													if (!(value in [ "actor", "partner" ]))
														push(errors, [ location, "must be one of \"actor\" or \"partner\"" ]);

													return value;
												}

												if (exists(value, "lacp-role")) {
													obj.lacp_role = parseLacpRole(location + "/lacp-role", value["lacp-role"], errors);
												}
												else {
													obj.lacp_role = "actor";
												}

												function parseLacpTimeout(location, value, errors) {
													if (type(value) != "string")
														push(errors, [ location, "must be of type string" ]);

													if (!(value in [ "short", "long" ]))
														push(errors, [ location, "must be one of \"short\" or \"long\"" ]);

													return value;
												}

												if (exists(value, "lacp-timeout")) {
													obj.lacp_timeout = parseLacpTimeout(location + "/lacp-timeout", value["lacp-timeout"], errors);
												}
												else {
													obj.lacp_timeout = "long";
												}

												return obj;
											}

											if (type(value) != "object")
												push(errors, [ location, "must be of type object" ]);

											return value;
										}

										if (exists(value, "lacp-config")) {
											obj.lacp_config = parseLacpConfig(location + "/lacp-config", value["lacp-config"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								if (exists(value, "mclag-group")) {
									obj.mclag_group = parseMclagGroup(location + "/mclag-group", value["mclag-group"], errors);
								}

								function parseSystemPriority(location, value, errors) {
									if (type(value) in [ "int", "double" ]) {
										if (value > 65535)
											push(errors, [ location, "must be lower than or equal to 65535" ]);

										if (value < 1)
											push(errors, [ location, "must be bigger than or equal to 1" ]);

									}

									if (type(value) != "int")
										push(errors, [ location, "must be of type integer" ]);

									return value;
								}

								if (exists(value, "system-priority")) {
									obj.system_priority = parseSystemPriority(location + "/system-priority", value["system-priority"], errors);
								}
								else {
									obj.system_priority = 32768;
								}

								function parseDualActiveDetection(location, value, errors) {
									if (type(value) != "bool")
										push(errors, [ location, "must be of type boolean" ]);

									return value;
								}

								if (exists(value, "dual-active-detection")) {
									obj.dual_active_detection = parseDualActiveDetection(location + "/dual-active-detection", value["dual-active-detection"], errors);
								}
								else {
									obj.dual_active_detection = true;
								}

								return obj;
							}

							if (type(value) != "object")
								push(errors, [ location, "must be of type object" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "mclag-domains")) {
					obj.mclag_domains = parseMclagDomains(location + "/mclag-domains", value["mclag-domains"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "mclag-config")) {
			obj.mclag_config = parseMclagConfig(location + "/mclag-config", value["mclag-config"], errors);
		}

		function parseVoiceVlanConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseVoiceVlanId(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 4094)
							push(errors, [ location, "must be lower than or equal to 4094" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "voice-vlan-id")) {
					obj.voice_vlan_id = parseVoiceVlanId(location + "/voice-vlan-id", value["voice-vlan-id"], errors);
				}

				function parseVoiceVlanAgeingTime(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 43200)
							push(errors, [ location, "must be lower than or equal to 43200" ]);

						if (value < 5)
							push(errors, [ location, "must be bigger than or equal to 5" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "voice-vlan-ageing-time")) {
					obj.voice_vlan_ageing_time = parseVoiceVlanAgeingTime(location + "/voice-vlan-ageing-time", value["voice-vlan-ageing-time"], errors);
				}
				else {
					obj.voice_vlan_ageing_time = 1440;
				}

				function parseVoiceVlanOuiConfig(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) == "object") {
								let obj = {};

								function parseVoiceVlanOuiMac(location, value, errors) {
									if (type(value) == "string") {
										if (!matchUcMac(value))
											push(errors, [ location, "must be a valid MAC address" ]);

									}

									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								if (exists(value, "voice-vlan-oui-mac")) {
									obj.voice_vlan_oui_mac = parseVoiceVlanOuiMac(location + "/voice-vlan-oui-mac", value["voice-vlan-oui-mac"], errors);
								}

								function parseVoiceVlanOuiMask(location, value, errors) {
									if (type(value) == "string") {
										if (!matchUcMac(value))
											push(errors, [ location, "must be a valid MAC address" ]);

									}

									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								if (exists(value, "voice-vlan-oui-mask")) {
									obj.voice_vlan_oui_mask = parseVoiceVlanOuiMask(location + "/voice-vlan-oui-mask", value["voice-vlan-oui-mask"], errors);
								}

								function parseVoiceVlanOuiDescription(location, value, errors) {
									if (type(value) == "string") {
										if (length(value) > 32)
											push(errors, [ location, "must be at most 32 characters long" ]);

										if (length(value) < 1)
											push(errors, [ location, "must be at least 1 characters long" ]);

									}

									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								if (exists(value, "voice-vlan-oui-description")) {
									obj.voice_vlan_oui_description = parseVoiceVlanOuiDescription(location + "/voice-vlan-oui-description", value["voice-vlan-oui-description"], errors);
								}

								return obj;
							}

							if (type(value) != "object")
								push(errors, [ location, "must be of type object" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "voice-vlan-oui-config")) {
					obj.voice_vlan_oui_config = parseVoiceVlanOuiConfig(location + "/voice-vlan-oui-config", value["voice-vlan-oui-config"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "voice-vlan-config")) {
			obj.voice_vlan_config = parseVoiceVlanConfig(location + "/voice-vlan-config", value["voice-vlan-config"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceVlan(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseId(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 4050)
					push(errors, [ location, "must be lower than or equal to 4050" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "id")) {
			obj.id = parseId(location + "/id", value["id"], errors);
		}

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "802.1ad", "802.1q" ]))
				push(errors, [ location, "must be one of \"802.1ad\" or \"802.1q\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}
		else {
			obj.proto = "802.1q";
		}

		function parseStpInstance(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "stp-instance")) {
			obj.stp_instance = parseStpInstance(location + "/stp-instance", value["stp-instance"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceBridge(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseMtu(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 256)
					push(errors, [ location, "must be bigger than or equal to 256" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "mtu")) {
			obj.mtu = parseMtu(location + "/mtu", value["mtu"], errors);
		}

		function parseTxQueueLen(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "tx-queue-len")) {
			obj.tx_queue_len = parseTxQueueLen(location + "/tx-queue-len", value["tx-queue-len"], errors);
		}

		function parseIsolatePorts(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "isolate-ports")) {
			obj.isolate_ports = parseIsolatePorts(location + "/isolate-ports", value["isolate-ports"], errors);
		}
		else {
			obj.isolate_ports = false;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceEthernet(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseSelectPorts(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "select-ports")) {
			obj.select_ports = parseSelectPorts(location + "/select-ports", value["select-ports"], errors);
		}

		function parseMulticast(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "multicast")) {
			obj.multicast = parseMulticast(location + "/multicast", value["multicast"], errors);
		}
		else {
			obj.multicast = true;
		}

		function parseLearning(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "learning")) {
			obj.learning = parseLearning(location + "/learning", value["learning"], errors);
		}
		else {
			obj.learning = true;
		}

		function parseIsolate(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "isolate")) {
			obj.isolate = parseIsolate(location + "/isolate", value["isolate"], errors);
		}
		else {
			obj.isolate = false;
		}

		function parseMacaddr(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcMac(value))
					push(errors, [ location, "must be a valid MAC address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "macaddr")) {
			obj.macaddr = parseMacaddr(location + "/macaddr", value["macaddr"], errors);
		}

		function parseReversePathFilter(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "reverse-path-filter")) {
			obj.reverse_path_filter = parseReversePathFilter(location + "/reverse-path-filter", value["reverse-path-filter"], errors);
		}
		else {
			obj.reverse_path_filter = false;
		}

		function parseVlanTag(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "tagged", "un-tagged", "auto" ]))
				push(errors, [ location, "must be one of \"tagged\", \"un-tagged\" or \"auto\"" ]);

			return value;
		}

		if (exists(value, "vlan-tag")) {
			obj.vlan_tag = parseVlanTag(location + "/vlan-tag", value["vlan-tag"], errors);
		}
		else {
			obj.vlan_tag = "auto";
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv4Dhcp(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseLeaseFirst(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "lease-first")) {
			obj.lease_first = parseLeaseFirst(location + "/lease-first", value["lease-first"], errors);
		}

		function parseLeaseCount(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "lease-count")) {
			obj.lease_count = parseLeaseCount(location + "/lease-count", value["lease-count"], errors);
		}

		function parseLeaseTime(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcTimeout(value))
					push(errors, [ location, "must be a valid timeout value" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "lease-time")) {
			obj.lease_time = parseLeaseTime(location + "/lease-time", value["lease-time"], errors);
		}
		else {
			obj.lease_time = "6h";
		}

		function parseRelayServer(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv4(value))
					push(errors, [ location, "must be a valid IPv4 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "relay-server")) {
			obj.relay_server = parseRelayServer(location + "/relay-server", value["relay-server"], errors);
		}

		function parseCircuitIdFormat(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "circuit-id-format")) {
			obj.circuit_id_format = parseCircuitIdFormat(location + "/circuit-id-format", value["circuit-id-format"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv4DhcpLease(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseMacaddr(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcMac(value))
					push(errors, [ location, "must be a valid MAC address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "macaddr")) {
			obj.macaddr = parseMacaddr(location + "/macaddr", value["macaddr"], errors);
		}

		function parseStaticLeaseOffset(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "static-lease-offset")) {
			obj.static_lease_offset = parseStaticLeaseOffset(location + "/static-lease-offset", value["static-lease-offset"], errors);
		}

		function parseLeaseTime(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcTimeout(value))
					push(errors, [ location, "must be a valid timeout value" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "lease-time")) {
			obj.lease_time = parseLeaseTime(location + "/lease-time", value["lease-time"], errors);
		}
		else {
			obj.lease_time = "6h";
		}

		function parsePublishHostname(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "publish-hostname")) {
			obj.publish_hostname = parsePublishHostname(location + "/publish-hostname", value["publish-hostname"], errors);
		}
		else {
			obj.publish_hostname = true;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv4PortForward(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProtocol(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "tcp", "udp", "any" ]))
				push(errors, [ location, "must be one of \"tcp\", \"udp\" or \"any\"" ]);

			return value;
		}

		if (exists(value, "protocol")) {
			obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
		}
		else {
			obj.protocol = "any";
		}

		function parseExternalPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) == "string") {
				if (!matchUcPortrange(value))
					push(errors, [ location, "must be a valid network port range" ]);

			}

			if (type(value) != "int" && type(value) != "string")
				push(errors, [ location, "must be of type integer or string" ]);

			return value;
		}

		if (exists(value, "external-port")) {
			obj.external_port = parseExternalPort(location + "/external-port", value["external-port"], errors);
		}
		else {
			push(errors, [ location, "is required" ]);
		}

		function parseInternalAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv4(value))
					push(errors, [ location, "must be a valid IPv4 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "internal-address")) {
			obj.internal_address = parseInternalAddress(location + "/internal-address", value["internal-address"], errors);
		}
		else {
			push(errors, [ location, "is required" ]);
		}

		function parseInternalPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) == "string") {
				if (!matchUcPortrange(value))
					push(errors, [ location, "must be a valid network port range" ]);

			}

			if (type(value) != "int" && type(value) != "string")
				push(errors, [ location, "must be of type integer or string" ]);

			return value;
		}

		if (exists(value, "internal-port")) {
			obj.internal_port = parseInternalPort(location + "/internal-port", value["internal-port"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv4(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseAddressing(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "dynamic", "static", "none" ]))
				push(errors, [ location, "must be one of \"dynamic\", \"static\" or \"none\"" ]);

			return value;
		}

		if (exists(value, "addressing")) {
			obj.addressing = parseAddressing(location + "/addressing", value["addressing"], errors);
		}

		function parseSubnet(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parsePrefix(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcCidr4(value))
									push(errors, [ location, "must be a valid IPv4 CIDR" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "prefix")) {
							obj.prefix = parsePrefix(location + "/prefix", value["prefix"], errors);
						}

						function parseVrf(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "vrf")) {
							obj.vrf = parseVrf(location + "/vrf", value["vrf"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "subnet")) {
			obj.subnet = parseSubnet(location + "/subnet", value["subnet"], errors);
		}

		function parseGateway(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parsePrefix(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcCidr4(value))
									push(errors, [ location, "must be a valid IPv4 CIDR" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "prefix")) {
							obj.prefix = parsePrefix(location + "/prefix", value["prefix"], errors);
						}

						function parseNexthop(location, value, errors) {
							if (type(value) == "string") {
								if (!matchIpv4(value))
									push(errors, [ location, "must be a valid IPv4 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "nexthop")) {
							obj.nexthop = parseNexthop(location + "/nexthop", value["nexthop"], errors);
						}

						function parseVrf(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "vrf")) {
							obj.vrf = parseVrf(location + "/vrf", value["vrf"], errors);
						}

						function parseMetric(location, value, errors) {
							if (!(type(value) in [ "int", "double" ]))
								push(errors, [ location, "must be of type number" ]);

							return value;
						}

						if (exists(value, "metric")) {
							obj.metric = parseMetric(location + "/metric", value["metric"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "gateway")) {
			obj.gateway = parseGateway(location + "/gateway", value["gateway"], errors);
		}

		function parseBroadcast(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parsePrefix(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcCidr4(value))
									push(errors, [ location, "must be a valid IPv4 CIDR" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "prefix")) {
							obj.prefix = parsePrefix(location + "/prefix", value["prefix"], errors);
						}

						function parseVrf(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "vrf")) {
							obj.vrf = parseVrf(location + "/vrf", value["vrf"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "broadcast")) {
			obj.broadcast = parseBroadcast(location + "/broadcast", value["broadcast"], errors);
		}

		function parseMulticast(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseUnknownMulticastFloodControl(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "unknown-multicast-flood-control")) {
					obj.unknown_multicast_flood_control = parseUnknownMulticastFloodControl(location + "/unknown-multicast-flood-control", value["unknown-multicast-flood-control"], errors);
				}
				else {
					obj.unknown_multicast_flood_control = true;
				}

				function parseIgmp(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseSnoopingEnable(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "snooping-enable")) {
							obj.snooping_enable = parseSnoopingEnable(location + "/snooping-enable", value["snooping-enable"], errors);
						}
						else {
							obj.snooping_enable = true;
						}

						function parseVersion(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							if (!(value in [ 1, 2, 3 ]))
								push(errors, [ location, "must be one of 1, 2 or 3" ]);

							return value;
						}

						if (exists(value, "version")) {
							obj.version = parseVersion(location + "/version", value["version"], errors);
						}
						else {
							obj.version = 3;
						}

						function parseQuerierEnable(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "querier-enable")) {
							obj.querier_enable = parseQuerierEnable(location + "/querier-enable", value["querier-enable"], errors);
						}
						else {
							obj.querier_enable = false;
						}

						function parseFastLeaveEnable(location, value, errors) {
							if (type(value) != "bool")
								push(errors, [ location, "must be of type boolean" ]);

							return value;
						}

						if (exists(value, "fast-leave-enable")) {
							obj.fast_leave_enable = parseFastLeaveEnable(location + "/fast-leave-enable", value["fast-leave-enable"], errors);
						}
						else {
							obj.fast_leave_enable = false;
						}

						function parseQueryInterval(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "query-interval")) {
							obj.query_interval = parseQueryInterval(location + "/query-interval", value["query-interval"], errors);
						}
						else {
							obj.query_interval = 1000;
						}

						function parseLastMemberQueryInterval(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "last-member-query-interval")) {
							obj.last_member_query_interval = parseLastMemberQueryInterval(location + "/last-member-query-interval", value["last-member-query-interval"], errors);
						}
						else {
							obj.last_member_query_interval = 1000;
						}

						function parseMaxResponseTime(location, value, errors) {
							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "max-response-time")) {
							obj.max_response_time = parseMaxResponseTime(location + "/max-response-time", value["max-response-time"], errors);
						}
						else {
							obj.max_response_time = 10;
						}

						function parseStaticMcastGroups(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseEgressPorts(location, value, errors) {
											if (type(value) == "array") {
												function parseItem(location, value, errors) {
													if (type(value) != "string")
														push(errors, [ location, "must be of type string" ]);

													return value;
												}

												return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
											}

											if (type(value) != "array")
												push(errors, [ location, "must be of type array" ]);

											return value;
										}

										if (exists(value, "egress-ports")) {
											obj.egress_ports = parseEgressPorts(location + "/egress-ports", value["egress-ports"], errors);
										}

										function parseAddress(location, value, errors) {
											if (type(value) == "string") {
												if (!matchIpv4(value))
													push(errors, [ location, "must be a valid IPv4 address" ]);

											}

											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											return value;
										}

										if (exists(value, "address")) {
											obj.address = parseAddress(location + "/address", value["address"], errors);
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "static-mcast-groups")) {
							obj.static_mcast_groups = parseStaticMcastGroups(location + "/static-mcast-groups", value["static-mcast-groups"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				if (exists(value, "igmp")) {
					obj.igmp = parseIgmp(location + "/igmp", value["igmp"], errors);
				}

				function parseMvr(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseMvrIntfMvrRole(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "none", "source", "receiver" ]))
								push(errors, [ location, "must be one of \"none\", \"source\" or \"receiver\"" ]);

							return value;
						}

						if (exists(value, "mvr-intf-mvr-role")) {
							obj.mvr_intf_mvr_role = parseMvrIntfMvrRole(location + "/mvr-intf-mvr-role", value["mvr-intf-mvr-role"], errors);
						}
						else {
							push(errors, [ location, "is required" ]);
						}

						function parseMvrIntfImmedLeave(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							if (!(value in [ "none", "by-host-ip", "by-group" ]))
								push(errors, [ location, "must be one of \"none\", \"by-host-ip\" or \"by-group\"" ]);

							return value;
						}

						if (exists(value, "mvr-intf-immed-leave")) {
							obj.mvr_intf_immed_leave = parseMvrIntfImmedLeave(location + "/mvr-intf-immed-leave", value["mvr-intf-immed-leave"], errors);
						}
						else {
							obj.mvr_intf_immed_leave = "by-group";
						}

						function parseMvrIntfAssocDomain(location, value, errors) {
							if (type(value) in [ "int", "double" ]) {
								if (value > 10)
									push(errors, [ location, "must be lower than or equal to 10" ]);

								if (value < 1)
									push(errors, [ location, "must be bigger than or equal to 1" ]);

							}

							if (type(value) != "int")
								push(errors, [ location, "must be of type integer" ]);

							return value;
						}

						if (exists(value, "mvr-intf-assoc-domain")) {
							obj.mvr_intf_assoc_domain = parseMvrIntfAssocDomain(location + "/mvr-intf-assoc-domain", value["mvr-intf-assoc-domain"], errors);
						}
						else {
							push(errors, [ location, "is required" ]);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				if (exists(value, "mvr")) {
					obj.mvr = parseMvr(location + "/mvr", value["mvr"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "multicast")) {
			obj.multicast = parseMulticast(location + "/multicast", value["multicast"], errors);
		}

		function parseSendHostname(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "send-hostname")) {
			obj.send_hostname = parseSendHostname(location + "/send-hostname", value["send-hostname"], errors);
		}
		else {
			obj.send_hostname = true;
		}

		function parseUseDns(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "string") {
						if (!matchIpv4(value))
							push(errors, [ location, "must be a valid IPv4 address" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "use-dns")) {
			obj.use_dns = parseUseDns(location + "/use-dns", value["use-dns"], errors);
		}

		function parseDhcpSnoopVlanEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dhcp-snoop-vlan-enable")) {
			obj.dhcp_snoop_vlan_enable = parseDhcpSnoopVlanEnable(location + "/dhcp-snoop-vlan-enable", value["dhcp-snoop-vlan-enable"], errors);
		}
		else {
			obj.dhcp_snoop_vlan_enable = false;
		}

		function parseVoiceVlanIntfConfig(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseVoiceVlanIntfMode(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "none", "manual", "auto" ]))
						push(errors, [ location, "must be one of \"none\", \"manual\" or \"auto\"" ]);

					return value;
				}

				if (exists(value, "voice-vlan-intf-mode")) {
					obj.voice_vlan_intf_mode = parseVoiceVlanIntfMode(location + "/voice-vlan-intf-mode", value["voice-vlan-intf-mode"], errors);
				}
				else {
					obj.voice_vlan_intf_mode = "auto";
				}

				function parseVoiceVlanIntfPriority(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 6)
							push(errors, [ location, "must be lower than or equal to 6" ]);

						if (value < 0)
							push(errors, [ location, "must be bigger than or equal to 0" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "voice-vlan-intf-priority")) {
					obj.voice_vlan_intf_priority = parseVoiceVlanIntfPriority(location + "/voice-vlan-intf-priority", value["voice-vlan-intf-priority"], errors);
				}
				else {
					obj.voice_vlan_intf_priority = 6;
				}

				function parseVoiceVlanIntfDetectVoice(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "oui", "lldp" ]))
						push(errors, [ location, "must be one of \"oui\" or \"lldp\"" ]);

					return value;
				}

				if (exists(value, "voice-vlan-intf-detect-voice")) {
					obj.voice_vlan_intf_detect_voice = parseVoiceVlanIntfDetectVoice(location + "/voice-vlan-intf-detect-voice", value["voice-vlan-intf-detect-voice"], errors);
				}
				else {
					obj.voice_vlan_intf_detect_voice = "oui";
				}

				function parseVoiceVlanIntfSecurity(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "voice-vlan-intf-security")) {
					obj.voice_vlan_intf_security = parseVoiceVlanIntfSecurity(location + "/voice-vlan-intf-security", value["voice-vlan-intf-security"], errors);
				}
				else {
					obj.voice_vlan_intf_security = false;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "voice-vlan-intf-config")) {
			obj.voice_vlan_intf_config = parseVoiceVlanIntfConfig(location + "/voice-vlan-intf-config", value["voice-vlan-intf-config"], errors);
		}

		if (exists(value, "dhcp")) {
			obj.dhcp = instantiateInterfaceIpv4Dhcp(location + "/dhcp", value["dhcp"], errors);
		}

		function parseDhcpLeases(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateInterfaceIpv4DhcpLease(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "dhcp-leases")) {
			obj.dhcp_leases = parseDhcpLeases(location + "/dhcp-leases", value["dhcp-leases"], errors);
		}

		function parsePortForward(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateInterfaceIpv4PortForward(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "port-forward")) {
			obj.port_forward = parsePortForward(location + "/port-forward", value["port-forward"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv6Dhcpv6(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseMode(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "hybrid", "stateless", "stateful", "relay" ]))
				push(errors, [ location, "must be one of \"hybrid\", \"stateless\", \"stateful\" or \"relay\"" ]);

			return value;
		}

		if (exists(value, "mode")) {
			obj.mode = parseMode(location + "/mode", value["mode"], errors);
		}

		function parseAnnounceDns(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "string") {
						if (!matchIpv6(value))
							push(errors, [ location, "must be a valid IPv6 address" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "announce-dns")) {
			obj.announce_dns = parseAnnounceDns(location + "/announce-dns", value["announce-dns"], errors);
		}

		function parseFilterPrefix(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcCidr6(value))
					push(errors, [ location, "must be a valid IPv6 CIDR" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "filter-prefix")) {
			obj.filter_prefix = parseFilterPrefix(location + "/filter-prefix", value["filter-prefix"], errors);
		}
		else {
			obj.filter_prefix = "::/0";
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv6PortForward(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProtocol(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "tcp", "udp", "any" ]))
				push(errors, [ location, "must be one of \"tcp\", \"udp\" or \"any\"" ]);

			return value;
		}

		if (exists(value, "protocol")) {
			obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
		}
		else {
			obj.protocol = "any";
		}

		function parseExternalPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) == "string") {
				if (!matchUcPortrange(value))
					push(errors, [ location, "must be a valid network port range" ]);

			}

			if (type(value) != "int" && type(value) != "string")
				push(errors, [ location, "must be of type integer or string" ]);

			return value;
		}

		if (exists(value, "external-port")) {
			obj.external_port = parseExternalPort(location + "/external-port", value["external-port"], errors);
		}
		else {
			push(errors, [ location, "is required" ]);
		}

		function parseInternalAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv6(value))
					push(errors, [ location, "must be a valid IPv6 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "internal-address")) {
			obj.internal_address = parseInternalAddress(location + "/internal-address", value["internal-address"], errors);
		}
		else {
			push(errors, [ location, "is required" ]);
		}

		function parseInternalPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) == "string") {
				if (!matchUcPortrange(value))
					push(errors, [ location, "must be a valid network port range" ]);

			}

			if (type(value) != "int" && type(value) != "string")
				push(errors, [ location, "must be of type integer or string" ]);

			return value;
		}

		if (exists(value, "internal-port")) {
			obj.internal_port = parseInternalPort(location + "/internal-port", value["internal-port"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv6TrafficAllow(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProtocol(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "protocol")) {
			obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
		}
		else {
			obj.protocol = "any";
		}

		function parseSourceAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcCidr6(value))
					push(errors, [ location, "must be a valid IPv6 CIDR" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "source-address")) {
			obj.source_address = parseSourceAddress(location + "/source-address", value["source-address"], errors);
		}
		else {
			obj.source_address = "::/0";
		}

		function parseSourcePorts(location, value, errors) {
			if (type(value) == "array") {
				if (length(value) < 1)
					push(errors, [ location, "must have at least 1 items" ]);

				function parseItem(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 0)
							push(errors, [ location, "must be bigger than or equal to 0" ]);

					}

					if (type(value) == "string") {
						if (!matchUcPortrange(value))
							push(errors, [ location, "must be a valid network port range" ]);

					}

					if (type(value) != "int" && type(value) != "string")
						push(errors, [ location, "must be of type integer or string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "source-ports")) {
			obj.source_ports = parseSourcePorts(location + "/source-ports", value["source-ports"], errors);
		}

		function parseDestinationAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv6(value))
					push(errors, [ location, "must be a valid IPv6 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "destination-address")) {
			obj.destination_address = parseDestinationAddress(location + "/destination-address", value["destination-address"], errors);
		}
		else {
			push(errors, [ location, "is required" ]);
		}

		function parseDestinationPorts(location, value, errors) {
			if (type(value) == "array") {
				if (length(value) < 1)
					push(errors, [ location, "must have at least 1 items" ]);

				function parseItem(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 0)
							push(errors, [ location, "must be bigger than or equal to 0" ]);

					}

					if (type(value) == "string") {
						if (!matchUcPortrange(value))
							push(errors, [ location, "must be a valid network port range" ]);

					}

					if (type(value) != "int" && type(value) != "string")
						push(errors, [ location, "must be of type integer or string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "destination-ports")) {
			obj.destination_ports = parseDestinationPorts(location + "/destination-ports", value["destination-ports"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceIpv6(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseAddressing(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "dynamic", "static" ]))
				push(errors, [ location, "must be one of \"dynamic\" or \"static\"" ]);

			return value;
		}

		if (exists(value, "addressing")) {
			obj.addressing = parseAddressing(location + "/addressing", value["addressing"], errors);
		}

		function parseSubnet(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcCidr6(value))
					push(errors, [ location, "must be a valid IPv6 CIDR" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "subnet")) {
			obj.subnet = parseSubnet(location + "/subnet", value["subnet"], errors);
		}

		function parseGateway(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv6(value))
					push(errors, [ location, "must be a valid IPv6 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "gateway")) {
			obj.gateway = parseGateway(location + "/gateway", value["gateway"], errors);
		}

		function parsePrefixSize(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 64)
					push(errors, [ location, "must be lower than or equal to 64" ]);

				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "prefix-size")) {
			obj.prefix_size = parsePrefixSize(location + "/prefix-size", value["prefix-size"], errors);
		}

		if (exists(value, "dhcpv6")) {
			obj.dhcpv6 = instantiateInterfaceIpv6Dhcpv6(location + "/dhcpv6", value["dhcpv6"], errors);
		}

		function parsePortForward(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateInterfaceIpv6PortForward(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "port-forward")) {
			obj.port_forward = parsePortForward(location + "/port-forward", value["port-forward"], errors);
		}

		function parseTrafficAllow(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateInterfaceIpv6TrafficAllow(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "traffic-allow")) {
			obj.traffic_allow = parseTrafficAllow(location + "/traffic-allow", value["traffic-allow"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceAcl(location, value, errors) {
	if (type(value) == "array") {
		function parseItem(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseAclInfPolicyPreference(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 64)
							push(errors, [ location, "must be lower than or equal to 64" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "acl-inf-policy-preference")) {
					obj.acl_inf_policy_preference = parseAclInfPolicyPreference(location + "/acl-inf-policy-preference", value["acl-inf-policy-preference"], errors);
				}
				else {
					obj.acl_inf_policy_preference = 1;
				}

				function parseAclInfPolicyIngress(location, value, errors) {
					if (type(value) == "string") {
						if (length(value) > 32)
							push(errors, [ location, "must be at most 32 characters long" ]);

						if (length(value) < 1)
							push(errors, [ location, "must be at least 1 characters long" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "acl-inf-policy-ingress")) {
					obj.acl_inf_policy_ingress = parseAclInfPolicyIngress(location + "/acl-inf-policy-ingress", value["acl-inf-policy-ingress"], errors);
				}

				function parseAclInfCountersIngress(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "acl-inf-counters-ingress")) {
					obj.acl_inf_counters_ingress = parseAclInfCountersIngress(location + "/acl-inf-counters-ingress", value["acl-inf-counters-ingress"], errors);
				}
				else {
					obj.acl_inf_counters_ingress = false;
				}

				function parseAclInfPolicyEgress(location, value, errors) {
					if (type(value) == "string") {
						if (length(value) > 32)
							push(errors, [ location, "must be at most 32 characters long" ]);

						if (length(value) < 1)
							push(errors, [ location, "must be at least 1 characters long" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "acl-inf-policy-egress")) {
					obj.acl_inf_policy_egress = parseAclInfPolicyEgress(location + "/acl-inf-policy-egress", value["acl-inf-policy-egress"], errors);
				}

				function parseAclInfCountersEgress(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "acl-inf-counters-egress")) {
					obj.acl_inf_counters_egress = parseAclInfCountersEgress(location + "/acl-inf-counters-egress", value["acl-inf-counters-egress"], errors);
				}
				else {
					obj.acl_inf_counters_egress = false;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
	}

	if (type(value) != "array")
		push(errors, [ location, "must be of type array" ]);

	return value;
}

function instantiateInterfaceDhcpSnoopPort(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseDhcpSnoopPortTrust(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dhcp-snoop-port-trust")) {
			obj.dhcp_snoop_port_trust = parseDhcpSnoopPortTrust(location + "/dhcp-snoop-port-trust", value["dhcp-snoop-port-trust"], errors);
		}
		else {
			obj.dhcp_snoop_port_trust = false;
		}

		function parseDhcpSnoopPortClientLimit(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "dhcp-snoop-port-client-limit")) {
			obj.dhcp_snoop_port_client_limit = parseDhcpSnoopPortClientLimit(location + "/dhcp-snoop-port-client-limit", value["dhcp-snoop-port-client-limit"], errors);
		}

		function parseDhcpSnoopPortCircuitId(location, value, errors) {
			if (type(value) == "string") {
				if (length(value) > 32)
					push(errors, [ location, "must be at most 32 characters long" ]);

				if (length(value) < 1)
					push(errors, [ location, "must be at least 1 characters long" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "dhcp-snoop-port-circuit-id")) {
			obj.dhcp_snoop_port_circuit_id = parseDhcpSnoopPortCircuitId(location + "/dhcp-snoop-port-circuit-id", value["dhcp-snoop-port-circuit-id"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceBroadBandWwan(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProtocol(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "wwan")
				push(errors, [ location, "must have value \"wwan\"" ]);

			return value;
		}

		if (exists(value, "protocol")) {
			obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
		}

		function parseModemType(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "qmi", "mbim", "wwan" ]))
				push(errors, [ location, "must be one of \"qmi\", \"mbim\" or \"wwan\"" ]);

			return value;
		}

		if (exists(value, "modem-type")) {
			obj.modem_type = parseModemType(location + "/modem-type", value["modem-type"], errors);
		}

		function parseAccessPointName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "access-point-name")) {
			obj.access_point_name = parseAccessPointName(location + "/access-point-name", value["access-point-name"], errors);
		}

		function parseAuthenticationType(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "none", "pap", "chap", "pap-chap" ]))
				push(errors, [ location, "must be one of \"none\", \"pap\", \"chap\" or \"pap-chap\"" ]);

			return value;
		}

		if (exists(value, "authentication-type")) {
			obj.authentication_type = parseAuthenticationType(location + "/authentication-type", value["authentication-type"], errors);
		}
		else {
			obj.authentication_type = "none";
		}

		function parsePinCode(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "pin-code")) {
			obj.pin_code = parsePinCode(location + "/pin-code", value["pin-code"], errors);
		}

		function parseUserName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "user-name")) {
			obj.user_name = parseUserName(location + "/user-name", value["user-name"], errors);
		}

		function parsePassword(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "password")) {
			obj.password = parsePassword(location + "/password", value["password"], errors);
		}

		function parsePacketDataProtocol(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "ipv4", "ipv6", "dual-stack" ]))
				push(errors, [ location, "must be one of \"ipv4\", \"ipv6\" or \"dual-stack\"" ]);

			return value;
		}

		if (exists(value, "packet-data-protocol")) {
			obj.packet_data_protocol = parsePacketDataProtocol(location + "/packet-data-protocol", value["packet-data-protocol"], errors);
		}
		else {
			obj.packet_data_protocol = "dual-stack";
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceBroadBandPppoe(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProtocol(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "pppoe")
				push(errors, [ location, "must have value \"pppoe\"" ]);

			return value;
		}

		if (exists(value, "protocol")) {
			obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
		}

		function parseUserName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "user-name")) {
			obj.user_name = parseUserName(location + "/user-name", value["user-name"], errors);
		}

		function parsePassword(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "password")) {
			obj.password = parsePassword(location + "/password", value["password"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceBroadBand(location, value, errors) {
	function parseVariant0(location, value, errors) {
		value = instantiateInterfaceBroadBandWwan(location, value, errors);

		return value;
	}

	function parseVariant1(location, value, errors) {
		value = instantiateInterfaceBroadBandPppoe(location, value, errors);

		return value;
	}

	let success = 0, tryval, tryerr, vvalue = null, verrors = [];

	tryerr = [];
	tryval = parseVariant0(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	tryerr = [];
	tryval = parseVariant1(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	if (success != 1) {
		if (length(verrors))
			push(errors, [ location, "must match exactly one of the following constraints:\n" + join("\n- or -\n", verrors) ]);
		else
			push(errors, [ location, "must match only one variant" ]);
		return null;
	}

	value = vvalue;

	return value;
}

function instantiateInterfaceTunnelMesh(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "mesh")
				push(errors, [ location, "must have value \"mesh\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceTunnelVxlan(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "vxlan")
				push(errors, [ location, "must have value \"vxlan\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}

		function parsePeerAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv4(value))
					push(errors, [ location, "must be a valid IPv4 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "peer-address")) {
			obj.peer_address = parsePeerAddress(location + "/peer-address", value["peer-address"], errors);
		}

		function parsePeerPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "peer-port")) {
			obj.peer_port = parsePeerPort(location + "/peer-port", value["peer-port"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceTunnelL2tp(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "l2tp")
				push(errors, [ location, "must have value \"l2tp\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}

		function parseServer(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv4(value))
					push(errors, [ location, "must be a valid IPv4 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "server")) {
			obj.server = parseServer(location + "/server", value["server"], errors);
		}

		function parseUserName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "user-name")) {
			obj.user_name = parseUserName(location + "/user-name", value["user-name"], errors);
		}

		function parsePassword(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "password")) {
			obj.password = parsePassword(location + "/password", value["password"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceTunnelGre(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "gre")
				push(errors, [ location, "must have value \"gre\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}

		function parsePeerAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv4(value))
					push(errors, [ location, "must be a valid IPv4 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "peer-address")) {
			obj.peer_address = parsePeerAddress(location + "/peer-address", value["peer-address"], errors);
		}

		function parseDhcpHealthcheck(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dhcp-healthcheck")) {
			obj.dhcp_healthcheck = parseDhcpHealthcheck(location + "/dhcp-healthcheck", value["dhcp-healthcheck"], errors);
		}
		else {
			obj.dhcp_healthcheck = false;
		}

		function parseDontFragment(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dont-fragment")) {
			obj.dont_fragment = parseDontFragment(location + "/dont-fragment", value["dont-fragment"], errors);
		}
		else {
			obj.dont_fragment = false;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceTunnelGre6(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "gre6")
				push(errors, [ location, "must have value \"gre6\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}

		function parsePeerAddress(location, value, errors) {
			if (type(value) == "string") {
				if (!matchIpv6(value))
					push(errors, [ location, "must be a valid IPv6 address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "peer-address")) {
			obj.peer_address = parsePeerAddress(location + "/peer-address", value["peer-address"], errors);
		}

		function parseDhcpHealthcheck(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dhcp-healthcheck")) {
			obj.dhcp_healthcheck = parseDhcpHealthcheck(location + "/dhcp-healthcheck", value["dhcp-healthcheck"], errors);
		}
		else {
			obj.dhcp_healthcheck = false;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateInterfaceTunnel(location, value, errors) {
	function parseVariant0(location, value, errors) {
		value = instantiateInterfaceTunnelMesh(location, value, errors);

		return value;
	}

	function parseVariant1(location, value, errors) {
		value = instantiateInterfaceTunnelVxlan(location, value, errors);

		return value;
	}

	function parseVariant2(location, value, errors) {
		value = instantiateInterfaceTunnelL2tp(location, value, errors);

		return value;
	}

	function parseVariant3(location, value, errors) {
		value = instantiateInterfaceTunnelGre(location, value, errors);

		return value;
	}

	function parseVariant4(location, value, errors) {
		value = instantiateInterfaceTunnelGre6(location, value, errors);

		return value;
	}

	let success = 0, tryval, tryerr, vvalue = null, verrors = [];

	tryerr = [];
	tryval = parseVariant0(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	tryerr = [];
	tryval = parseVariant1(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	tryerr = [];
	tryval = parseVariant2(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	tryerr = [];
	tryval = parseVariant3(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	tryerr = [];
	tryval = parseVariant4(location, value, tryerr);
	if (!length(tryerr)) {
		if (type(vvalue) == "object" && type(tryval) == "object")
			vvalue = { ...vvalue, ...tryval };
		else
			vvalue = tryval;

		success++;
	}
	else {
		push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
	}

	if (success != 1) {
		if (length(verrors))
			push(errors, [ location, "must match exactly one of the following constraints:\n" + join("\n- or -\n", verrors) ]);
		else
			push(errors, [ location, "must match only one variant" ]);
		return null;
	}

	value = vvalue;

	return value;
}

function instantiateInterface(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseName(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "name")) {
			obj.name = parseName(location + "/name", value["name"], errors);
		}

		function parseRole(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "upstream", "downstream" ]))
				push(errors, [ location, "must be one of \"upstream\" or \"downstream\"" ]);

			return value;
		}

		if (exists(value, "role")) {
			obj.role = parseRole(location + "/role", value["role"], errors);
		}

		function parseIsolateHosts(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "isolate-hosts")) {
			obj.isolate_hosts = parseIsolateHosts(location + "/isolate-hosts", value["isolate-hosts"], errors);
		}

		function parseMetric(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 4294967295)
					push(errors, [ location, "must be lower than or equal to 4294967295" ]);

				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "metric")) {
			obj.metric = parseMetric(location + "/metric", value["metric"], errors);
		}

		function parseMtu(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 1500)
					push(errors, [ location, "must be lower than or equal to 1500" ]);

				if (value < 1280)
					push(errors, [ location, "must be bigger than or equal to 1280" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "mtu")) {
			obj.mtu = parseMtu(location + "/mtu", value["mtu"], errors);
		}

		function parseServices(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "services")) {
			obj.services = parseServices(location + "/services", value["services"], errors);
		}

		function parseVlanAwareness(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseFirst(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "first")) {
					obj.first = parseFirst(location + "/first", value["first"], errors);
				}

				function parseLast(location, value, errors) {
					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "last")) {
					obj.last = parseLast(location + "/last", value["last"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "vlan-awareness")) {
			obj.vlan_awareness = parseVlanAwareness(location + "/vlan-awareness", value["vlan-awareness"], errors);
		}

		if (exists(value, "vlan")) {
			obj.vlan = instantiateInterfaceVlan(location + "/vlan", value["vlan"], errors);
		}

		if (exists(value, "bridge")) {
			obj.bridge = instantiateInterfaceBridge(location + "/bridge", value["bridge"], errors);
		}

		function parseEthernet(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateInterfaceEthernet(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "ethernet")) {
			obj.ethernet = parseEthernet(location + "/ethernet", value["ethernet"], errors);
		}

		if (exists(value, "ipv4")) {
			obj.ipv4 = instantiateInterfaceIpv4(location + "/ipv4", value["ipv4"], errors);
		}

		if (exists(value, "ipv6")) {
			obj.ipv6 = instantiateInterfaceIpv6(location + "/ipv6", value["ipv6"], errors);
		}

		if (exists(value, "acl")) {
			obj.acl = instantiateInterfaceAcl(location + "/acl", value["acl"], errors);
		}

		if (exists(value, "dhcp-snoop-port")) {
			obj.dhcp_snoop_port = instantiateInterfaceDhcpSnoopPort(location + "/dhcp-snoop-port", value["dhcp-snoop-port"], errors);
		}

		if (exists(value, "broad-band")) {
			obj.broad_band = instantiateInterfaceBroadBand(location + "/broad-band", value["broad-band"], errors);
		}

		if (exists(value, "tunnel")) {
			obj.tunnel = instantiateInterfaceTunnel(location + "/tunnel", value["tunnel"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceLldp(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseDescribe(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "describe")) {
			obj.describe = parseDescribe(location + "/describe", value["describe"], errors);
		}
		else {
			obj.describe = "uCentral Access Point";
		}

		function parseLocation(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "location")) {
			obj.location = parseLocation(location + "/location", value["location"], errors);
		}
		else {
			obj.location = "uCentral Network";
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceSsh(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parsePort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "port")) {
			obj.port = parsePort(location + "/port", value["port"], errors);
		}
		else {
			obj.port = 22;
		}

		function parseAuthorizedKeys(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "authorized-keys")) {
			obj.authorized_keys = parseAuthorizedKeys(location + "/authorized-keys", value["authorized-keys"], errors);
		}

		function parsePasswordAuthentication(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "password-authentication")) {
			obj.password_authentication = parsePasswordAuthentication(location + "/password-authentication", value["password-authentication"], errors);
		}
		else {
			obj.password_authentication = true;
		}

		function parseEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enable")) {
			obj.enable = parseEnable(location + "/enable", value["enable"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceNtp(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseServers(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "string") {
						if (!matchUcHost(value))
							push(errors, [ location, "must be a valid hostname or IP address" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "servers")) {
			obj.servers = parseServers(location + "/servers", value["servers"], errors);
		}

		function parseLocalServer(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "local-server")) {
			obj.local_server = parseLocalServer(location + "/local-server", value["local-server"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceMdns(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enable")) {
			obj.enable = parseEnable(location + "/enable", value["enable"], errors);
		}
		else {
			obj.enable = false;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceRtty(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseHost(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcHost(value))
					push(errors, [ location, "must be a valid hostname or IP address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "host")) {
			obj.host = parseHost(location + "/host", value["host"], errors);
		}

		function parsePort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "port")) {
			obj.port = parsePort(location + "/port", value["port"], errors);
		}
		else {
			obj.port = 5912;
		}

		function parseToken(location, value, errors) {
			if (type(value) == "string") {
				if (length(value) > 32)
					push(errors, [ location, "must be at most 32 characters long" ]);

				if (length(value) < 32)
					push(errors, [ location, "must be at least 32 characters long" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "token")) {
			obj.token = parseToken(location + "/token", value["token"], errors);
		}

		function parseMutualTls(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "mutual-tls")) {
			obj.mutual_tls = parseMutualTls(location + "/mutual-tls", value["mutual-tls"], errors);
		}
		else {
			obj.mutual_tls = true;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceLog(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseHost(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcHost(value))
					push(errors, [ location, "must be a valid hostname or IP address" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "host")) {
			obj.host = parseHost(location + "/host", value["host"], errors);
		}

		function parsePort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 100)
					push(errors, [ location, "must be bigger than or equal to 100" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "port")) {
			obj.port = parsePort(location + "/port", value["port"], errors);
		}

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (!(value in [ "tcp", "udp" ]))
				push(errors, [ location, "must be one of \"tcp\" or \"udp\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}
		else {
			obj.proto = "udp";
		}

		function parseSize(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value < 32)
					push(errors, [ location, "must be bigger than or equal to 32" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "size")) {
			obj.size = parseSize(location + "/size", value["size"], errors);
		}
		else {
			obj.size = 1000;
		}

		function parsePriority(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value < 0)
					push(errors, [ location, "must be bigger than or equal to 0" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "priority")) {
			obj.priority = parsePriority(location + "/priority", value["priority"], errors);
		}
		else {
			obj.priority = 7;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceHttp(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseHttpPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "http-port")) {
			obj.http_port = parseHttpPort(location + "/http-port", value["http-port"], errors);
		}
		else {
			obj.http_port = 80;
		}

		function parseEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enable")) {
			obj.enable = parseEnable(location + "/enable", value["enable"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceIgmp(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enable")) {
			obj.enable = parseEnable(location + "/enable", value["enable"], errors);
		}
		else {
			obj.enable = false;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceRadiusProxy(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProxySecret(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "proxy-secret")) {
			obj.proxy_secret = parseProxySecret(location + "/proxy-secret", value["proxy-secret"], errors);
		}
		else {
			obj.proxy_secret = "secret";
		}

		function parseRealms(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					function parseVariant0(location, value, errors) {
						if (type(value) == "object") {
							let obj = {};

							function parseProtocol(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								if (!(value in [ "radsec" ]))
									push(errors, [ location, "must be one of \"radsec\"" ]);

								return value;
							}

							if (exists(value, "protocol")) {
								obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
							}
							else {
								obj.protocol = "radsec";
							}

							function parseRealm(location, value, errors) {
								if (type(value) == "array") {
									function parseItem(location, value, errors) {
										if (type(value) != "string")
											push(errors, [ location, "must be of type string" ]);

										return value;
									}

									return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
								}

								if (type(value) != "array")
									push(errors, [ location, "must be of type array" ]);

								return value;
							}

							if (exists(value, "realm")) {
								obj.realm = parseRealm(location + "/realm", value["realm"], errors);
							}

							function parseAutoDiscover(location, value, errors) {
								if (type(value) != "bool")
									push(errors, [ location, "must be of type boolean" ]);

								return value;
							}

							if (exists(value, "auto-discover")) {
								obj.auto_discover = parseAutoDiscover(location + "/auto-discover", value["auto-discover"], errors);
							}
							else {
								obj.auto_discover = false;
							}

							function parseHost(location, value, errors) {
								if (type(value) == "string") {
									if (!matchUcHost(value))
										push(errors, [ location, "must be a valid hostname or IP address" ]);

								}

								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "host")) {
								obj.host = parseHost(location + "/host", value["host"], errors);
							}

							function parsePort(location, value, errors) {
								if (type(value) in [ "int", "double" ]) {
									if (value > 65535)
										push(errors, [ location, "must be lower than or equal to 65535" ]);

								}

								if (type(value) != "int")
									push(errors, [ location, "must be of type integer" ]);

								return value;
							}

							if (exists(value, "port")) {
								obj.port = parsePort(location + "/port", value["port"], errors);
							}
							else {
								obj.port = 2083;
							}

							function parseSecret(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "secret")) {
								obj.secret = parseSecret(location + "/secret", value["secret"], errors);
							}

							function parseUseLocalCertificates(location, value, errors) {
								if (type(value) != "bool")
									push(errors, [ location, "must be of type boolean" ]);

								return value;
							}

							if (exists(value, "use-local-certificates")) {
								obj.use_local_certificates = parseUseLocalCertificates(location + "/use-local-certificates", value["use-local-certificates"], errors);
							}
							else {
								obj.use_local_certificates = false;
							}

							function parseCaCertificate(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "ca-certificate")) {
								obj.ca_certificate = parseCaCertificate(location + "/ca-certificate", value["ca-certificate"], errors);
							}

							function parseCertificate(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "certificate")) {
								obj.certificate = parseCertificate(location + "/certificate", value["certificate"], errors);
							}

							function parsePrivateKey(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "private-key")) {
								obj.private_key = parsePrivateKey(location + "/private-key", value["private-key"], errors);
							}

							function parsePrivateKeyPassword(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "private-key-password")) {
								obj.private_key_password = parsePrivateKeyPassword(location + "/private-key-password", value["private-key-password"], errors);
							}

							return obj;
						}

						if (type(value) != "object")
							push(errors, [ location, "must be of type object" ]);

						return value;
					}

					function parseVariant1(location, value, errors) {
						if (type(value) == "object") {
							let obj = {};

							function parseProtocol(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								if (!(value in [ "radius" ]))
									push(errors, [ location, "must be one of \"radius\"" ]);

								return value;
							}

							if (exists(value, "protocol")) {
								obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
							}

							function parseRealm(location, value, errors) {
								if (type(value) == "array") {
									function parseItem(location, value, errors) {
										if (type(value) != "string")
											push(errors, [ location, "must be of type string" ]);

										return value;
									}

									return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
								}

								if (type(value) != "array")
									push(errors, [ location, "must be of type array" ]);

								return value;
							}

							if (exists(value, "realm")) {
								obj.realm = parseRealm(location + "/realm", value["realm"], errors);
							}

							function parseAuthServer(location, value, errors) {
								if (type(value) == "string") {
									if (!matchUcHost(value))
										push(errors, [ location, "must be a valid hostname or IP address" ]);

								}

								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "auth-server")) {
								obj.auth_server = parseAuthServer(location + "/auth-server", value["auth-server"], errors);
							}

							function parseAuthPort(location, value, errors) {
								if (type(value) in [ "int", "double" ]) {
									if (value > 65535)
										push(errors, [ location, "must be lower than or equal to 65535" ]);

									if (value < 1024)
										push(errors, [ location, "must be bigger than or equal to 1024" ]);

								}

								if (type(value) != "int")
									push(errors, [ location, "must be of type integer" ]);

								return value;
							}

							if (exists(value, "auth-port")) {
								obj.auth_port = parseAuthPort(location + "/auth-port", value["auth-port"], errors);
							}

							function parseAuthSecret(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "auth-secret")) {
								obj.auth_secret = parseAuthSecret(location + "/auth-secret", value["auth-secret"], errors);
							}

							function parseAcctServer(location, value, errors) {
								if (type(value) == "string") {
									if (!matchUcHost(value))
										push(errors, [ location, "must be a valid hostname or IP address" ]);

								}

								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "acct-server")) {
								obj.acct_server = parseAcctServer(location + "/acct-server", value["acct-server"], errors);
							}

							function parseAcctPort(location, value, errors) {
								if (type(value) in [ "int", "double" ]) {
									if (value > 65535)
										push(errors, [ location, "must be lower than or equal to 65535" ]);

									if (value < 1024)
										push(errors, [ location, "must be bigger than or equal to 1024" ]);

								}

								if (type(value) != "int")
									push(errors, [ location, "must be of type integer" ]);

								return value;
							}

							if (exists(value, "acct-port")) {
								obj.acct_port = parseAcctPort(location + "/acct-port", value["acct-port"], errors);
							}

							function parseAcctSecret(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "acct-secret")) {
								obj.acct_secret = parseAcctSecret(location + "/acct-secret", value["acct-secret"], errors);
							}

							return obj;
						}

						if (type(value) != "object")
							push(errors, [ location, "must be of type object" ]);

						return value;
					}

					function parseVariant2(location, value, errors) {
						if (type(value) == "object") {
							let obj = {};

							function parseProtocol(location, value, errors) {
								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								if (!(value in [ "block" ]))
									push(errors, [ location, "must be one of \"block\"" ]);

								return value;
							}

							if (exists(value, "protocol")) {
								obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
							}

							function parseRealm(location, value, errors) {
								if (type(value) == "array") {
									function parseItem(location, value, errors) {
										if (type(value) != "string")
											push(errors, [ location, "must be of type string" ]);

										return value;
									}

									return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
								}

								if (type(value) != "array")
									push(errors, [ location, "must be of type array" ]);

								return value;
							}

							if (exists(value, "realm")) {
								obj.realm = parseRealm(location + "/realm", value["realm"], errors);
							}

							function parseMessage(location, value, errors) {
								if (type(value) == "array") {
									function parseItem(location, value, errors) {
										if (type(value) != "string")
											push(errors, [ location, "must be of type string" ]);

										return value;
									}

									return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
								}

								if (type(value) != "string")
									push(errors, [ location, "must be of type string" ]);

								return value;
							}

							if (exists(value, "message")) {
								obj.message = parseMessage(location + "/message", value["message"], errors);
							}

							return obj;
						}

						if (type(value) != "object")
							push(errors, [ location, "must be of type object" ]);

						return value;
					}

					let success = 0, tryval, tryerr, vvalue = null, verrors = [];

					tryerr = [];
					tryval = parseVariant0(location, value, tryerr);
					if (!length(tryerr)) {
						if (type(vvalue) == "object" && type(tryval) == "object")
							vvalue = { ...vvalue, ...tryval };
						else
							vvalue = tryval;

						success++;
					}
					else {
						push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
					}

					tryerr = [];
					tryval = parseVariant1(location, value, tryerr);
					if (!length(tryerr)) {
						if (type(vvalue) == "object" && type(tryval) == "object")
							vvalue = { ...vvalue, ...tryval };
						else
							vvalue = tryval;

						success++;
					}
					else {
						push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
					}

					tryerr = [];
					tryval = parseVariant2(location, value, tryerr);
					if (!length(tryerr)) {
						if (type(vvalue) == "object" && type(tryval) == "object")
							vvalue = { ...vvalue, ...tryval };
						else
							vvalue = tryval;

						success++;
					}
					else {
						push(verrors, join(" and\n", map(tryerr, err => "\t - " + err[1])));
					}

					if (success == 0) {
						if (length(verrors))
							push(errors, [ location, "must match at least one of the following constraints:\n" + join("\n- or -\n", verrors) ]);
						else
							push(errors, [ location, "must match only one variant" ]);
						return null;
					}

					value = vvalue;

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "realms")) {
			obj.realms = parseRealms(location + "/realms", value["realms"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceOnlineCheck(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parsePingHosts(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "string") {
						if (!matchUcHost(value))
							push(errors, [ location, "must be a valid hostname or IP address" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "ping-hosts")) {
			obj.ping_hosts = parsePingHosts(location + "/ping-hosts", value["ping-hosts"], errors);
		}

		function parseDownloadHosts(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "download-hosts")) {
			obj.download_hosts = parseDownloadHosts(location + "/download-hosts", value["download-hosts"], errors);
		}

		function parseCheckInterval(location, value, errors) {
			if (!(type(value) in [ "int", "double" ]))
				push(errors, [ location, "must be of type number" ]);

			return value;
		}

		if (exists(value, "check-interval")) {
			obj.check_interval = parseCheckInterval(location + "/check-interval", value["check-interval"], errors);
		}
		else {
			obj.check_interval = 60;
		}

		function parseCheckThreshold(location, value, errors) {
			if (!(type(value) in [ "int", "double" ]))
				push(errors, [ location, "must be of type number" ]);

			return value;
		}

		if (exists(value, "check-threshold")) {
			obj.check_threshold = parseCheckThreshold(location + "/check-threshold", value["check-threshold"], errors);
		}
		else {
			obj.check_threshold = 1;
		}

		function parseAction(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "leds" ]))
						push(errors, [ location, "must be one of \"leds\"" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "action")) {
			obj.action = parseAction(location + "/action", value["action"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceDataPlane(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseIngressFilters(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseName(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "name")) {
							obj.name = parseName(location + "/name", value["name"], errors);
						}

						function parseProgram(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcBase64(value))
									push(errors, [ location, "must be a valid base64 encoded data" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "program")) {
							obj.program = parseProgram(location + "/program", value["program"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "ingress-filters")) {
			obj.ingress_filters = parseIngressFilters(location + "/ingress-filters", value["ingress-filters"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceQualityOfServiceClassSelector(location, value, errors) {
	if (type(value) != "string")
		push(errors, [ location, "must be of type string" ]);

	if (!(value in [ "CS0", "CS1", "CS2", "CS3", "CS4", "CS5", "CS6", "CS7", "AF11", "AF12", "AF13", "AF21", "AF22", "AF23", "AF31", "AF32", "AF33", "AF41", "AF42", "AF43", "DF", "EF", "VA", "LE" ]))
		push(errors, [ location, "must be one of \"CS0\", \"CS1\", \"CS2\", \"CS3\", \"CS4\", \"CS5\", \"CS6\", \"CS7\", \"AF11\", \"AF12\", \"AF13\", \"AF21\", \"AF22\", \"AF23\", \"AF31\", \"AF32\", \"AF33\", \"AF41\", \"AF42\", \"AF43\", \"DF\", \"EF\", \"VA\" or \"LE\"" ]);

	return value;
}

function instantiateServiceQualityOfService(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseSelectPorts(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "select-ports")) {
			obj.select_ports = parseSelectPorts(location + "/select-ports", value["select-ports"], errors);
		}

		function parseBandwidthUp(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "bandwidth-up")) {
			obj.bandwidth_up = parseBandwidthUp(location + "/bandwidth-up", value["bandwidth-up"], errors);
		}
		else {
			obj.bandwidth_up = 0;
		}

		function parseBandwidthDown(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "bandwidth-down")) {
			obj.bandwidth_down = parseBandwidthDown(location + "/bandwidth-down", value["bandwidth-down"], errors);
		}
		else {
			obj.bandwidth_down = 0;
		}

		function parseBulkDetection(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				if (exists(value, "dscp")) {
					obj.dscp = instantiateServiceQualityOfServiceClassSelector(location + "/dscp", value["dscp"], errors);
				}
				else {
					obj.dscp = "CS0";
				}

				function parsePacketsPerSecond(location, value, errors) {
					if (!(type(value) in [ "int", "double" ]))
						push(errors, [ location, "must be of type number" ]);

					return value;
				}

				if (exists(value, "packets-per-second")) {
					obj.packets_per_second = parsePacketsPerSecond(location + "/packets-per-second", value["packets-per-second"], errors);
				}
				else {
					obj.packets_per_second = 0;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "bulk-detection")) {
			obj.bulk_detection = parseBulkDetection(location + "/bulk-detection", value["bulk-detection"], errors);
		}

		function parseServices(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "services")) {
			obj.services = parseServices(location + "/services", value["services"], errors);
		}

		function parseClassifier(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						if (exists(value, "dscp")) {
							obj.dscp = instantiateServiceQualityOfServiceClassSelector(location + "/dscp", value["dscp"], errors);
						}
						else {
							obj.dscp = "CS1";
						}

						function parsePorts(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseProtocol(location, value, errors) {
											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											if (!(value in [ "any", "tcp", "udp" ]))
												push(errors, [ location, "must be one of \"any\", \"tcp\" or \"udp\"" ]);

											return value;
										}

										if (exists(value, "protocol")) {
											obj.protocol = parseProtocol(location + "/protocol", value["protocol"], errors);
										}
										else {
											obj.protocol = "any";
										}

										function parsePort(location, value, errors) {
											if (type(value) != "int")
												push(errors, [ location, "must be of type integer" ]);

											return value;
										}

										if (exists(value, "port")) {
											obj.port = parsePort(location + "/port", value["port"], errors);
										}

										function parseRangeEnd(location, value, errors) {
											if (type(value) != "int")
												push(errors, [ location, "must be of type integer" ]);

											return value;
										}

										if (exists(value, "range-end")) {
											obj.range_end = parseRangeEnd(location + "/range-end", value["range-end"], errors);
										}

										function parseReclassify(location, value, errors) {
											if (type(value) != "bool")
												push(errors, [ location, "must be of type boolean" ]);

											return value;
										}

										if (exists(value, "reclassify")) {
											obj.reclassify = parseReclassify(location + "/reclassify", value["reclassify"], errors);
										}
										else {
											obj.reclassify = true;
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "ports")) {
							obj.ports = parsePorts(location + "/ports", value["ports"], errors);
						}

						function parseDns(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "object") {
										let obj = {};

										function parseFqdn(location, value, errors) {
											if (type(value) == "string") {
												if (!matchUcFqdn(value))
													push(errors, [ location, "must be a valid fully qualified domain name" ]);

											}

											if (type(value) != "string")
												push(errors, [ location, "must be of type string" ]);

											return value;
										}

										if (exists(value, "fqdn")) {
											obj.fqdn = parseFqdn(location + "/fqdn", value["fqdn"], errors);
										}

										function parseSuffixMatching(location, value, errors) {
											if (type(value) != "bool")
												push(errors, [ location, "must be of type boolean" ]);

											return value;
										}

										if (exists(value, "suffix-matching")) {
											obj.suffix_matching = parseSuffixMatching(location + "/suffix-matching", value["suffix-matching"], errors);
										}
										else {
											obj.suffix_matching = true;
										}

										function parseReclassify(location, value, errors) {
											if (type(value) != "bool")
												push(errors, [ location, "must be of type boolean" ]);

											return value;
										}

										if (exists(value, "reclassify")) {
											obj.reclassify = parseReclassify(location + "/reclassify", value["reclassify"], errors);
										}
										else {
											obj.reclassify = true;
										}

										return obj;
									}

									if (type(value) != "object")
										push(errors, [ location, "must be of type object" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "dns")) {
							obj.dns = parseDns(location + "/dns", value["dns"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "classifier")) {
			obj.classifier = parseClassifier(location + "/classifier", value["classifier"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceWireguardOverlay(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseProto(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			if (value != "wireguard-overlay")
				push(errors, [ location, "must have value \"wireguard-overlay\"" ]);

			return value;
		}

		if (exists(value, "proto")) {
			obj.proto = parseProto(location + "/proto", value["proto"], errors);
		}

		function parsePrivateKey(location, value, errors) {
			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "private-key")) {
			obj.private_key = parsePrivateKey(location + "/private-key", value["private-key"], errors);
		}

		function parsePeerPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "peer-port")) {
			obj.peer_port = parsePeerPort(location + "/peer-port", value["peer-port"], errors);
		}
		else {
			obj.peer_port = 3456;
		}

		function parsePeerExchangePort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "peer-exchange-port")) {
			obj.peer_exchange_port = parsePeerExchangePort(location + "/peer-exchange-port", value["peer-exchange-port"], errors);
		}
		else {
			obj.peer_exchange_port = 3458;
		}

		function parseRootNode(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parseKey(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "key")) {
					obj.key = parseKey(location + "/key", value["key"], errors);
				}

				function parseEndpoint(location, value, errors) {
					if (type(value) == "string") {
						if (!matchUcIp(value))
							push(errors, [ location, "must be a valid IPv4 or IPv6 address" ]);

					}

					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				if (exists(value, "endpoint")) {
					obj.endpoint = parseEndpoint(location + "/endpoint", value["endpoint"], errors);
				}

				function parseIpaddr(location, value, errors) {
					if (type(value) == "array") {
						function parseItem(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcIp(value))
									push(errors, [ location, "must be a valid IPv4 or IPv6 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
					}

					if (type(value) != "array")
						push(errors, [ location, "must be of type array" ]);

					return value;
				}

				if (exists(value, "ipaddr")) {
					obj.ipaddr = parseIpaddr(location + "/ipaddr", value["ipaddr"], errors);
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "root-node")) {
			obj.root_node = parseRootNode(location + "/root-node", value["root-node"], errors);
		}

		function parseHosts(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) == "object") {
						let obj = {};

						function parseName(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "name")) {
							obj.name = parseName(location + "/name", value["name"], errors);
						}

						function parseKey(location, value, errors) {
							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "key")) {
							obj.key = parseKey(location + "/key", value["key"], errors);
						}

						function parseEndpoint(location, value, errors) {
							if (type(value) == "string") {
								if (!matchUcIp(value))
									push(errors, [ location, "must be a valid IPv4 or IPv6 address" ]);

							}

							if (type(value) != "string")
								push(errors, [ location, "must be of type string" ]);

							return value;
						}

						if (exists(value, "endpoint")) {
							obj.endpoint = parseEndpoint(location + "/endpoint", value["endpoint"], errors);
						}

						function parseSubnet(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "string") {
										if (!matchUcCidr(value))
											push(errors, [ location, "must be a valid IPv4 or IPv6 CIDR" ]);

									}

									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "subnet")) {
							obj.subnet = parseSubnet(location + "/subnet", value["subnet"], errors);
						}

						function parseIpaddr(location, value, errors) {
							if (type(value) == "array") {
								function parseItem(location, value, errors) {
									if (type(value) == "string") {
										if (!matchUcIp(value))
											push(errors, [ location, "must be a valid IPv4 or IPv6 address" ]);

									}

									if (type(value) != "string")
										push(errors, [ location, "must be of type string" ]);

									return value;
								}

								return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
							}

							if (type(value) != "array")
								push(errors, [ location, "must be of type array" ]);

							return value;
						}

						if (exists(value, "ipaddr")) {
							obj.ipaddr = parseIpaddr(location + "/ipaddr", value["ipaddr"], errors);
						}

						return obj;
					}

					if (type(value) != "object")
						push(errors, [ location, "must be of type object" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "hosts")) {
			obj.hosts = parseHosts(location + "/hosts", value["hosts"], errors);
		}

		function parseVxlan(location, value, errors) {
			if (type(value) == "object") {
				let obj = {};

				function parsePort(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 1)
							push(errors, [ location, "must be bigger than or equal to 1" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "port")) {
					obj.port = parsePort(location + "/port", value["port"], errors);
				}
				else {
					obj.port = 4789;
				}

				function parseMtu(location, value, errors) {
					if (type(value) in [ "int", "double" ]) {
						if (value > 65535)
							push(errors, [ location, "must be lower than or equal to 65535" ]);

						if (value < 256)
							push(errors, [ location, "must be bigger than or equal to 256" ]);

					}

					if (type(value) != "int")
						push(errors, [ location, "must be of type integer" ]);

					return value;
				}

				if (exists(value, "mtu")) {
					obj.mtu = parseMtu(location + "/mtu", value["mtu"], errors);
				}
				else {
					obj.mtu = 1420;
				}

				function parseIsolate(location, value, errors) {
					if (type(value) != "bool")
						push(errors, [ location, "must be of type boolean" ]);

					return value;
				}

				if (exists(value, "isolate")) {
					obj.isolate = parseIsolate(location + "/isolate", value["isolate"], errors);
				}
				else {
					obj.isolate = true;
				}

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "vxlan")) {
			obj.vxlan = parseVxlan(location + "/vxlan", value["vxlan"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceGps(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseAdjustTime(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "adjust-time")) {
			obj.adjust_time = parseAdjustTime(location + "/adjust-time", value["adjust-time"], errors);
		}
		else {
			obj.adjust_time = false;
		}

		function parseBaudRate(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			if (!(value in [ 2400, 4800, 9600, 19200 ]))
				push(errors, [ location, "must be one of 2400, 4800, 9600 or 19200" ]);

			return value;
		}

		if (exists(value, "baud-rate")) {
			obj.baud_rate = parseBaudRate(location + "/baud-rate", value["baud-rate"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceTelnet(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enable")) {
			obj.enable = parseEnable(location + "/enable", value["enable"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateServiceHttps(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseHttpsPort(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value > 65535)
					push(errors, [ location, "must be lower than or equal to 65535" ]);

				if (value < 1)
					push(errors, [ location, "must be bigger than or equal to 1" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "https-port")) {
			obj.https_port = parseHttpsPort(location + "/https-port", value["https-port"], errors);
		}
		else {
			obj.https_port = 443;
		}

		function parseEnable(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "enable")) {
			obj.enable = parseEnable(location + "/enable", value["enable"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateService(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		if (exists(value, "lldp")) {
			obj.lldp = instantiateServiceLldp(location + "/lldp", value["lldp"], errors);
		}

		if (exists(value, "ssh")) {
			obj.ssh = instantiateServiceSsh(location + "/ssh", value["ssh"], errors);
		}

		if (exists(value, "ntp")) {
			obj.ntp = instantiateServiceNtp(location + "/ntp", value["ntp"], errors);
		}

		if (exists(value, "mdns")) {
			obj.mdns = instantiateServiceMdns(location + "/mdns", value["mdns"], errors);
		}

		if (exists(value, "rtty")) {
			obj.rtty = instantiateServiceRtty(location + "/rtty", value["rtty"], errors);
		}

		if (exists(value, "log")) {
			obj.log = instantiateServiceLog(location + "/log", value["log"], errors);
		}

		if (exists(value, "http")) {
			obj.http = instantiateServiceHttp(location + "/http", value["http"], errors);
		}

		if (exists(value, "igmp")) {
			obj.igmp = instantiateServiceIgmp(location + "/igmp", value["igmp"], errors);
		}

		if (exists(value, "radius-proxy")) {
			obj.radius_proxy = instantiateServiceRadiusProxy(location + "/radius-proxy", value["radius-proxy"], errors);
		}

		if (exists(value, "online-check")) {
			obj.online_check = instantiateServiceOnlineCheck(location + "/online-check", value["online-check"], errors);
		}

		if (exists(value, "data-plane")) {
			obj.data_plane = instantiateServiceDataPlane(location + "/data-plane", value["data-plane"], errors);
		}

		if (exists(value, "quality-of-service")) {
			obj.quality_of_service = instantiateServiceQualityOfService(location + "/quality-of-service", value["quality-of-service"], errors);
		}

		if (exists(value, "wireguard-overlay")) {
			obj.wireguard_overlay = instantiateServiceWireguardOverlay(location + "/wireguard-overlay", value["wireguard-overlay"], errors);
		}

		if (exists(value, "gps")) {
			obj.gps = instantiateServiceGps(location + "/gps", value["gps"], errors);
		}

		if (exists(value, "telnet")) {
			obj.telnet = instantiateServiceTelnet(location + "/telnet", value["telnet"], errors);
		}

		if (exists(value, "https")) {
			obj.https = instantiateServiceHttps(location + "/https", value["https"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateMetricsStatistics(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseInterval(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value < 60)
					push(errors, [ location, "must be bigger than or equal to 60" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "interval")) {
			obj.interval = parseInterval(location + "/interval", value["interval"], errors);
		}

		function parseTypes(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "lldp", "clients" ]))
						push(errors, [ location, "must be one of \"lldp\" or \"clients\"" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "types")) {
			obj.types = parseTypes(location + "/types", value["types"], errors);
		}

		function parseWiredClientsMaxNum(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "wired-clients-max-num")) {
			obj.wired_clients_max_num = parseWiredClientsMaxNum(location + "/wired-clients-max-num", value["wired-clients-max-num"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateMetricsHealth(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseInterval(location, value, errors) {
			if (type(value) in [ "int", "double" ]) {
				if (value < 60)
					push(errors, [ location, "must be bigger than or equal to 60" ]);

			}

			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "interval")) {
			obj.interval = parseInterval(location + "/interval", value["interval"], errors);
		}

		function parseDhcpLocal(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dhcp-local")) {
			obj.dhcp_local = parseDhcpLocal(location + "/dhcp-local", value["dhcp-local"], errors);
		}
		else {
			obj.dhcp_local = true;
		}

		function parseDhcpRemote(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dhcp-remote")) {
			obj.dhcp_remote = parseDhcpRemote(location + "/dhcp-remote", value["dhcp-remote"], errors);
		}
		else {
			obj.dhcp_remote = false;
		}

		function parseDnsLocal(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dns-local")) {
			obj.dns_local = parseDnsLocal(location + "/dns-local", value["dns-local"], errors);
		}
		else {
			obj.dns_local = true;
		}

		function parseDnsRemote(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "dns-remote")) {
			obj.dns_remote = parseDnsRemote(location + "/dns-remote", value["dns-remote"], errors);
		}
		else {
			obj.dns_remote = true;
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateMetricsDhcpSnooping(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseFilters(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "ack", "discover", "offer", "request", "solicit", "reply", "renew" ]))
						push(errors, [ location, "must be one of \"ack\", \"discover\", \"offer\", \"request\", \"solicit\", \"reply\" or \"renew\"" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "filters")) {
			obj.filters = parseFilters(location + "/filters", value["filters"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateMetricsTelemetry(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseInterval(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "interval")) {
			obj.interval = parseInterval(location + "/interval", value["interval"], errors);
		}

		function parseTypes(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "ssh", "health", "health.dns", "health.dhcp", "health.radius", "health.memory", "client", "client.join", "client.leave", "client.key-mismatch", "wired", "wired.carrier-up", "wired.carrier-down", "unit", "unit.boot-up" ]))
						push(errors, [ location, "must be one of \"ssh\", \"health\", \"health.dns\", \"health.dhcp\", \"health.radius\", \"health.memory\", \"client\", \"client.join\", \"client.leave\", \"client.key-mismatch\", \"wired\", \"wired.carrier-up\", \"wired.carrier-down\", \"unit\" or \"unit.boot-up\"" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "types")) {
			obj.types = parseTypes(location + "/types", value["types"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateMetricsRealtime(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseTypes(location, value, errors) {
			if (type(value) == "array") {
				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					if (!(value in [ "ssh", "health", "health.dns", "health.dhcp", "health.radius", "health.memory", "client", "client.join", "client.leave", "client.key-mismatch", "wired", "wired.carrier-up", "wired.carrier-down", "unit", "unit.boot-up" ]))
						push(errors, [ location, "must be one of \"ssh\", \"health\", \"health.dns\", \"health.dhcp\", \"health.radius\", \"health.memory\", \"client\", \"client.join\", \"client.leave\", \"client.key-mismatch\", \"wired\", \"wired.carrier-up\", \"wired.carrier-down\", \"unit\" or \"unit.boot-up\"" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "types")) {
			obj.types = parseTypes(location + "/types", value["types"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateMetrics(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		if (exists(value, "statistics")) {
			obj.statistics = instantiateMetricsStatistics(location + "/statistics", value["statistics"], errors);
		}

		if (exists(value, "health")) {
			obj.health = instantiateMetricsHealth(location + "/health", value["health"], errors);
		}

		if (exists(value, "dhcp-snooping")) {
			obj.dhcp_snooping = instantiateMetricsDhcpSnooping(location + "/dhcp-snooping", value["dhcp-snooping"], errors);
		}

		if (exists(value, "telemetry")) {
			obj.telemetry = instantiateMetricsTelemetry(location + "/telemetry", value["telemetry"], errors);
		}

		if (exists(value, "realtime")) {
			obj.realtime = instantiateMetricsRealtime(location + "/realtime", value["realtime"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

function instantiateConfigRaw(location, value, errors) {
	if (type(value) == "array") {
		function parseItem(location, value, errors) {
			if (type(value) == "array") {
				if (length(value) < 2)
					push(errors, [ location, "must have at least 2 items" ]);

				function parseItem(location, value, errors) {
					if (type(value) != "string")
						push(errors, [ location, "must be of type string" ]);

					return value;
				}

				return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		return map(value, (item, i) => parseItem(location + "/" + i, item, errors));
	}

	if (type(value) != "array")
		push(errors, [ location, "must be of type array" ]);

	return value;
}

function newUCentralState(location, value, errors) {
	if (type(value) == "object") {
		let obj = {};

		function parseStrict(location, value, errors) {
			if (type(value) != "bool")
				push(errors, [ location, "must be of type boolean" ]);

			return value;
		}

		if (exists(value, "strict")) {
			obj.strict = parseStrict(location + "/strict", value["strict"], errors);
		}
		else {
			obj.strict = false;
		}

		function parseUuid(location, value, errors) {
			if (type(value) != "int")
				push(errors, [ location, "must be of type integer" ]);

			return value;
		}

		if (exists(value, "uuid")) {
			obj.uuid = parseUuid(location + "/uuid", value["uuid"], errors);
		}

		function parsePublic_ip_lookup(location, value, errors) {
			if (type(value) == "string") {
				if (!matchUcFqdn(value))
					push(errors, [ location, "must be a valid fully qualified domain name" ]);

			}

			if (type(value) != "string")
				push(errors, [ location, "must be of type string" ]);

			return value;
		}

		if (exists(value, "public_ip_lookup")) {
			obj.public_ip_lookup = parsePublic_ip_lookup(location + "/public_ip_lookup", value["public_ip_lookup"], errors);
		}

		if (exists(value, "unit")) {
			obj.unit = instantiateUnit(location + "/unit", value["unit"], errors);
		}

		if (exists(value, "globals")) {
			obj.globals = instantiateGlobals(location + "/globals", value["globals"], errors);
		}

		function parseEthernet(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateEthernet(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "ethernet")) {
			obj.ethernet = parseEthernet(location + "/ethernet", value["ethernet"], errors);
		}

		if (exists(value, "switch")) {
			obj.switch = instantiateSwitch(location + "/switch", value["switch"], errors);
		}

		function parseInterfaces(location, value, errors) {
			if (type(value) == "array") {
				return map(value, (item, i) => instantiateInterface(location + "/" + i, item, errors));
			}

			if (type(value) != "array")
				push(errors, [ location, "must be of type array" ]);

			return value;
		}

		if (exists(value, "interfaces")) {
			obj.interfaces = parseInterfaces(location + "/interfaces", value["interfaces"], errors);
		}

		if (exists(value, "services")) {
			obj.services = instantiateService(location + "/services", value["services"], errors);
		}

		if (exists(value, "metrics")) {
			obj.metrics = instantiateMetrics(location + "/metrics", value["metrics"], errors);
		}

		if (exists(value, "config-raw")) {
			obj.config_raw = instantiateConfigRaw(location + "/config-raw", value["config-raw"], errors);
		}

		function parseThirdParty(location, value, errors) {
			if (type(value) == "object") {
				let obj = { ...value };

				return obj;
			}

			if (type(value) != "object")
				push(errors, [ location, "must be of type object" ]);

			return value;
		}

		if (exists(value, "third-party")) {
			obj.third_party = parseThirdParty(location + "/third-party", value["third-party"], errors);
		}

		return obj;
	}

	if (type(value) != "object")
		push(errors, [ location, "must be of type object" ]);

	return value;
}

return {
	validate: (value, errors) => {
		let err = [];
		let res = newUCentralState("", value, err);
		if (errors) push(errors, ...map(err, e => "[E] (In " + e[0] + ") Value " + e[1]));
		return length(err) ? null : res;
	}
};